Merge branch 'develop' into STR0001_TenonDT

- 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

.gitignore

@@ -0,0 +1 @@
+.vscode/settings.json

Beam.ini

@@ -0,0 +1,7 @@
+[Beam]
+BtlEnable=1
+BaseDir=C:\EgtData\Beam
+BtlExec=BatchProcess.lua
+Button1=Process.lua,Images\Process.png,Lavora Travi
+Button2=Swap.lua,Images\Swap.png,Scambia estremi trave
+Button3=Rotate.lua,Images\Rotate.png,Ruota trave

LuaLibs/BasicCustomerStrategies.lua

@@ -0,0 +1,577 @@
+--BasicCustomerStrategies.lua by Egalware s.r.l. 2024/04/02
+-- Libreria strategie di base disponibili per i clienti
+-- 2024/04/02 PRIMA VERSIONE CALCOLO LAVORAZIONI CON STRATEGIE
+
+-- Tabella per definizione modulo
+local BasicCustomerStrategies = {}
+
+-- Include
+require( 'EgtBase')
+
+-- Carico i dati globali
+local BeamData = require( 'BeamData')
+local ID = require( 'Identity')
+
+
+
+   -- TODO tabella da compleatare man mano che si inseriscono le varie strategie
+   -- ESEMPIO SCRITTURA TABELLA CON STRATEGIE DISPONIBILI
+   ---------------------------------------------------------------------
+   -- Feature : Cut
+   -- if ID.TipoFeature( Proc) then
+   --    if Proc.Topology.sName == 'QQQQQQQQQ' then
+   --       Strategies =  {
+   --                        {  sStrategyId = 'STR9999',
+   --                           Parameters = {
+   --                              { sName = 'Val_1', sValue = '15', sType = 'd'},
+   --                              { sName = 'Val_2', sValue = 'false', sType = 'b'}
+   --                           }
+   --                        }
+   --                        {  sStrategyId = 'STR9998'}
+   --                      }
+   --    end
+   -- end
+
+----------------------------------------------------------------------------------
+--    *** EGALWARE ***
+----------------------------------------------------------------------------------
+local function GetStrategies_Egalware( Proc)
+   local Strategies = {}
+
+   ---------------------------------------------------------------------
+   -- Feature : Cut
+   if ID.IsHeadCut( Proc) then
+      Strategies =  { { sStrategyId = 'HEADCUT'}}
+   ---------------------------------------------------------------------
+   -- Feature : Cut
+   elseif ID.IsTailCut( Proc) then
+      Strategies =  { { sStrategyId = 'TAILCUT'}}
+   ---------------------------------------------------------------------
+   -- Feature : Cut
+   elseif ID.IsCut( Proc) then
+      Strategies = { { sStrategyId = 'STR0005'}}
+   ---------------------------------------------------------------------
+   -- Feature : Longitudinal Cut
+   elseif ID.IsLongitudinalCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Double Cut
+   elseif ID.IsDoubleCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Ridge or Valley Cut
+   elseif ID.IsDoubleLongitudinalCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Saw Cut
+   elseif ID.IsSawCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Slot
+   elseif ID.IsSlot( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Front Slot
+   elseif ID.IsFrontSlot( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Birds Mouth
+   elseif ID.IsBirdsMouth( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Hip or Valley Rafter Notch
+   elseif ID.IsHipValleyRafterNotch( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Ridge Lap
+   elseif ID.IsRidgeLap( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Lap Joint
+   elseif ID.IsLapJoint( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Notch/Rabbet
+   elseif ID.IsNotchRabbet( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Block Haus
+   elseif ID.IsBlockHaus( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Notch
+   elseif ID.IsNotch( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : French Ridge Lap
+   elseif ID.IsFrenchRidgeLap( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Chamfer
+   elseif ID.IsChamfer( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Block Haus Half Lap
+   elseif ID.IsHalfBlockHaus( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Block Haus Front
+   elseif ID.IsFrontBlockHaus( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Pocket
+   elseif ID.IsPocket( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Drilling
+   elseif ID.IsDrilling( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Tenon
+   elseif ID.IsTenon( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Mortise
+   elseif ID.IsMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Front Mortise
+   elseif ID.IsFrontMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : House
+   elseif ID.IsHouse( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : House Mortise
+   elseif ID.IsHouseMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Dovetail Tenon
+   elseif ID.IsDovetailTenon( Proc) then
+      Strategies =  { { sStrategyId = 'STR0001'}}
+   ---------------------------------------------------------------------
+   -- Feature : Dovetail Mortise
+   elseif ID.IsDovetailMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Dovetail Mortise Front
+   elseif ID.IsFrontDovetailMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Marking
+   elseif ID.IsMarking( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Text
+   elseif ID.IsText( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Scarf Simple
+   elseif ID.IsScarfSimple( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Scarf Joint
+   elseif ID.IsScarfJoint( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Step Joint
+   elseif ID.IsStepJoint( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Step Joint Notch
+   elseif ID.IsStepJointNotch( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Planing
+   elseif ID.IsPlaning( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Front Profile
+   elseif ID.IsFrontProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Head Concave Profile
+   elseif ID.IsHeadConcaveProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Head Convex Profile
+   elseif ID.IsHeadConvexProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Head Cambered Profile
+   elseif ID.IsHeadCamberedProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Round Arch
+   elseif ID.IsRoundArch( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Head Profile
+   elseif ID.IsHeadProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Sphere
+   elseif ID.IsSphere( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Triangle Cut
+   elseif ID.IsTriangleCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : TyroleanDovetail
+   elseif ID.IsTyroleanDovetail( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Dovetail
+   elseif ID.IsDovetail( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Free Contour
+   elseif ID.IsFreeContour( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Outline
+   elseif ID.IsOutline( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Aperture
+   elseif ID.IsAperture( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Variant
+   elseif ID.IsVariant( Proc) then
+   ---------------------------------------------------------------------
+   end
+
+   return Strategies
+end
+
+----------------------------------------------------------------------------------
+--    *** ESSETRE ***
+----------------------------------------------------------------------------------
+local function GetStrategies_Essetre( Proc)
+   local Strategies = {}
+
+   ---------------------------------------------------------------------
+   -- Feature : Cut
+   if ID.IsHeadCut( Proc) then
+      Strategies =  { { sStrategyId = 'HEADCUT'}}
+   ---------------------------------------------------------------------
+   -- Feature : Cut
+   elseif ID.IsTailCut( Proc) then
+      Strategies =  { { sStrategyId = 'TAILCUT'}}
+   ---------------------------------------------------------------------
+   -- Feature : Cut
+   elseif ID.IsCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Longitudinal Cut
+   elseif ID.IsLongitudinalCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Double Cut
+   elseif ID.IsDoubleCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Ridge or Valley Cut
+   elseif ID.IsDoubleLongitudinalCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Saw Cut
+   elseif ID.IsSawCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Slot
+   elseif ID.IsSlot( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Front Slot
+   elseif ID.IsFrontSlot( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Birds Mouth
+   elseif ID.IsBirdsMouth( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Hip or Valley Rafter Notch
+   elseif ID.IsHipValleyRafterNotch( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Ridge Lap
+   elseif ID.IsRidgeLap( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Lap Joint
+   elseif ID.IsLapJoint( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Notch/Rabbet
+   elseif ID.IsNotchRabbet( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Block Haus
+   elseif ID.IsBlockHaus( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Notch
+   elseif ID.IsNotch( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : French Ridge Lap
+   elseif ID.IsFrenchRidgeLap( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Chamfer
+   elseif ID.IsChamfer( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Block Haus Half Lap
+   elseif ID.IsHalfBlockHaus( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Block Haus Front
+   elseif ID.IsFrontBlockHaus( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Pocket
+   elseif ID.IsPocket( Proc) then
+      if Proc.Topology.sName == 'Pocket-5-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-4-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}, { sStrategyId = 'STR0004'}}
+      elseif Proc.Topology.sName == 'Groove-3-Blind' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+         Strategies =  { { sStrategyId = 'STR0002'}}
+      end
+   ---------------------------------------------------------------------
+   -- Feature : Drilling
+   elseif ID.IsDrilling( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Tenon
+   elseif ID.IsTenon( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Mortise
+   elseif ID.IsMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Front Mortise
+   elseif ID.IsFrontMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : House
+   elseif ID.IsHouse( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : House Mortise
+   elseif ID.IsHouseMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Dovetail Tenon
+   elseif ID.IsDovetailTenon( Proc) then
+      Strategies =  { { sStrategyId = 'STR0001'}}
+   ---------------------------------------------------------------------
+   -- Feature : Dovetail Mortise
+   elseif ID.IsDovetailMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Dovetail Mortise Front
+   elseif ID.IsFrontDovetailMortise( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Marking
+   elseif ID.IsMarking( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Text
+   elseif ID.IsText( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Scarf Simple
+   elseif ID.IsScarfSimple( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Scarf Joint
+   elseif ID.IsScarfJoint( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Step Joint
+   elseif ID.IsStepJoint( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Step Joint Notch
+   elseif ID.IsStepJointNotch( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Planing
+   elseif ID.IsPlaning( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Front Profile
+   elseif ID.IsFrontProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Head Concave Profile
+   elseif ID.IsHeadConcaveProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Head Convex Profile
+   elseif ID.IsHeadConvexProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Head Cambered Profile
+   elseif ID.IsHeadCamberedProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Round Arch
+   elseif ID.IsRoundArch( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Head Profile
+   elseif ID.IsHeadProfile( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Sphere
+   elseif ID.IsSphere( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Triangle Cut
+   elseif ID.IsTriangleCut( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : TyroleanDovetail
+   elseif ID.IsTyroleanDovetail( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Dovetail
+   elseif ID.IsDovetail( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Free Contour
+   elseif ID.IsFreeContour( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Outline
+   elseif ID.IsOutline( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Aperture
+   elseif ID.IsAperture( Proc) then
+   ---------------------------------------------------------------------
+   -- Feature : Variant
+   elseif ID.IsVariant( Proc) then
+   ---------------------------------------------------------------------
+   end
+
+   return Strategies
+end
+
+----------------------------------------------------------------------------------
+--    *** Esecuzione ***
+----------------------------------------------------------------------------------
+
+-- script delle strategie di base standard definito con cliente (statico e non modificabile)
+-- se non esiste JSON configurazione, o se non ha trovato nessuna strategia, prova a cercare in questi script
+function BasicCustomerStrategies.GetStrategiesFromBasicCustomerStrategies( Proc)
+   local StrategiesFromScript = {}
+
+   -- se nessuno script specifico in BeamData, si carica standard di default EGALWARE
+   if not BeamData.STRATEGIES_SCRIPT or BeamData.STRATEGIES_SCRIPT == 'Egalware' then
+      StrategiesFromScript = GetStrategies_Egalware( Proc)
+   -- CLIENTE : ESSETRE
+   elseif BeamData.STRATEGIES_SCRIPT == 'Essetre' then
+      StrategiesFromScript = GetStrategies_Essetre( Proc)
+   else
+      StrategiesFromScript = nil
+   end
+   return StrategiesFromScript
+end
+
+-------------------------------------------------------------------------------------------------------------
+
+return BasicCustomerStrategies

LuaLibs/BeamLib.lua

@@ -0,0 +1,631 @@
+-- BeamLib.lua by Egalware s.r.l. 2024/04/02
+-- Libreria globale per Travi
+-- 2024/04/02 PRIMA VERSIONE CALCOLO LAVORAZIONI CON STRATEGIE
+
+
+-- Tabella per definizione modulo
+local BeamLib = {}
+
+-- Include
+require( 'EgtBase')
+local BeamData = require( 'BeamData')
+
+EgtOutLog( ' BeamLib started', 1)
+
+--TODO refactoring di queste funzioni
+
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.AddPartStartFace( PartId, b3Solid)
+   -- recupero gruppo per geometria aggiuntiva
+   local AddGrpId = BeamLib.GetAddGroup( PartId)
+   if not AddGrpId then
+      local sErr = 'Error on process StartFace impossible to find AddGroup'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+
+   -- aggiungo nuovo taglio iniziale
+   local nStmId = EgtSurfTmPlaneInBBox( AddGrpId, b3Solid:getMax(), X_AX(), b3Solid, GDB_RT.GLOB)
+   if not nStmId then
+      local sErr = 'Error on process StartFace impossible to create Face'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- applico gli opportuni attributi di feature
+   EgtSetName( nStmId, 'StartCut')
+   EgtSetInfo( nStmId, 'GRP', 1)
+   EgtSetInfo( nStmId, 'PRC', 340)
+   -- verifico se sostituisce un taglio di testa già presente
+   local nProcId = EgtGetFirstInGroup( EgtGetFirstNameInGroup( PartId, 'Processings') or GDB_ID.NULL)
+   while nProcId do
+      local nGrp = EgtGetInfo( nProcId, 'GRP', 'i') or 0
+      local nProc = EgtGetInfo( nProcId, 'PRC', 'i') or 0
+      if ( nGrp == 1 or nGrp == 2) and nProc == 10 then
+         local ptC, vtN = EgtSurfTmFacetCenter( nProcId, 0, GDB_ID.ROOT)
+         if ptC and vtN and AreSameVectorApprox( vtN, X_AX())  and  abs( ptC:getX() - b3Solid:getMax():getX()) < 10 * GEO.EPS_SMALL then
+            EgtSetInfo( nStmId, 'ORI', nProcId)
+         end
+      end
+      nProcId = EgtGetNext( nProcId)
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.AddPartEndFace( PartId, b3Solid)
+   -- recupero gruppo per geometria aggiuntiva
+   local AddGrpId = BeamLib.GetAddGroup( PartId)
+   if not AddGrpId then
+      local sErr = 'Error on process EndFace impossible to find AddGroup'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+
+   -- aggiungo nuovo taglio finale
+   local nStmId = EgtSurfTmPlaneInBBox( AddGrpId, b3Solid:getMin(), -X_AX(), b3Solid, GDB_RT.GLOB)
+   if not nStmId then
+      local sErr = 'Error on process EndFace impossible to create Face'
+      EgtOutLog( sErr)
+      return false, sErr
+   end
+   -- applico gli opportuni attributi di feature
+   EgtSetName( nStmId, 'EndCut')
+   EgtSetInfo( nStmId, 'GRP', 2)
+   EgtSetInfo( nStmId, 'PRC', 350)
+   -- verifico se sostituisce un taglio di coda già presente
+   local nProcId = EgtGetFirstInGroup( EgtGetFirstNameInGroup( PartId, 'Processings') or GDB_ID.NULL)
+   while nProcId do
+      local nGrp = EgtGetInfo( nProcId, 'GRP', 'i') or 0
+      local nProc = EgtGetInfo( nProcId, 'PRC', 'i') or 0
+      if ( nGrp == 1 or nGrp == 2) and nProc == 10 then
+         local ptC, vtN = EgtSurfTmFacetCenter( nProcId, 0, GDB_ID.ROOT)
+         if ptC and vtN and AreSameVectorApprox( vtN, -X_AX())  and  abs( ptC:getX() - b3Solid:getMin():getX()) < 10 * GEO.EPS_SMALL then
+            EgtSetInfo( nStmId, 'ORI', nProcId)
+         end
+      end
+      nProcId = EgtGetNext( nProcId)
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.GetPartSplittingPoints( Part, OptionalParameters)
+   local PartSplittingPoints = {}
+   local dPartLength = Part.b3Part:getDimX()
+
+   -- parametri opzionali
+   if not OptionalParameters then
+      OptionalParameters = {}
+   end
+   local dMaxSegmentLength = OptionalParameters.dMaxSegmentLength or BeamData.LONGCUT_MAXLEN
+   local dMaxSegmentLengthOnEdges = OptionalParameters.dMaxSegmentLengthOnEdges or BeamData.LONGCUT_ENDLEN
+
+   if dPartLength < dMaxSegmentLength + 10 * GEO.EPS_SMALL then
+      return {}
+   elseif dPartLength >= dMaxSegmentLength + 10 * GEO.EPS_SMALL
+          and dPartLength < 3 * dMaxSegmentLengthOnEdges + 10 * GEO.EPS_SMALL then
+      local dXPartCentralPoint = ( Part.b3Part:getMax():getX() - Part.b3Part:getMin():getX()) / 2
+      table.insert( PartSplittingPoints, Point3d( dXPartCentralPoint, 0, 0))
+   else
+      -- punto estremo destro
+      local dSplitXRight = Part.b3Part:getMax():getX() - dMaxSegmentLengthOnEdges
+      table.insert( PartSplittingPoints, Point3d( dSplitXRight, 0, 0))
+
+      -- punti centrali
+      local dPartCentralLength = dPartLength - 2 * dMaxSegmentLengthOnEdges
+      local nSplitParts = max( ceil( dPartCentralLength / dMaxSegmentLength + 10 * GEO.EPS_SMALL), 1)
+      local dSplitPartsLen = dPartCentralLength / nSplitParts
+      for i = 1, ( nSplitParts - 1) do
+         local ptOn
+         local dCurrentPointX = dSplitXRight - i * dSplitPartsLen
+         ptOn = Point3d( dCurrentPointX, 0, 0)
+         table.insert( PartSplittingPoints, ptOn)
+      end
+
+      -- punto estremo sinistro
+      local dSplitXLeft = Part.b3Part:getMin():getX() + dMaxSegmentLengthOnEdges
+      table.insert( PartSplittingPoints, Point3d( dSplitXLeft, 0, 0))
+   end
+
+   return PartSplittingPoints
+end
+
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.AddPhaseWithRawParts( nRawId, OriXR, PosXR, dDeltaSucc)
+   EgtAddPhase()
+   local dRawMove = 0
+   while nRawId do
+      EgtKeepRawPart( nRawId)
+      EgtMoveToCornerRawPart( nRawId, OriXR, PosXR)
+      EgtMoveRawPart( nRawId, Vector3d( - dRawMove, 0, 0))
+      if dRawMove == 0 then dRawMove = dRawMove + dDeltaSucc end
+      dRawMove = dRawMove + EgtGetRawPartBBox( nRawId):getDimX()
+      nRawId = EgtGetNextRawPart( nRawId)
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+--- funzione che ruota il pezzo, da lanciare per creare la disposizione corretta
+function BeamLib.RotatePart( Part, nPosition)
+   -- primo posizionamento
+   if nPosition == 1 then
+      ; -- il pezzo è già in posizione
+   -- rotazione 90°
+   elseif nPosition == 2 then
+      local dDeltaYZ = EgtGetRawPartBBox( Part.idRaw):getDimY() - EgtGetRawPartBBox( Part.idRaw):getDimZ()
+      local vtMove = Vector3d( 0, dDeltaYZ / 2 * EgtIf( BeamData.RIGHT_LOAD, -1, 1), dDeltaYZ / 2)
+      local bPreMove = dDeltaYZ < 0
+      -- ruoto le travi della fase corrente
+      local nRId = Part.idRaw
+      while nRId do
+         if bPreMove then EgtMoveRawPart( nRId, vtMove) end
+         EgtRotateRawPart( nRId, X_AX(), EgtIf( BeamData.RIGHT_LOAD, -90, 90))
+         if not bPreMove then EgtMoveRawPart( nRId, vtMove) end
+         nRId = EgtGetNextRawPart( nRId)
+      end
+   -- rotazione 180°
+   elseif nPosition == 3 then
+      -- ribalto le travi della fase corrente
+      local nRId = Part.idRaw
+      while nRId do
+         EgtRotateRawPart( nRId, X_AX(), 180)
+         nRId = EgtGetNextRawPart( nRId)
+      end
+   -- rotazione 270°
+   elseif nPosition == 4 then
+      local dDeltaYZ = EgtGetRawPartBBox( Part.idRaw):getDimY() - EgtGetRawPartBBox( Part.idRaw):getDimZ()
+      local vtMove = Vector3d( 0, dDeltaYZ / 2 * EgtIf( BeamData.RIGHT_LOAD, -1, 1), dDeltaYZ / 2)
+      local bPreMove = dDeltaYZ < 0
+      -- ruoto le travi della fase corrente
+      local nRId = Part.idRaw
+      while nRId do
+         if bPreMove then EgtMoveRawPart( nRId, vtMove) end
+         EgtRotateRawPart( nRId, X_AX(), EgtIf( BeamData.RIGHT_LOAD, 90, -90))
+         if not bPreMove then EgtMoveRawPart( nRId, vtMove) end
+         nRId = EgtGetNextRawPart( nRId)
+      end
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.CreateOrEmptyAddGroup( PartId)
+   -- recupero i dati del gruppo aggiuntivo
+   local AddGrpId, sMchGrp = BeamLib.GetAddGroup( PartId)
+   if not sMchGrp then
+      return false
+   end
+
+   -- se esiste, aggiorno riferimento al gruppo di lavoro e lo svuoto
+   if AddGrpId then
+      EgtSetInfo( AddGrpId, GDB_SI.MGRPONLY, EgtGetCurrMachGroup())
+      return EgtEmptyGroup( AddGrpId)
+   end
+   -- altrimenti lo creo
+   AddGrpId = EgtGroup( PartId or GDB_ID.NULL)
+   if not AddGrpId then
+      return false
+   end
+   -- assegno nome, flag di layer per gruppo di lavoro e colore
+   EgtSetName( AddGrpId, sMchGrp)
+   EgtSetInfo( AddGrpId, GDB_SI.MGRPONLY, EgtGetCurrMachGroup())
+   EgtSetColor( AddGrpId, Color3d( 80, 160, 160, 50))
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.GetAddGroup( PartId)
+   -- recupero il nome del gruppo di lavoro corrente
+   local sMchGrp = EgtGetMachGroupName( EgtGetCurrMachGroup() or GDB_ID.NULL)
+   if not sMchGrp then
+      return nil, nil
+   end
+
+   -- cerco il gruppo aggiuntivo omonimo nel pezzo e se esiste lo restituisco
+   local AddGrpId = EgtGetFirstNameInGroup( PartId or GDB_ID.NULL, sMchGrp)
+
+   -- restituisco Id e Nome
+   return AddGrpId, sMchGrp
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- restituisce le facce della parte interessate dalla feature Proc
+function BeamLib.GetAffectedFaces( Proc, Part)
+   local vtFacesAffected = { bTop = false, bBottom = false, bFront = false, bBack = false, bLeft = false, bRight = false}
+   if Proc.b3Box and not Proc.b3Box:isEmpty() then
+      if Proc.b3Box:getMax():getZ() > Part.b3Part:getMax():getZ() - 500 * GEO.EPS_SMALL then
+         vtFacesAffected.bTop = true
+      end
+      if Proc.b3Box:getMin():getZ() < Part.b3Part:getMin():getZ() + 500 * GEO.EPS_SMALL then
+         vtFacesAffected.bBottom = true
+      end
+      if Proc.b3Box:getMin():getY() < Part.b3Part:getMin():getY() + 500 * GEO.EPS_SMALL then
+         vtFacesAffected.bFront = true
+      end
+      if Proc.b3Box:getMax():getY() > Part.b3Part:getMax():getY() - 500 * GEO.EPS_SMALL then
+         vtFacesAffected.bBack = true
+      end
+      if Proc.b3Box:getMin():getX() < Part.b3Part:getMin():getX() + 500 * GEO.EPS_SMALL then
+         vtFacesAffected.bLeft = true
+      end
+      if Proc.b3Box:getMax():getX() > Part.b3Part:getMax():getX() - 500 * GEO.EPS_SMALL then
+         vtFacesAffected.bRight = true
+      end
+   end
+
+   return vtFacesAffected
+end
+
+---------------------------------------------------------------------
+function BeamLib.GetNearestOrthoOpposite( vtRef, vtNorm)
+   -- se definita anche la normale alla faccia, elimino la parte di vtRef parallela a questa
+   local vtMyRef = Vector3d( vtRef)
+   if vtNorm then
+      vtMyRef = vtMyRef - ( vtMyRef * vtNorm) * vtNorm
+      vtMyRef:normalize()
+   end
+   -- se prevalente una componente orizzontale (con piccolissimo vantaggio)
+   if abs( vtMyRef:getX()) > 0.91 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.91 * abs( vtMyRef:getZ()) then
+      -- se prevale la componente destra/sinistra
+      if abs( vtMyRef:getX()) > 0.95 * abs( vtMyRef:getY()) then
+         if vtMyRef:getX() > -GEO.EPS_SMALL then
+            return MCH_MILL_FU.ORTHO_LEFT
+         else
+            return MCH_MILL_FU.ORTHO_RIGHT
+         end
+      else
+         if vtMyRef:getY() > -GEO.EPS_SMALL then
+            return MCH_MILL_FU.ORTHO_FRONT
+         else
+            return MCH_MILL_FU.ORTHO_BACK
+         end
+      end
+   -- altrimenti prevale la verticale
+   else
+      if vtMyRef:getZ() > -GEO.EPS_SMALL then
+         return MCH_MILL_FU.ORTHO_DOWN
+      else
+         return MCH_MILL_FU.ORTHO_TOP
+      end
+   end
+   return nil
+end
+
+---------------------------------------------------------------------
+function BeamLib.GetNearestParalOpposite( vtRef, vtNorm)
+   -- se definita anche la normale alla faccia, elimino la parte di vtRef parallela a questa
+   local vtMyRef = Vector3d( vtRef)
+   if vtNorm then
+      vtMyRef = vtMyRef - ( vtMyRef * vtNorm) * vtNorm
+      vtMyRef:normalize()
+   end
+   -- se prevalente una componente orizzontale (con piccolissimo vantaggio)
+   if abs( vtMyRef:getX()) > 0.95 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.95 * abs( vtMyRef:getZ()) then
+      if abs( vtMyRef:getX()) > 0.95 * abs( vtMyRef:getY()) then
+         if vtMyRef:getX() > -GEO.EPS_SMALL then
+            return MCH_MILL_FU.PARAL_LEFT
+         else
+            return MCH_MILL_FU.PARAL_RIGHT
+         end
+      else
+         if vtMyRef:getY() > -GEO.EPS_SMALL then
+            return MCH_MILL_FU.PARAL_FRONT
+         else
+            return MCH_MILL_FU.PARAL_BACK
+         end
+      end
+   -- altrimenti prevale la verticale
+   else
+      if vtMyRef:getZ() > -GEO.EPS_SMALL then
+         return MCH_MILL_FU.PARAL_DOWN
+      else
+         return MCH_MILL_FU.PARAL_TOP
+      end
+   end
+   return nil
+end
+
+---------------------------------------------------------------------
+-- Funzione per determinare se la faccia ha lati molto corti (trascurabili) ed è quindi approssimabile ad una 3 facce
+function BeamLib.Is3EdgesApprox( Proc, idFace, nAddGrpId)
+   nAddGrpId = nAddGrpId or BeamLib.GetAddGroup( Proc.idPart)
+   if not nAddGrpId then
+      local nEdges = #(EgtSurfTmFacetAdjacencies( Proc.id, idFace)[1])
+      return ( nEdges == 3)
+   end
+   local bResult = false
+
+   local nContourId, nContourCnt = EgtExtractSurfTmFacetLoops( Proc.id, idFace, nAddGrpId)
+   if not nContourId then
+      return false
+   end
+   EgtMergeCurvesInCurveCompo( nContourId)
+   -- recupero il numero effettivo di lati
+   local _, nEntityCount = EgtCurveDomain( nContourId)
+   local nEdges = nEntityCount
+   if nEntityCount and nEntityCount == 3 then
+      bResult = true
+   -- rimuovo i lati molto corti dal conteggio totale
+   elseif nEntityCount then
+      for i = 1, nEntityCount do
+         local dLength = EgtCurveCompoLength( nContourId, i - 1)
+         if dLength < 15 then nEdges = nEdges - 1 end
+      end
+   end
+   if nEdges == 3 then bResult = true end
+   -- cancello tutti i contorni appena creati
+   EgtErase( EgtTableFill( nContourId, nContourCnt))
+
+   return bResult
+end
+
+-------------------------------------------------------------------------------------------------------------
+function BeamLib.GetNzLimDownUp( b3Raw, vtN, vtOrtho)
+   if BeamData.GetNzLimDownUp then
+      return BeamData.GetNzLimDownUp( b3Raw, vtN, vtOrtho)
+   elseif BeamData.C_SIMM then
+      return -0.484
+   elseif BeamData.TURN then
+      return -2
+   else
+      if vtOrtho and vtOrtho:getZ() > 0.35 then
+         -- N_HorAng < 15° or N_HorAng > 55°
+         if vtN and ( abs( vtN:getY()) < 0.259 or abs( vtN:getY()) > 0.819) then
+            return -0.708
+         -- N_HorAng > 50°
+         elseif vtN and abs( vtN:getY()) > 0.766 then
+            return -0.383
+         else
+            return EgtIf( b3Raw:getDimZ() < BeamData.MIN_DIM_HBEAM, -0.609, -0.383)
+         end
+      else
+         -- N_HorAng > 60°
+         if vtN and ( abs( vtN:getY()) > 0.866) then
+            return -0.708
+         else
+            if b3Raw:getDimZ() < 120 then
+               return -0.708
+            elseif b3Raw:getDimZ() < 200 then
+               -- N_HorAng < 15° or N_HorAng > 55°
+               if vtN and ( abs( vtN:getY()) < 0.259 or abs( vtN:getY()) > 0.819) then
+                  return -0.5
+               else
+                  return -0.383
+               end
+            elseif b3Raw:getDimZ() < 300 then
+               -- N_HorAng < 10°
+               if vtN and ( abs( vtN:getY()) < 0.174) then
+                  return -0.5
+               else
+                  return -0.259
+               end
+            elseif b3Raw:getDimZ() < BeamData.MIN_DIM_HBEAM then
+               -- N_HorAng < 10°
+               if vtN and ( abs( vtN:getY()) < 0.174) then
+                  return -0.342
+               else
+                  return -0.259
+               end
+            else
+               -- N_HorAng < 10°
+               if vtN and ( abs( vtN:getY()) < 0.174) then
+                  return -0.383
+               else
+                  return -0.174
+               end
+            end
+         end
+      end
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- sovrascrivo i parametri personalizzati salvati su Proc a quelli di default dalla strategia
+-- N.B. : I parametri personalizzati non più presenti tra i default della strategia, verranno ignorati. Quelli extra avranno valore di default
+-- Il controllo deve essere fatto SEMPRE all'inizio di ogni strategia, per controllare conformità parametri custom
+function BeamLib.GetUpdateCustomParameters( CustomStrategyParamList, DefaultStrategyParamList)
+   if CustomStrategyParamList and #CustomStrategyParamList > 0 then
+      for i = 1, #DefaultStrategyParamList do
+         for j = 1, #CustomStrategyParamList do
+            if DefaultStrategyParamList[i].sName == CustomStrategyParamList[j].sName then
+               DefaultStrategyParamList[i].sValue = CustomStrategyParamList[j].sValue
+            end
+         end
+      end
+   end
+   return DefaultStrategyParamList
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- si traduce la tabella dei parametri con tutte le informazioni in una lista contenente i parametri utilizzabili con accesso diretto
+function BeamLib.LoadCustomParametersInStrategy( CustomParameters)
+   local Parameters = {}
+   if CustomParameters and  #CustomParameters > 0 then
+      for i=1, #CustomParameters do
+         if CustomParameters[i].sType == 'b' then
+            Parameters[CustomParameters[i].sName] = CustomParameters[i].sValue == 'true'
+         elseif CustomParameters[i].sType == 'd' then
+            Parameters[CustomParameters[i].sName] = tonumber( CustomParameters[i].sValue)
+         else --CustomParameters[i].sType == 's' or CustomParameters[i].sType == 'combo'
+            Parameters[CustomParameters[i].sName] = CustomParameters[i].sValue
+         end
+      end
+   end
+   return Parameters
+end
+
+---------------------------------------------------------------------
+function BeamLib.GetChainSawInitAngs( vtN, vtO, nInd)
+   if BeamData.GetChainSawInitAngs then
+      return BeamData.GetChainSawInitAngs( vtN, vtO, nInd)
+   else
+      if BeamData.C_SIMM then
+         return EgtIf( vtN:getY() > 0, 'C=180', 'C=-180')
+      else
+         if nInd == 1 then
+            return ''
+         else
+            return EgtIf( vtN:getY() > 0, 'C=180', 'C=-180')
+         end
+      end
+   end
+end
+
+---------------------------------------------------------------------
+function BeamLib.GetBlockedAxis( nToolIndex, sBlockedAxis, b3Raw, vtTool, vtOut)
+   -- se presente funzione specifica nella macchina, la richiamo
+   if BeamData.GetBlockedAxis then
+      return BeamData.GetBlockedAxis( TOOLS[nToolIndex].sHead, TOOLS[nToolIndex].nTypeId, sBlockedAxis, b3Raw, vtTool, vtOut) or ''
+   -- sezione mantenuta per retrocompatibilità con GetChainSawBlockedAxis
+   elseif TOOLS[nToolIndex].nTypeId == MCH_TY.MORTISE_STD then
+      local nInd = EgtIf( sBlockedAxis == 'parallel', 0, 1)
+      if BeamData.GetChainSawBlockedAxis then
+         return BeamData.GetChainSawBlockedAxis( nInd)
+      else
+         if nInd == 1 then
+            return EgtIf( BeamData.C_SIMM, 'A=90', 'A=90')
+         else
+            return EgtIf( BeamData.C_SIMM, 'A=0', 'A=0')
+         end
+      end
+   end
+
+   return ''
+end
+
+---------------------------------------------------------------------
+function BeamLib.BinaryToDecimal( dNumber)
+   local sNumberToConvert = tostring( dNumber)
+   local dResult = 0
+   local k = 0
+   
+   for i = #sNumberToConvert, 1, -1 do
+      k = k + 1
+      local n = string.sub(sNumberToConvert, k, k)
+      dResult = dResult + n*(2^(i-1))
+   end
+   
+   return dResult
+end
+
+---------------------------------------------------------------------
+function BeamLib.DecimalToBinary( dNumber)
+   local sNumberToConvert = tostring( dNumber)
+   local n = sNumberToConvert
+   local tmp = {}
+   local sResult = ""
+   
+   for i = sNumberToConvert, 0, -1 do
+       local q = math.modf(n)
+       n = n/2
+       local b = q%2
+       table.insert(tmp, b)
+
+       if (q == 1) then
+          break
+       end
+   end
+
+   for i = #tmp, 1, -1 do
+     sResult = sResult..tmp[i]
+   end
+   
+   return tonumber( sResult)
+end
+
+---------------------------------------------------------------------
+function BeamLib.CalculateStringBinaryFormat( dNumber, CharNumber)
+   local NumberString = tostring( dNumber)
+   while #NumberString < CharNumber do
+      NumberString = '0' .. NumberString
+   end
+
+   return NumberString
+end
+
+---------------------------------------------------------------------
+--- copia una tabella lua in modo ricorsivo, ossia mantiene indipendenti anche tutte le sottotabelle
+--- ATTENZIONE: in caso di modifiche vanno gestiti anche i tipi custom; sarebbe meglio metterla nel LuaLibs
+function BeamLib.TableCopyDeep( OriginalTable)
+   local CopiedTable = {}
+   for key, value in pairs( OriginalTable) do
+      if type( value) == "table" then
+         if isBBox3d( value) then
+            CopiedTable[ key] = BBox3d( value)
+         elseif isColor3d( value) then
+            CopiedTable[ key] = Color3d( value)
+         elseif isFrame3d( value) then
+            CopiedTable[ key] = Frame3d( value)
+         elseif isPoint3d( value) then
+            CopiedTable[ key] = Point3d( value)
+         elseif isQuaternion( value) then
+            CopiedTable[ key] = Quaternion( value)
+         elseif isVector3d( value) then
+            CopiedTable[ key] = Vector3d( value)
+         else
+            CopiedTable[ key] = BeamLib.TableCopyDeep( value)
+         end
+      else
+         CopiedTable[ key] = value
+      end
+   end
+
+   return CopiedTable
+end
+
+---------------------------------------------------------------------
+-- Merge sorting - algoritmo di sorting stabile, ossia che mantiene l'ordine relativo se gli elementi sono equivalenti
+-- TODO vedere come riordinare (tutto in tabella MergeSort??)
+-- TODO libreria Sorting??
+do
+   -- unisce due liste ordinate
+   local function MergeHalves(Left, Right, Compare)
+      local result = {}
+      local i, j = 1, 1
+
+      while i <= #Left and j <= #Right do
+         if Compare( Left[i], Right[j]) then
+            table.insert( result, Left[i])
+            i = i + 1
+         else
+            table.insert( result, Right[j])
+            j = j + 1
+         end
+      end
+
+      -- Append degli elementi rimanenti a sinistra o destra
+      while i <= #Left do
+         table.insert( result, Left[i])
+         i = i + 1
+      end
+      while j <= #Right do
+         table.insert( result, Right[j])
+         j = j + 1
+      end
+
+      return result
+   end
+
+   -- Merge sort
+   local function MergeSort( List, Compare)
+      if #List <= 1 then
+         return List
+      end
+
+      local mid = floor( #List / 2)
+      local Left = MergeSort( { table.unpack( List, 1, mid)}, Compare)
+      local Right = MergeSort( { table.unpack( List, mid + 1)}, Compare)
+
+      return MergeHalves( Left, Right, Compare)
+   end
+
+   -- chiamata accessibile dall'esterno
+   function BeamLib.StableSort( List, Compare)
+      return MergeSort( List, Compare)
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+return BeamLib

LuaLibs/DiceCut.lua

@@ -0,0 +1,676 @@
+-- DiceCut.lua by Egaltech s.r.l. 2024/01/23
+-- Gestione dei piano paralleli nei tagli lunghi: equidistanziamento dei piani paralleli
+
+-- Tabella per definizione modulo
+local DiceCut = {}
+
+-- Include
+require( 'EgtBase')
+local BeamLib = require( 'BeamLib')
+
+EgtOutLog( ' DiceCut started', 1)
+
+-- Dati
+local BeamData = require( 'BeamData')
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- creo i piani paralleli
+-- GetParallelPlanes: restituisce un vettore con gli indici delle superfici
+--   nAddGrpId: il layer
+--   b3BoxToDicing: il grezzo della barra
+--   ptC: il punto centrale del piano della feature
+--   vtN: il versore normale del piano della feature
+--   nCopyPlane: 0 => genera una copia del piano passato, 1=> non genera una copia del piano passato 
+--   dOffset: offset dei piani paralleli
+--   nStep: numero massimo di step
+--   Color: colre del fascio di piani
+--   dTolerance*: distanza tra i piani paralleli e i piani di taglio (se non esistono altre superfici può essere omesso)
+--   bNoTolOnFirstCut*: elimina la tolleranza per il primo piano del fascio (se non esistono altre superfici può essere omesso)
+--   ptCCut*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
+--   vtNCut*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
+--   ptCCut1*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
+--   vtNCut1*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
+local function GetParallelPlanes( nAddGrpId, b3BoxToDicing, ptC, vtN, nCopyPlane, dOffset, nStep, Color, dTolerance, bNoTolOnFirstCut, ptCCut, vtNCut, ptCCut1, vtNCut1 )
+   local ptMyCCut
+   local AreaMin = 5*5
+   if ptCCut and vtNCut then
+      if dTolerance then
+         ptMyCCut = Point3d( ptCCut + dTolerance * vtNCut)
+      end
+      ptMyCCut = Point3d( ptCCut)
+   end
+   local ptMyCCut1
+   if ptCCut1 and  vtNCut1 then 
+      ptMyCCut1 = Point3d( ptCCut1 + 0 * vtNCut1)
+   end
+   local TabellaTmSurfParallel = {}   
+   local i = nCopyPlane
+   while i < nStep do
+      local SurfId = EgtSurfTmPlaneInBBox( nAddGrpId, ptC + ( i * dOffset) * vtN, vtN, b3BoxToDicing, GDB_RT.GLOB) 
+      local nFacet = EgtSurfTmFacetCount( SurfId or GDB_ID.NULL)
+      if nFacet == 0 then
+         -- se sono al primo taglio do una possibilità in più di girare
+         if i > nCopyPlane then
+            break
+         end
+      end
+      if nFacet > 0 and vtNCut and ptMyCCut and EgtSurfArea(SurfId) > AreaMin then
+         if i == nCopyPlane and bNoTolOnFirstCut then
+            EgtCutSurfTmPlane( SurfId, ptCCut, -vtNCut, false, GDB_RT.GLOB)
+         else
+            EgtCutSurfTmPlane( SurfId, ptMyCCut, -vtNCut, false, GDB_RT.GLOB)
+         end         
+         nFacet = EgtSurfTmFacetCount( SurfId)
+      end
+      if nFacet > 0 and vtNCut1 and ptMyCCut1 and EgtSurfArea(SurfId) > AreaMin then
+         if i == nCopyPlane and bNoTolOnFirstCut then
+            EgtCutSurfTmPlane( SurfId, ptCCut1, -vtNCut1, false, GDB_RT.GLOB)
+         else
+            EgtCutSurfTmPlane( SurfId, ptMyCCut1, -vtNCut1, false, GDB_RT.GLOB)
+         end
+         nFacet = EgtSurfTmFacetCount( SurfId)
+      end
+      if nFacet > 0 and EgtSurfArea(SurfId) > AreaMin then
+         table.insert( TabellaTmSurfParallel, SurfId)
+         EgtSetColor( SurfId, Color)
+      else
+         EgtErase( SurfId)
+      end
+      if dOffset == 0 then
+         break  
+      end  
+      i = i + 1
+   end
+   return TabellaTmSurfParallel
+end
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- GetOrderedCutTable:
+--   nAddGrpId: il layer 
+--   TabParallelPlanes: tabella delle superfici dei piani paralleli
+--   TabOrtoPlanes: tabella delle superfici dei piani ortogonali
+-- stampo l'ordine dei piani di taglio (prima tagli ortogonali piu' esterni poi taglio parallelo collettivo)
+local function GetOrderedCutTable( nAddGrpId, TabParallelPlanes, TabOrtoPlanes)
+   local StepParallel = #TabParallelPlanes
+   local StepOrto = #TabOrtoPlanes
+   local TabellaOrderParallelCut1 = {}
+
+   for IndexTmP=1, StepParallel do
+      TabellaOrderParallelCut1[IndexTmP] = {}
+      for IndexOrto=1, StepOrto do
+         local ptOrtoN, vtNOrtoN = EgtSurfTmFacetCenter( TabOrtoPlanes[IndexOrto ], 0, GDB_ID.ROOT)
+         local Copy1Id = EgtCopySurfTmFacet( TabParallelPlanes[IndexTmP], 0, nAddGrpId)
+         local Copy2Id = EgtCopySurfTmFacet( TabParallelPlanes[IndexTmP], 0, nAddGrpId)
+         if Copy1Id and ptOrtoN then
+            EgtCutSurfTmPlane( Copy1Id, ptOrtoN, -vtNOrtoN, false, GDB_RT.GLOB)
+            EgtCutSurfTmPlane( Copy2Id, ptOrtoN, vtNOrtoN, false, GDB_RT.GLOB)
+            local nFacet1 = EgtSurfTmFacetCount( Copy1Id)
+            local nFacet2 = EgtSurfTmFacetCount( Copy2Id)
+            if nFacet1 < 1 then 
+               EgtErase( Copy1Id)
+               EgtErase( Copy2Id) 
+               EgtCutSurfTmPlane( TabParallelPlanes[IndexTmP], ptOrtoN, vtNOrtoN, false, GDB_RT.GLOB)
+            elseif nFacet2 < 1 then
+               EgtErase( Copy1Id)
+               EgtErase( Copy2Id)
+               break
+            else
+               table.insert( TabellaOrderParallelCut1[IndexTmP], Copy1Id)
+               EgtErase( Copy2Id)    
+               EgtCutSurfTmPlane( TabParallelPlanes[IndexTmP], ptOrtoN, vtNOrtoN, false, GDB_RT.GLOB)
+            end
+         end
+      end
+      table.insert(TabellaOrderParallelCut1[IndexTmP], TabParallelPlanes[IndexTmP]) 
+   end
+   return TabellaOrderParallelCut1
+end 
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- GetOrtoCutCenter:
+--   idFacet: l'id della faccia
+--   ptC: il punto centrale della faccia
+--   vtN: il versore normale della faccia
+--   vtO: il versore dei piani ortogonali 
+--   dOffsetEff: offset della distanza dal punto centrale
+-- Verifica se l'asse X del box costruito sopra la superficie è più grande di un certo offset 
+local function GetOrtoCutCenter( FacetId, ptC, vtN, vtO, dOffsetEff, dNzLimDwnUp)
+   local FrameLocal = Frame3d( EgtSurfTmFacetCenter( FacetId, 0, GDB_ID.ROOT))
+   EgtSetGridFrame(FrameLocal)
+   local IdAuxLocal = EgtGroup(EgtGetParent( FacetId), FrameLocal)
+   EgtSetName( IdAuxLocal, "AuxLocal")  
+   local BoxLocal = EgtGetBBoxRef( FacetId, GDB_BB.STANDARD, FrameLocal)  
+   local ptS = EgtGP( EgtSurfTmBBox( IdAuxLocal, BoxLocal, GDB_RT.GRID), GDB_ID.ROOT)
+   EgtErase( IdAuxLocal)
+   EgtSetGridFrame(Frame3d())
+   -- riferimento intrinseco
+   local asseX = Vector3d( vtO)
+   local asseY = vtN ^ asseX
+   local Frame = Frame3d( ptC, ptC + asseX, ptC + asseY)
+   -- ingombro della faccia secondo questo riferimento
+   local Box = EgtGetBBoxRef( FacetId, GDB_BB.STANDARD, Frame)
+   local dLen = Box:getDimX()
+   local dWidth = Box:getDimY()
+
+   -- se faccia non troppo lunga, con un lato piccolo e non diretta troppo verso il basso, non servono dice
+   local dMaxLen = BeamData.MAX_LEN_DICE or 600
+   if dLen < dMaxLen and dWidth < dMaxLen and
+      ( dLen < dOffsetEff + 1.0 or dWidth < dOffsetEff + 1.0) and vtN:getZ() > dNzLimDwnUp then
+      return nil, nil, nil
+   end
+
+   local N = ceil( dLen / dOffsetEff)
+   local dOffsetRel = ( dLen / N) + 10 * GEO.EPS_SMALL
+   local dCopyPlane
+   local dCenOffs = ( Box:getMax():getX() + Box:getMin():getX()) / 2
+
+   if dLen <= dOffsetRel then
+      dCopyPlane = 1
+   elseif dLen <= 2 * dOffsetRel then
+      dOffsetRel = dOffsetEff
+      dCopyPlane = 0
+   else
+      if N % 2 == 0 then
+         dCopyPlane = 0
+      elseif N % 2 == 1 then
+         dCopyPlane = 0.5
+      end
+   end
+
+   return dOffsetRel, dCopyPlane, dCenOffs, ptS
+end
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- TableMesh:
+--   TableOrto: tabella delle superfici dei piani ortogonali
+--   TableParallel: tabella delle superfici dei piani paralleli
+-- Forma una tabella unica delle superfici di taglio inserendo strati di tagli ortogonali alternati da strati di taglio parallelo
+local function TableMesh( TableOrto, TableParallel)
+   local TableUnited = {}
+   for i=1, #TableOrto do
+      table.insert( TableUnited, TableOrto[i])
+      table.insert( TableUnited, TableParallel[i])
+   end
+   return TableUnited
+end 
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- FindValue:
+--   tab: tabella da scansionare
+--   val: valore da cercare
+-- Verifica se tab contiene val, a supporto della funzione SortOrtoCutsByNormalMethod
+local function FindValue( tab, val)
+   for index, value in ipairs( tab) do
+      if value == val then
+         return true
+      end
+   end
+   return false
+end
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- SortOrtoCutsByNormalMethod:
+--   TabParallelPlanes: tabella delle superfici dei piani paralleli
+--   TabOrtoPlanes: tabella delle superfici dei piani ortogonali
+-- stampo l'ordine dei piani di taglio sfruttando il prodotto dei versori normali (prima tagli ortogonali piu' esterni poi taglio parallelo collettivo)
+local function SortOrtoCutsByNormalMethod( TabParallelPlanes, TabOrtoPlanes)
+   -- tabella dei tagli ordinati
+   local TabOrderOrtoCut = {}
+   -- tabella ausiliaria dei dati inseriti nell'ordine
+   local TabAux = {}
+   -- ciclo di ordinamento
+   local StepParallel = #TabParallelPlanes
+   local StepOrto = #TabOrtoPlanes
+   for IndexTmP=1, StepParallel do
+      TabOrderOrtoCut[IndexTmP] = {}
+      local ptParalN, vtNParalN = EgtSurfTmFacetCenter( TabParallelPlanes[IndexTmP][1], 0, GDB_ID.ROOT)
+      for IndexOrto=1, StepOrto do
+         for i=1, #TabOrtoPlanes[IndexOrto] do
+            -- identificativo del taglio
+            local OrtoPlaneId = TabOrtoPlanes[IndexOrto][i]
+            -- controlla che l'elemento da valutare non sia gia' stato inserito nella tabella
+            if not FindValue( TabAux, OrtoPlaneId) then
+               local ptOrtoN, vtNOrtoN = EgtSurfTmFacetCenter( OrtoPlaneId, 0, GDB_ID.ROOT)
+               local scalarProduct = ( ptOrtoN - ptParalN) * vtNParalN
+               if scalarProduct > 0 then
+                  table.insert( TabOrderOrtoCut[IndexTmP], OrtoPlaneId)
+                  table.insert( TabAux, OrtoPlaneId)
+               end
+            end
+         end
+      end
+   end
+   -- cancello dal DB geometrico i tagli non inseriti
+   for IndexOrto=1, StepOrto do
+      for i=1, #TabOrtoPlanes[IndexOrto] do
+         -- identificativo del taglio
+         local OrtoPlaneId = TabOrtoPlanes[IndexOrto][i]
+         -- ricerco il taglio tra gli inseriti
+         if not FindValue( TabAux, OrtoPlaneId) then
+            EgtErase( OrtoPlaneId)
+         end
+      end
+   end
+   return TabOrderOrtoCut
+end 
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- VerifyFirstOrthoCut :
+--   CutTable: tabella dei tagli
+--   OffsetP: offset della distanza dal punto centrale
+--   b3BoxToDicing: il grezzo della barra
+--   Verifica se l'asse X del box costruito sopra le 2 facce è più piccolo di un certo offset e quindi la faccia O è superflua 
+local function VerifyFirstOrthoCut( CutTable, OffsetP, b3BoxToDicing, dNzLimDwnUp)
+
+   if not CutTable[1] or not CutTable[2] then return end
+
+   local CutOId = CutTable[1][1]
+   local Cut1Id = CutTable[2][1]
+   local Cut2Id = CutTable[2][2]
+
+   if CutOId and Cut1Id and Cut2Id then
+      -- centri e normali delle due semifacce
+      local ptC1, vtN1 = EgtSurfTmFacetCenter( Cut1Id, 0, GDB_ID.ROOT)
+      local ptC2, vtN2 = EgtSurfTmFacetCenter( Cut2Id, 0, GDB_ID.ROOT)
+      -- normale alla faccia ortogonale
+      local _, vtO = EgtSurfTmFacetCenter( CutOId, 0, GDB_ID.ROOT)
+      vtO = vtO - vtO * vtN1 * vtN1 ; vtO:normalize()
+      local dMaxElev = EgtSurfTmFacetElevationInBBox( CutOId, 0, b3BoxToDicing, true, GDB_ID.ROOT)
+      -- calcolo lunghezza prima semi-faccia
+      local asseX1 = vtO
+      local asseY1 = vtN1 ^ asseX1
+      local Frame1 = Frame3d( ptC1, ptC1+asseX1, ptC1+asseY1)
+      local Box1 = EgtGetBBoxRef( Cut1Id, GDB_BB.STANDARD, Frame1)
+      local x1 = Box1:getDimX()
+      -- prendo il massimo tra la lugnhezza della faccia parallela e l'elevazione della corrispondente ortogonale
+      x1 = max( x1, dMaxElev)
+      -- calcolo lunghezza seconda semi-faccia
+      local asseX2 = vtO
+      local asseY2 = vtN2 ^ asseX2
+      local Frame2 = Frame3d( ptC2, ptC2+asseX2, ptC2+asseY2)
+      local Box2 = EgtGetBBoxRef( Cut2Id, GDB_BB.STANDARD, Frame2)
+      local x2 = Box2:getDimX()
+      -- lunghezza totale faccia
+      local dLongSize = x1 + x2
+      -- se faccia piccola e non orientata verso il basso, elimino ortogonale e unisco le due parti
+      if dLongSize <= OffsetP + 1.0 and vtN1:getZ() > dNzLimDwnUp then
+         local nAddGrpId = EgtGetParent( Cut1Id)
+         local SurfId = EgtSurfTmBySewing( nAddGrpId, { Cut1Id, Cut2Id})
+         EgtSetColor( SurfId, Color3d( FUCHSIA(), 60))
+         EgtErase( CutOId)
+         table.remove( CutTable[1], 1)
+         table.remove( CutTable[2], 1)
+         table.remove( CutTable[2], 1)
+         table.insert( CutTable[2], 1, SurfId)
+      end
+   end
+end
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- ricavo i vertici del box
+local function CalcolaPuntiEstremiBox( b3BoxToDicing)
+   local ptMin = b3BoxToDicing:getMin()
+   local ptMax = b3BoxToDicing:getMax()
+   local TBoxPoint = {}
+   table.insert( TBoxPoint, { P = Point3d( ptMin:getX(), ptMin:getY(), ptMin:getZ()), On = true})
+   table.insert( TBoxPoint, { P = Point3d( ptMax:getX(), ptMin:getY(), ptMin:getZ()), On = true})
+   table.insert( TBoxPoint, { P = Point3d( ptMin:getX(), ptMax:getY(), ptMin:getZ()), On = true})
+   table.insert( TBoxPoint, { P = Point3d( ptMax:getX(), ptMax:getY(), ptMin:getZ()), On = true})
+   table.insert( TBoxPoint, { P = Point3d( ptMin:getX(), ptMin:getY(), ptMax:getZ()), On = true})
+   table.insert( TBoxPoint, { P = Point3d( ptMax:getX(), ptMin:getY(), ptMax:getZ()), On = true})
+   table.insert( TBoxPoint, { P = Point3d( ptMin:getX(), ptMax:getY(), ptMax:getZ()), On = true})
+   table.insert( TBoxPoint, { P = Point3d( ptMax:getX(), ptMax:getY(), ptMax:getZ()), On = true})
+   return TBoxPoint
+end
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- restituisce i punti che devono essere presi in considerazione per la costruzione del BoundingBox
+local function VerificaEstremiGrezzo( ptC, vtN, TPoint)
+   for i = 1, #TPoint do
+      if ( TPoint[i].P - ptC) * vtN < 0 then
+         TPoint[i].On = false
+      end
+   end
+   return TPoint
+end
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- ricavo l'altezza del BoundingBox assegnati gli estremi del grezzo e la feature
+-- le funzioni commentate permettono di vedere la creazione di BoundingBox
+local function DistanzaMassima( nAddGrpId, ptC1, vtN1, ptC2, vtN2, b3BoxToDicing, TPoint)
+   -- calcolo il riferimento nel piano 1
+   local Frame1 = Frame3d( ptC1, vtN1)
+   -- determino l'ingombro in questo riferimento della parte di trave compresa nel o nei piani
+   local BB1 = BBox3d()
+   -- punti di vertice della trave compresi 
+   for i = 1, #TPoint do
+      if TPoint[i].On then
+         local ptP = Point3d( TPoint[i].P)
+         ptP:toLoc( Frame1)
+         BB1:Add( ptP) 
+      end
+   end
+   -- eventuale altra faccia
+   if ptC2 and vtN2 then
+      local IdAux = EgtGroup( nAddGrpId)
+      local IdSurf2 = EgtSurfTmPlaneInBBox( IdAux, ptC2, vtN2, b3BoxToDicing, GDB_RT.GLOB)
+      EgtCutSurfTmPlane( IdSurf2, ptC1, -vtN1, false, GDB_RT.GLOB)
+      if IdSurf2 then
+         local BB2 = EgtGetBBoxRef( IdSurf2, GDB_BB.STANDARD, Frame1)
+         BB1:Add( BB2)
+      end   
+      EgtErase( IdAux)
+   end
+   if not BB1:isEmpty() then
+      return ( BB1:getMax():getZ() + 0.1)
+   end
+
+   return 0
+end
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- DiceCut.GetDice :
+--   nParent: il layer 
+--   BBoxRawPart: il grezzo della barra
+--   ptCPlanes: il punto centrale del piano della feature
+--   vtNPlanes: il versore normale del piano della feature
+--   bGetOrtoPlanes*: se voglio calcolare i piani ortogonali al piano passato (se non esistono altre superfici può essere omesso)
+--   ptCBond*: il punto centrale della superfice limitante (se non esistono altre superfici può essere omesso)
+--   vtNBond*: il versore normale della superfice limitante (se non esistono altre superfici può essere omesso)
+--   dOrthoMaxDim : massima profondità taglio se faccia singola perpendicolare facce laterali trave
+--   dCustMaxDimDice: dimensione massima customizzata, sostituisce il parametro BeamData.MAX_DIM_DICE (se negativa qualunque, se positiva deve stare nel MAX)
+--   bDownHead : taglio con testa da sotto
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- function DiceCut.GetDice( nParent, BBoxRawPart, ptCPlanes, vtNPlanes, bGetOrtoPlanes, ptCBond, vtNBond, dOrthoMaxDim, dCustMaxDimDice, bDownHead)
+
+
+---------------------------------------------------------------------------------------------------------------
+-- DiceCut.GetDice :
+   -- Part           : pezzo
+   -- Face1          : table. Contiene tutti i dati della faccia principale. Obbligatori i campi '.ptCenter' e '.vtNormal'
+   -- Face2          : table. Contiene tutti i dati della faccia secondaria. Se non esiste, la table è vuota ({}). Se esiste, obbligatori i campi '.ptCenter' e '.vtNormal'
+   -- OptionaParameters : eventuali parametri opzionali
+---------------------------------------------------------------------------------------------------------------
+function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
+
+   local dMaxDimDice = BeamData.MAX_DIM_DICE
+   local dTolerance = 0                      -- distanza di sicurezza per i tagli ortogonali
+   local OffsetP = dMaxDimDice               -- distanza tra i piani paralleli
+   local StepP = 100                         -- numero massimo di piani paralleli da generare
+   local OffsetO = dMaxDimDice               -- distanza tra i piani ortogonali
+   local StepO = 100                         -- numero massimo di piani ortogonali da generare
+
+   -- recupero gruppo per geometria addizionale
+   local nAddGrpId = BeamLib.GetAddGroup( Part.id)
+   -- se il box non è passato tra i parametri opzionali, faccio i calcoli sul SOLID del Part
+   local b3BoxToDicing = OptionalParameters.b3BoxToDicing or Part.b3Part
+   -- copio dati passati su variabili locali
+   local ptCMainFace, vtNMainFace, ptCSubordinateFace, vtNSubordinateFace, bGetOrtoPlanes
+   if Face1.ptCenter and Face1.vtNormal then
+      ptCMainFace = Face1.ptCenter
+      vtNMainFace = Face1.vtNormal
+   end
+   -- se esiste faccia secondaria non esiste, forzo calcolo piani ortogonali
+   if Face2.ptCenter and Face2.vtNormal then
+      ptCSubordinateFace = Face2.ptCenter
+      vtNSubordinateFace = Face2.vtNormal
+      bGetOrtoPlanes = false
+   else
+      bGetOrtoPlanes = true
+   end
+   -- ricavo dimensione massima cubetti
+   if OptionalParameters.dCustMaxDimDice and OptionalParameters.dCustMaxDimDice < BeamData.MAX_DIM_DICE then
+      dMaxDimDice = abs( OptionalParameters.dCustMaxDimDice)
+   end
+
+   --Ricavo le altezze dei BoundingBox contenente feature e estremi del grezzo
+   local TBoxPoint = CalcolaPuntiEstremiBox( b3BoxToDicing)
+   TBoxPoint = VerificaEstremiGrezzo( ptCMainFace, vtNMainFace, TBoxPoint)
+   if ptCSubordinateFace and vtNSubordinateFace then
+      TBoxPoint = VerificaEstremiGrezzo( ptCSubordinateFace, vtNSubordinateFace, TBoxPoint)
+   end
+   local dElevP = DistanzaMassima( nAddGrpId, ptCMainFace, vtNMainFace, ptCSubordinateFace, vtNSubordinateFace, b3BoxToDicing, TBoxPoint)
+   local dElevO
+   if ptCSubordinateFace and vtNSubordinateFace and not AreOppositeVectorApprox( vtNSubordinateFace, vtNMainFace) then
+      dElevO = DistanzaMassima( nAddGrpId, ptCSubordinateFace, vtNSubordinateFace, ptCMainFace, vtNMainFace, b3BoxToDicing, TBoxPoint)
+   end
+
+   -- inclinazione limite per taglio da sotto
+   local dNzLimDwnUp = BeamLib.GetNzLimDownUp( b3BoxToDicing)
+
+   -- se non c'è testa da sotto e normali senza componenti in Y con faccia quasi verticale e trave non alta, uso per offset i limiti dei tagli di testa e coda
+   if not BeamData.DOWN_HEAD and abs( vtNMainFace:getY()) < 0.1 and vtNMainFace:getZ() < 0.7071 and ( not vtNSubordinateFace or abs( vtNSubordinateFace:getY()) < 0.1) and b3BoxToDicing:getDimZ() < BeamData.MIN_DIM_HBEAM then
+      OffsetO = OptionalParameters.dOrthoMaxDim or BeamData.MAX_DIM_HTCUT
+   end
+
+   -- aggiungo piccolo extra agli offset
+   OffsetP = OffsetP + 10 * GEO.EPS_SMALL
+   OffsetO = OffsetO + 10 * GEO.EPS_SMALL
+
+   -- se piani non ortogonali, diminuisco la distanza di offset opportunamente
+   local originalOffsetP = OffsetP
+   if not bGetOrtoPlanes then
+      local dCoeff = ( vtNMainFace ^ vtNSubordinateFace):len()
+      OffsetP = OffsetP * dCoeff
+      OffsetO = OffsetO * dCoeff
+   end
+
+   local n = ceil( dElevP / OffsetP)
+   OffsetP = dElevP / n
+   if dElevO then
+      local m = ceil( dElevO / OffsetO)
+      OffsetO = dElevO / m
+   end
+
+   -- elenco di tutte le superfici generate dai tagli
+   local TabFUCHSIA = {}
+   local TabGREEN = {}
+
+   -- PIANI PARALLELI alla faccia di taglio 
+   local TabellaTmSurfP = {}
+   local TabFromIn = GetParallelPlanes( nAddGrpId, b3BoxToDicing, ptCMainFace, vtNMainFace, 0, OffsetP, StepP, Color3d( FUCHSIA(), 60), dTolerance, true, ptCSubordinateFace, vtNSubordinateFace)
+   for i = #TabFromIn, 1, -1 do
+      table.insert( TabellaTmSurfP, TabFromIn[i])
+   end
+
+   -- PIANI ORTOGONALI alla faccia di taglio
+   -- orientamento definito da seconda faccia
+   if not bGetOrtoPlanes then
+      local TabellaTmSurfOrto = {}
+      local TabFromIn = GetParallelPlanes( nAddGrpId, b3BoxToDicing, ptCSubordinateFace, vtNSubordinateFace, 0, OffsetO, StepO, Color3d( GREEN(), 60), dTolerance, false, ptCMainFace, vtNMainFace)
+      for i = #TabFromIn, 1, -1 do
+         table.insert( TabellaTmSurfOrto, TabFromIn[i])
+      end
+      local TabellaOrderParallelCut = GetOrderedCutTable( nAddGrpId, TabellaTmSurfP, TabellaTmSurfOrto)   -- Ottiene la tabella dei tagli paralleli ordinati
+      local TabellaOrderOrtoCut = GetOrderedCutTable( nAddGrpId, TabellaTmSurfOrto, TabellaTmSurfP)       -- Ottiene la tabella dei tagli ortogonali da riordinare per strato 
+
+      TabGREEN = SortOrtoCutsByNormalMethod( TabellaOrderParallelCut, TabellaOrderOrtoCut)              -- I tagli ortogonali vengono ordinati per strato  
+      TabFUCHSIA = TabellaOrderParallelCut                                                              -- I tagli paralleli sono già ordinati
+
+   -- orientamento da definire
+   else
+      for PlnInd = 1, #TabellaTmSurfP do
+         -- piano interno
+         local ptCInner, vtNInner = EgtSurfTmFacetCenter( TabellaTmSurfP[PlnInd], 0, GDB_ID.ROOT)
+         -- eventuale piano esterno
+         local ptCOuter, vtNOuter = nil, nil
+         if PlnInd > 1 then
+            ptCOuter, vtNOuter = EgtSurfTmFacetCenter( TabellaTmSurfP[PlnInd-1], 0, GDB_ID.ROOT)
+            vtNOuter = -vtNOuter
+         end
+         -- calcolo la direzione dei piani ortogonali
+         local vtO = VectorFromUprightOrtho( vtNInner)
+         if vtNInner:getZ() > -0.0175 or vtNInner:getZ() < dNzLimDwnUp or abs( vtNInner:getY()) > 0.8 then
+            vtO:rotate( vtNInner, 90)
+            -- se diretto troppo ortogonalmente all'asse trave e taglio non da sotto, lo ruoto ulteriormente
+            if ( abs( vtO:getY()) > 4 * abs( vtO:getX()) or b3BoxToDicing:getDimZ() > 620) and vtNInner:getZ() > dNzLimDwnUp then
+               vtO:rotate( vtNInner, 90)
+               -- se faccia principale verso il basso (almeno -3deg), lo inverto per iniziare da sopra
+               if vtNInner:getZ() < -0.05 then
+                  vtO = -vtO
+               end
+            else
+               if vtNInner:getX() > -0.017 then
+                  if vtO:getX() < -0.001 then vtO = -vtO end
+               else
+                  if vtO:getX() > 0.001 then vtO = -vtO end
+               end
+            end
+         end
+         -- se quasi verticale (fino a 20 gradi di distanza) su faccia inclinata in Y, ruoto di 90 gradi
+         if vtO:getZ() > 0.939 and abs( vtNInner:getY()) > 0.5 then
+            vtO:rotate( vtNInner, 90)
+         end
+         -- se taglio con testa da sotto
+         if OptionalParameters.bHeadFromBottom and vtO:getZ() > 0.05 then
+            vtO = -vtO
+         end
+         -- calcolo le dimensioni dell'offset e dove posizionare la prima faccia:
+         --   CopyPlane: 0 => crea la prima faccia direttamente sul punto passato
+         --   CopyPlane: 1 => crea la prima faccia e tutte le altre con l'offset passato
+         --   CopyPlane: 0.5 => crea la prima faccia a metà offset e tutte le altre con l'offest intero
+         local OffsetRel, CopyPlane, dCenOffs, ptCStart = GetOrtoCutCenter( TabellaTmSurfP[PlnInd], ptCInner, vtNInner, vtO, OffsetO, dNzLimDwnUp)
+
+         if OffsetRel and CopyPlane and dCenOffs then
+            ptCInner = ptCInner + dCenOffs * vtO
+            local TabRight = GetParallelPlanes( nAddGrpId, b3BoxToDicing, ptCStart, vtO, CopyPlane, -OffsetRel, StepO, Color3d( GREEN(), 60),
+                                                dTolerance, false, ptCInner, vtNInner, ptCOuter, vtNOuter)
+            if CopyPlane == 0 then
+               CopyPlane = 1
+            end
+            local TabLeft = GetParallelPlanes( nAddGrpId, b3BoxToDicing, ptCStart, vtO, CopyPlane, OffsetRel, StepO, Color3d( GREEN(), 60),
+                                               dTolerance, false, ptCInner, vtNInner, ptCOuter, vtNOuter)
+            -- carico la tabella con gli indici riordinati
+            local TempOrtoTab = {}
+            for i = #TabLeft, 1, -1 do
+               table.insert( TempOrtoTab, TabLeft[i])
+            end
+            for i = 1, #TabRight do
+               table.insert( TempOrtoTab, TabRight[i])
+            end   
+            -- creo una tabella per ogni piano per generare i tagli sulla Inner
+            local TempParTab = GetOrderedCutTable( nAddGrpId, {TabellaTmSurfP[PlnInd]}, TempOrtoTab)
+            for i = 1, #TempParTab do
+               table.insert( TabFUCHSIA, TempParTab[i])
+            end
+            table.insert( TabGREEN, TempOrtoTab)
+         else
+            table.insert( TabFUCHSIA, {TabellaTmSurfP[PlnInd]})
+            table.insert( TabGREEN, {})
+         end
+      end
+   end
+
+   -- Se sono state costruite non più di una faccia parallela e una faccia perpendicolare, allora non servono e tengo le originali
+   if #TabGREEN == 1 and #TabGREEN[1] <= 1 and #TabFUCHSIA == 1 and #TabFUCHSIA[1] <= 1 then
+      if #TabGREEN[1] == 1 then
+         EgtErase( TabGREEN[1][1])
+      end
+      TabGREEN = {}
+      if #TabFUCHSIA[1] == 1 then
+         EgtErase( TabFUCHSIA[1][1])
+      end
+      TabFUCHSIA = {}
+   end
+
+   -- Si uniscono le tabelle dei tagli ortogonali e paralleli in una sola tabella
+   local UltimateTable = TableMesh( TabGREEN, TabFUCHSIA)
+
+   -- Se esiste la superficie limitante (nFacet == 2) verifica se il taglio più esterno è superfluo e quindi viene eliminato
+   if not bGetOrtoPlanes then
+      VerifyFirstOrthoCut( UltimateTable, originalOffsetP, b3BoxToDicing, dNzLimDwnUp)
+      -- se rimangono due sole facce, devono coincidere con le originali e quindi sono superflue
+      if #UltimateTable == 2 and #UltimateTable[1] == 1 and #UltimateTable[2] == 1 then
+         EgtErase( UltimateTable[1][1])
+         EgtErase( UltimateTable[2][1])
+         UltimateTable = {}
+      end
+   end
+
+   return UltimateTable
+end
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+-- PrintOrderCut:
+--   TabellaOrderCut: tabella delle superfici di taglio
+-- stampo l'ordine dei piani di taglio ricevendo una tabella con gli strati parallelo/ortogonali già ordinati
+function DiceCut.PrintOrderCut( TabellaOrderCut)
+   local Step = #TabellaOrderCut
+   if Step > 0 then
+      EgtOutLog( "   L'ordine delle superfici da tagliare è il seguente:")
+   else
+      EgtOutLog( '   Non sono necessarie superfici aggiuntive di taglio.')
+   end
+   for i = 1, Step do
+      if i % 2 == 1 then
+         EgtOutLog( '  *** Strato di taglio ' .. EgtNumToString( ( i + 1) / 2, 0))
+         if #TabellaOrderCut[i] > 0 then
+            EgtOutLog( '   Tagli ortogonali: ')
+         else
+            EgtOutLog( '   Tagli ortogonali assenti')
+         end
+      else
+         if #TabellaOrderCut[i] > 0 then
+            EgtOutLog( '   Tagli paralleli: ')
+         else
+            EgtOutLog( '   Tagli paralleli assenti')
+         end
+      end
+      for j=1, #TabellaOrderCut[i] do
+         EgtOutLog( '     Indice faccia ' .. (TabellaOrderCut[i][j] or 0))
+      end
+   end
+end
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+local function DiceCutTest()
+
+   -- salvo l'indice del layer Trimesh selezionato
+   local SelectedIndex = EgtGetFirstSelectedObj()
+   -- verifico che sia selezionato un elemento
+   if not SelectedIndex then return end
+
+   -- salvo l'indice del layer Processing
+   local nAddGrpId = EgtGetParent( SelectedIndex)
+   -- salvo l'indice del layer Part
+   local nRawPart = EgtGetParent( nAddGrpId)
+   local nBox = EgtGetFirstNameInGroup( nRawPart, 'Box')
+   -- carico il bounding box della trave
+   -- local b3BoxToDicing = EgtGetBBoxGlob( nRawPart, GDB_BB.STANDARD )
+   local b3BoxToDicing = EgtGetBBoxGlob( nBox, GDB_BB.STANDARD )
+   -- seleziono il Part e il Layer di destinazione
+   EgtSetCurrPartLayer( nRawPart, nAddGrpId)
+
+   -- conto il numero di facce da processare
+   local nFacet = EgtSurfTmFacetCount( SelectedIndex)
+   EgtOutLog( ' Numero facce ' .. nFacet, 1)
+
+   -- salvo
+   local TabPlanesFeatures = {}
+   for i = 1, nFacet do
+      local ptC, vtN = EgtSurfTmFacetCenter( SelectedIndex, i - 1, GDB_ID.ROOT)
+      table.insert( TabPlanesFeatures, { ptC = ptC, vtN = vtN})
+   end
+   local ptC1 = Point3d( TabPlanesFeatures[1].ptC)
+   local vtN1 = Vector3d( TabPlanesFeatures[1].vtN)
+
+   local CutTable = {}
+   if nFacet == 1 then
+      CutTable = DiceCut.GetDice( nAddGrpId, b3BoxToDicing, ptC1, vtN1, true)
+   elseif nFacet == 2 then
+      CutTable = DiceCut.GetDice( nAddGrpId, b3BoxToDicing, ptC1, vtN1, false, TabPlanesFeatures[2].ptC, TabPlanesFeatures[2].vtN)
+   end
+
+   if EgtGetDebugLevel() >= 3 then
+      DiceCut.PrintOrderCut( CutTable)
+   end
+   
+   EgtDeselectAll()
+
+   EgtDraw()
+end 
+
+----------------------------------------------------------------------------------------------------------------------------------------------------
+--DiceCutTest()
+
+return DiceCut

LuaLibs/FaceData.lua

@@ -0,0 +1,544 @@
+-- FaceData.lua by Egalware s.r.l. 2024/04/18
+-- Libreria lettura o calcolo dati e proprietà delle facce di una trimesh
+-- 2024/04/02 PRIMA VERSIONE CALCOLO LAVORAZIONI CON STRATEGIE
+
+-- Tabella per definizione modulo
+local FaceData = {}
+
+-- carico librerie
+local BeamLib = require( 'BeamLib')
+local Logs = require( 'Logs')
+
+
+---------------------------------------------------------------------
+-- restituisce la matrice delle adiacenze di Proc dove i e j sono le facce e a(ij) è l'angolo tra di esse; 0 se nessuna adiacenza
+function FaceData.GetAdjacencyMatrix( Proc)
+   local vAdj = {}
+
+   -- essendo la matrice simmetrica a diagonale nulla, ne calcolo solo la metà superiore
+   for i = 1, Proc.nFct do
+      vAdj[i] = {}
+      for j = i + 1, Proc.nFct do
+         _, _, _, vAdj[i][j] = EgtSurfTmFacetsContact( Proc.id, i - 1, j - 1, GDB_ID.ROOT)
+         if not vAdj[i][j] then
+            vAdj[i][j] = 0
+         end
+      end
+   end
+
+   -- riempio di conseguenza il resto della matrice
+   for i = 1, Proc.nFct do
+      vAdj[i][i] = 0
+      for j = i + 1, Proc.nFct do
+         vAdj[j][i] = vAdj[i][j]
+      end
+
+   end
+   return vAdj
+end
+
+---------------------------------------------------------------------
+-- restituisce un vettore con gli indici (0 based) delle facce triangolari (o quasi) di Proc
+function FaceData.GetTriangularFaces( Proc)
+   -- se la feature ha una sola faccia, esco subito
+   if Proc.nFct <= 1 then
+      return
+   end
+
+   local vTriangularFaces = {}
+
+   for i = 1, Proc.nFct do
+      if BeamLib.Is3EdgesApprox( Proc, i - 1) then
+         table.insert( vTriangularFaces, i - 1)
+      end
+
+   end
+   return vTriangularFaces
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetNotAdjacentFaces( Proc, idFace)
+   local NotAdjacentFaces = {}
+
+   for i = 1, Proc.nFct do
+      if Proc.Faces[i].id ~= idFace then
+         local bIsAdjacent = false
+         for j = 1, #Proc.Faces[idFace + 1].Adjacencies do
+            if Proc.Faces[i].id == Proc.Faces[idFace + 1].Adjacencies[j] then
+               bIsAdjacent = true
+            end
+         end
+         if not bIsAdjacent then
+            table.insert( NotAdjacentFaces, Proc.Faces[i])
+         end
+      end
+   end
+
+   return NotAdjacentFaces
+end
+
+---------------------------------------------------------------------
+-- restituisce una tabella che correla numero di adiacenze e id delle facce con quello stesso numero di adiacenze
+function FaceData.GetFacesByAdjacencyNumber( Proc)
+   -- se la feature ha una sola faccia, esco subito
+   if Proc.nFct <= 1 then
+      return {}
+   end
+   
+   local FacesByAdjacencyNumber = {}
+
+   for i = 1, 10 do
+      FacesByAdjacencyNumber[i] = {}
+   end
+   for i = 1, Proc.nFct do
+      table.insert( FacesByAdjacencyNumber[#Proc.Faces[i].Adjacencies], Proc.Faces[i])
+   end
+
+   return FacesByAdjacencyNumber
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetEdgesInfo( Proc, idFace )
+   local Edges = {}
+   local nFaceType, EdgesEgt = EgtSurfTmGetFacetOutlineInfo( Proc.id, idFace, GDB_ID.ROOT)
+
+   for i = 1, #EdgesEgt do
+      local nPreviousEdgeIndex = i - 1
+      if i == 1 then
+         nPreviousEdgeIndex = #EdgesEgt
+      end
+      local nNextEdgeIndex = i + 1
+      if i == #EdgesEgt then
+         nNextEdgeIndex = 1
+      end
+
+      -- l'elevazione si tiene sempre positiva e la normale sempre diretta verso l'interno della faccia
+      -- per sapere se il lato è aperto c'è la proprietà apposita bIsOpen
+      local CurrentEdge = {}
+      CurrentEdge.idAdjacentFace = EdgesEgt[i].Adj
+      CurrentEdge.dLength = EdgesEgt[i].Len
+      CurrentEdge.dElevation = abs( EdgesEgt[i].Elev)
+      CurrentEdge.bIsOpen = EdgesEgt[i].Open
+      CurrentEdge.vtN = Vector3d( EdgesEgt[i].Norm)
+      if CurrentEdge.bIsOpen then
+         CurrentEdge.vtN = -CurrentEdge.vtN
+      end
+      CurrentEdge.bIsStartOpen = EdgesEgt[nPreviousEdgeIndex].Open
+      CurrentEdge.bIsEndOpen = EdgesEgt[nNextEdgeIndex].Open
+      CurrentEdge.sType = 'Standard'
+
+      table.insert( Edges, CurrentEdge)
+   end
+
+   return nFaceType, Edges
+end
+
+-------------------------------------------------------------------------------------------------------------
+function FaceData.GetFacesInfo( Proc, Part)
+   EgtOutLog( '---Faces START---')
+   local Faces = {}
+
+   local vAdj
+   if Proc.AdjacencyMatrix then
+      vAdj = Proc.AdjacencyMatrix
+   else
+      vAdj = FaceData.GetAdjacencyMatrix( Proc)
+   end
+
+   if not Proc.nFct then
+      Proc.nFct = EgtSurfTmFacetCount( Proc.id) or 0
+   end
+
+   -- reset eventuali visualizzazioni facce a due colori
+   EgtSurfTmResetTwoColors( Proc.id)
+
+   for i = 1, Proc.nFct do
+      Faces[i] = {}
+      Faces[i].id = i - 1
+      Faces[i].ptCenter, Faces[i].vtN =  EgtSurfTmFacetCenter( Proc.id, i - 1, GDB_ID.ROOT)
+      if Proc.nFct < 6 then
+         -- frame OCS faccia
+         Faces[i].vtFrameHV = Frame3d( Faces[i].ptCenter, Faces[i].vtN)
+         -- elevazione calcolata rispetto al box della parte
+         Faces[i].dElevation = EgtSurfTmFacetElevationInBBox( Proc.id, i - 1, Part.b3Part, true, GDB_ID.ROOT)
+         -- TODO qui sarebbe meglio l'area vera e non quella del rettangolo minimo
+         local _, dLongEdgeDimension, dShortEdgeDimension = EgtSurfTmFacetMinAreaRectangle( Proc.id, i - 1, GDB_ID.ROOT)
+         Faces[i].dArea = dShortEdgeDimension * dLongEdgeDimension
+
+         local nFaceType, Edges = GetEdgesInfo( Proc, i - 1)
+         Faces[i].bIsOkForMachining = nFaceType < 1
+         Faces[i].Edges = Edges
+
+         -- TODO valutare se fare un output unico alla fine o gestire log in altro modo
+         EgtOutLog( 'Facet ' .. Faces[i].id .. ' of ' .. Proc.nFct - 1)
+         EgtOutLog( '   vtN: ' .. tostring( Faces[i].vtN))
+
+         -- adiacenze della faccia
+         -- TODO chiamarle in modo che si capisca che sono solo gli id e non l'intero oggetto faccia
+         Faces[i].Adjacencies = {}
+         for j = 1, Proc.nFct do
+            if vAdj[i][j] and vAdj[i][j] ~= 0 and ( i ~= j) then
+               table.insert( Faces[i].Adjacencies, j - 1)
+               if EgtGetDebugLevel() >= 3 then
+                  EgtOutLog( '   Adjacent to facet: ' .. j - 1)
+               end
+            end
+         end
+      end
+
+   end
+
+   EgtOutLog( '---Faces END---')
+   return Faces
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- TODO valutare refactoring per mettere i calcoli del tunnel in una funzione
+-- TODO creare le facce tunnel solo se non ci sono già. Verirficare all'inizio se già presente in AddGrpId e nel caso riferire all'id di quella esistente e ricalcolare solo le informazioni della faccia.
+local function GetTunnelFaces( Proc, Part)
+   local TunnelAddedFaces = {}
+
+   if not ( Proc.Topology.bIsThrough and Proc.Topology.bAllRightAngles and Proc.nFct < 5) then
+      error( 'GetTunnelFaces : Topology not implemented')
+   end
+
+   -- direzione del tunnel
+   local vtTunnelDirection = Proc.Faces[1].vtN ^ Proc.Faces[ Proc.Faces[1].Adjacencies[1] + 1].vtN
+   
+   -- centro del tunnel
+   local frTunnel = Frame3d( Proc.Faces[1].ptCenter, vtTunnelDirection)
+   local b3Tunnel = EgtGetBBoxRef( Proc.id, GDB_BB.STANDARD, frTunnel)
+   local ptTunnelCenter = b3Tunnel:getCenter()
+   ptTunnelCenter:toGlob( frTunnel)
+
+   -- recupero gruppo per geometria addizionale
+   local nAddGrpId = BeamLib.GetAddGroup( Proc.idPart)
+   if not nAddGrpId then
+      -- TODO gestire meglio questo errore. Non conviene creare e verificare all'inizio se il gruppo esiste?
+      EgtOutLog( 'Error : missing AddGroup')
+      return TunnelAddedFaces
+   end
+
+   -- faccia centrale
+   local nMiddleTmId = EgtSurfTmPlaneInBBox( nAddGrpId, ptTunnelCenter, vtTunnelDirection, Part.b3Part, GDB_ID.ROOT)
+   -- TODO se non si riesce a costruire la faccia bisogna dare errore o semplicemente non ritornarla??
+   for i = 1, Proc.nFct do
+      EgtCutSurfTmPlane( nMiddleTmId, Proc.Faces[i].ptCenter, -Proc.Faces[i].vtN, false, GDB_ID.ROOT)
+   end
+
+   -- facce laterali
+   local nLateralTmId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
+   EgtCutSurfTmPlane( nLateralTmId, ptTunnelCenter, -vtTunnelDirection, false, GDB_ID.ROOT)
+
+   -- unione facce
+   -- TODO cambiare nome alla trimesh?? non contiene più solamente la faccia di mezzo
+   TunnelAddedFaces.MiddleFaceTm = {}
+   TunnelAddedFaces.MiddleFaceTm.id = EgtSurfTmBySewing( nAddGrpId, { nMiddleTmId, nLateralTmId}, true)
+
+   -- TODO c'è un modo più elegante per raccogliere le informazioni delle facce aggiunte
+   TunnelAddedFaces.MiddleFaceTm.sType = 'Tunnel'
+   TunnelAddedFaces.MiddleFaceTm.nFct = Proc.nFct + 1
+   TunnelAddedFaces.MiddleFaceTm.Faces = FaceData.GetFacesInfo( TunnelAddedFaces.MiddleFaceTm, Part)
+
+   return TunnelAddedFaces
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetBottomFaces( Proc)
+   local BottomFaces = {}
+
+   if Proc.Topology.sFamily == 'Tunnel' then
+      return nil
+   elseif not ( Proc.Topology.sFamily == 'Rabbet' or Proc.Topology.sFamily == 'VGroove' or Proc.Topology.sFamily == 'Groove' or Proc.Topology.sFamily == 'Pocket') then
+      error( 'GetBottomFace : Topology not implemented')
+   end
+
+   -- la faccia di fondo ha sempre Fct - 1 adiacenze
+   local FacesByAdjacencyNumber = FaceData.GetFacesByAdjacencyNumber( Proc)
+   if FacesByAdjacencyNumber then
+      BottomFaces = FacesByAdjacencyNumber[ Proc.nFct - 1]
+      -- si rimuovono le facce non adatte ad essere lavorate
+      local nBottomFaces = #BottomFaces
+      local nCurrentFace = 1
+      while nCurrentFace <= nBottomFaces do
+         if not BottomFaces[nCurrentFace].bIsOkForMachining then
+            table.remove( BottomFaces, nCurrentFace)
+            nBottomFaces = nBottomFaces - 1
+         end
+         nCurrentFace = nCurrentFace + 1
+      end
+      -- la BottomFace 1 è sempre quella con minor elevazione
+      table.sort( BottomFaces, function (a, b) return a.dElevation < b.dElevation end)
+   end
+
+   if #BottomFaces == 0 then
+      return nil
+   end
+
+   BottomFaces[1].sType = 'Bottom'
+   BottomFaces[1].MainEdges = {}
+   BottomFaces[1].MainEdges.LongEdges = {}
+   BottomFaces[1].MainEdges.SideEdges = {}
+   
+   local ClosedEdgesSortedByGreatestLength = {}
+   for i = 1, #BottomFaces[1].Edges do
+      if not BottomFaces[1].Edges[i].bIsOpen then
+         table.insert( ClosedEdgesSortedByGreatestLength, {})
+         ClosedEdgesSortedByGreatestLength[#ClosedEdgesSortedByGreatestLength].nIndex = i
+         ClosedEdgesSortedByGreatestLength[#ClosedEdgesSortedByGreatestLength].dLength = BottomFaces[1].Edges[i].dLength
+      end
+   end
+   table.sort( ClosedEdgesSortedByGreatestLength, function (a, b) return a.dLength > b.dLength end)
+   local nFirstLongEdgeIndex = ClosedEdgesSortedByGreatestLength[1].nIndex
+
+   for i = 1, #BottomFaces[1].Edges do
+      local nPreviousEdgeIndex = i - 1
+      if i == 1 then
+         nPreviousEdgeIndex = #BottomFaces[1].Edges
+      end
+      local nNextEdgeIndex = i + 1
+      if i == #BottomFaces[1].Edges then
+         nNextEdgeIndex = 1
+      end
+
+      local CurrentEdge = {}
+      CurrentEdge.idAdjacentFace = BottomFaces[1].Edges[i].idAdjacentFace
+      CurrentEdge.vtN = BottomFaces[1].Edges[i].vtN
+      CurrentEdge.dLength = BottomFaces[1].Edges[i].dLength
+      CurrentEdge.bIsOpen = BottomFaces[1].Edges[i].bIsOpen
+      CurrentEdge.dElevation = BottomFaces[1].Edges[i].dElevation
+      CurrentEdge.bIsStartOpen = BottomFaces[1].Edges[i].bIsStartOpen
+      CurrentEdge.bIsEndOpen = BottomFaces[1].Edges[i].bIsEndOpen
+
+      if i == nFirstLongEdgeIndex then
+         BottomFaces[1].MainEdges.LongEdges[1] = CurrentEdge
+         BottomFaces[1].MainEdges.LongEdges[1].sType = 'Long'
+      elseif nNextEdgeIndex == nFirstLongEdgeIndex then
+         BottomFaces[1].MainEdges.SideEdges[1] = CurrentEdge
+         BottomFaces[1].MainEdges.SideEdges[1].sType = 'Side'
+      elseif nPreviousEdgeIndex == nFirstLongEdgeIndex then
+         BottomFaces[1].MainEdges.SideEdges[2] = CurrentEdge
+         BottomFaces[1].MainEdges.SideEdges[2].sType = 'Side'
+      else
+         BottomFaces[1].MainEdges.LongEdges[2] = CurrentEdge
+         BottomFaces[1].MainEdges.LongEdges[2].sType = 'Long'
+      end
+   end
+   
+   return BottomFaces
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetLongFaces( Proc, MainFaces)
+   local LongFaces = {}
+
+   if Proc.nFct > 5 then
+      error( 'GetLongFaces : Topology not implemented')
+   end
+
+   local BottomFace
+   local BottomFaces = MainFaces.BottomFaces or GetBottomFaces( Proc)
+   if BottomFaces and #BottomFaces > 0 then
+      BottomFace = BottomFaces[1]
+   end
+
+   local idFirstLongFace = GDB_ID.NULL
+   local idSecondLongFace = GDB_ID.NULL
+   if not BottomFace then
+      local FacesSortedByGreatestArea = {}
+      for i = 1, Proc.nFct do
+         FacesSortedByGreatestArea[i] = {}
+         FacesSortedByGreatestArea[i].id = Proc.Faces[i].id
+         FacesSortedByGreatestArea[i].dArea = Proc.Faces[i].dArea
+      end
+      table.sort( FacesSortedByGreatestArea, function (a, b) return a.dArea > b.dArea end)
+      idFirstLongFace = FacesSortedByGreatestArea[1].id
+      local FacesNotAdjacent = GetNotAdjacentFaces( Proc, idFirstLongFace)
+      idSecondLongFace = FacesNotAdjacent[1].id
+   else
+      if not BottomFace.MainEdges.LongEdges[1].bIsOpen then
+         idFirstLongFace = BottomFace.MainEdges.LongEdges[1].idAdjacentFace
+      end
+      if not BottomFace.MainEdges.LongEdges[2].bIsOpen then
+         idSecondLongFace = BottomFace.MainEdges.LongEdges[2].idAdjacentFace
+      end
+   end
+   if idFirstLongFace > -1 and Proc.Faces[idFirstLongFace + 1].bIsOkForMachining then
+      table.insert( LongFaces, Proc.Faces[idFirstLongFace + 1])
+   end
+   if idSecondLongFace > -1 and Proc.Faces[idSecondLongFace + 1].bIsOkForMachining then
+      table.insert( LongFaces, Proc.Faces[idSecondLongFace + 1])
+   end
+
+   for i = 1, #LongFaces do
+      LongFaces[i].sType = 'Long'
+      LongFaces[i].MainEdges = {}
+      LongFaces[i].MainEdges.SideEdges = {}
+      LongFaces[i].MainEdges.OppositeEdges = {}
+
+      for j = 1, #LongFaces[i].Edges do
+         local nPreviousEdgeIndex = j - 1
+         if j == 1 then
+            nPreviousEdgeIndex = #LongFaces[1].Edges
+         end
+         local nNextEdgeIndex = j + 1
+         if j == #LongFaces[i].Edges then
+            nNextEdgeIndex = 1
+         end
+
+         local CurrentEdge = {}
+         CurrentEdge.idAdjacentFace = LongFaces[i].Edges[j].idAdjacentFace
+         CurrentEdge.vtN = LongFaces[i].Edges[j].vtN
+         CurrentEdge.dLength = LongFaces[i].Edges[j].dLength
+         CurrentEdge.bIsOpen = LongFaces[i].Edges[j].bIsOpen
+         CurrentEdge.dElevation = LongFaces[i].Edges[j].dElevation
+         CurrentEdge.bIsStartOpen = LongFaces[i].Edges[j].bIsStartOpen
+         CurrentEdge.bIsEndOpen = LongFaces[i].Edges[j].bIsEndOpen
+
+         if Proc.Topology.sFamily == 'Tunnel' then
+            if CurrentEdge.idAdjacentFace > -1 then
+               table.insert( LongFaces[i].MainEdges.SideEdges, CurrentEdge)
+               LongFaces[i].MainEdges.SideEdges[#LongFaces[i].MainEdges.SideEdges].sType = 'Side'
+            else
+               table.insert( LongFaces[i].MainEdges.OppositeEdges, CurrentEdge)
+               LongFaces[i].MainEdges.OppositeEdges[#LongFaces[i].MainEdges.OppositeEdges].sType = 'Opposite'
+            end
+         else
+            if CurrentEdge.idAdjacentFace == BottomFace.id then
+               LongFaces[i].MainEdges.BottomEdge = CurrentEdge
+               LongFaces[i].MainEdges.BottomEdge.sType = 'Bottom'
+            elseif LongFaces[i].Edges[nNextEdgeIndex].idAdjacentFace == BottomFace.id then
+               LongFaces[i].MainEdges.SideEdges[1] = CurrentEdge
+               LongFaces[i].MainEdges.SideEdges[1].sType = 'Side'
+            elseif LongFaces[i].Edges[nPreviousEdgeIndex].idAdjacentFace == BottomFace.id then
+               LongFaces[i].MainEdges.SideEdges[2] = CurrentEdge
+               LongFaces[i].MainEdges.SideEdges[2].sType = 'Side'
+            else
+               table.insert( LongFaces[i].MainEdges.OppositeEdges, CurrentEdge)
+               LongFaces[i].MainEdges.OppositeEdges[#LongFaces[i].MainEdges.OppositeEdges].sType = 'Opposite'
+            end
+         end
+      end
+   end
+
+   return LongFaces
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetSideFaces( Proc, MainFaces)
+   local SideFaces = {}
+
+   if Proc.nFct > 5 then
+      error( 'GetSideFaces : Topology not implemented')
+   end
+
+   local BottomFace
+   local BottomFaces = MainFaces.BottomFaces or GetBottomFaces( Proc)
+   if BottomFaces and #BottomFaces > 0 then
+      BottomFace = BottomFaces[1]
+   end
+   local LongFaces = MainFaces.LongFaces or GetLongFaces( Proc, MainFaces)
+
+   local idFirstSideFace = GDB_ID.NULL
+   local idSecondSideFace = GDB_ID.NULL
+   if not LongFaces[1].MainEdges.SideEdges[1].bIsOpen then
+      idFirstSideFace = LongFaces[1].MainEdges.SideEdges[1].idAdjacentFace
+   end
+   if not LongFaces[1].MainEdges.SideEdges[2].bIsOpen then
+      idSecondSideFace = LongFaces[1].MainEdges.SideEdges[2].idAdjacentFace
+   end
+   if idFirstSideFace > -1 and Proc.Faces[idFirstSideFace + 1].bIsOkForMachining then
+      table.insert( SideFaces, Proc.Faces[idFirstSideFace + 1])
+      SideFaces[#SideFaces].sType = 'Side'
+   end
+   if idSecondSideFace > -1 and Proc.Faces[idSecondSideFace + 1].bIsOkForMachining then
+      table.insert( SideFaces, Proc.Faces[idSecondSideFace + 1])
+      SideFaces[#SideFaces].sType = 'Side'
+   end
+
+   for i = 1, #SideFaces do
+      SideFaces[i].sType = 'Side'
+      SideFaces[i].MainEdges = {}
+      SideFaces[i].MainEdges.LongEdges = {}
+      SideFaces[i].MainEdges.OppositeEdges = {}
+
+      for j = 1, #SideFaces[i].Edges do
+         local nPreviousEdgeIndex = j - 1
+         if j == 1 then
+            nPreviousEdgeIndex = #SideFaces[1].Edges
+         end
+         local nNextEdgeIndex = j + 1
+         if j == #SideFaces[i].Edges then
+            nNextEdgeIndex = 1
+         end
+
+         local CurrentEdge = {}
+         CurrentEdge.idAdjacentFace = SideFaces[i].Edges[j].idAdjacentFace
+         CurrentEdge.vtN = SideFaces[i].Edges[j].vtN
+         CurrentEdge.dLength = SideFaces[i].Edges[j].dLength
+         CurrentEdge.bIsOpen = SideFaces[i].Edges[j].bIsOpen
+         CurrentEdge.dElevation = SideFaces[i].Edges[j].dElevation
+         CurrentEdge.bIsStartOpen = SideFaces[i].Edges[j].bIsStartOpen
+         CurrentEdge.bIsEndOpen = SideFaces[i].Edges[j].bIsEndOpen
+
+         if Proc.Topology.sFamily == 'Tunnel' then
+            if CurrentEdge.idAdjacentFace > -1 then
+               table.insert( SideFaces[i].MainEdges.LongEdges, CurrentEdge)
+            else
+               table.insert( SideFaces[i].MainEdges.OppositeEdges, CurrentEdge)
+            end
+         else
+            if CurrentEdge.idAdjacentFace == BottomFace.id then
+               SideFaces[i].MainEdges.BottomEdge = CurrentEdge
+               SideFaces[i].MainEdges.BottomEdge.sType = 'Bottom'
+            elseif SideFaces[i].Edges[nNextEdgeIndex].idAdjacentFace == BottomFace.id then
+               SideFaces[i].MainEdges.LongEdges[1] = CurrentEdge
+               SideFaces[i].MainEdges.LongEdges[1].sType = 'Long'
+            elseif SideFaces[i].Edges[nPreviousEdgeIndex].idAdjacentFace == BottomFace.id then
+               SideFaces[i].MainEdges.LongEdges[2] = CurrentEdge
+               SideFaces[i].MainEdges.LongEdges[2].sType = 'Long'
+            else
+               table.insert( SideFaces[i].MainEdges.OppositeEdges, CurrentEdge)
+               SideFaces[i].MainEdges.OppositeEdges[#SideFaces[i].MainEdges.OppositeEdges].sType = 'Opposite'
+            end
+         end
+      end
+   end
+
+   return SideFaces
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- recupero facce principali della feature, in base alla topologia
+function FaceData.GetMainFaces( Proc, Part)
+
+   EgtOutLog( '---MainFaces START---')
+   local MainFaces = {}
+
+   -- CASO 1 : Feature tipo LapJoint
+   if Proc.Topology.sFamily == 'Rabbet' or Proc.Topology.sFamily == 'VGroove' or Proc.Topology.sFamily == 'Groove' or Proc.Topology.sFamily == 'Pocket' or Proc.Topology.sFamily == 'Tunnel' then
+      
+      if Proc.Topology.bIsThrough and Proc.Topology.bAllRightAngles and Proc.nFct < 5 then
+         MainFaces.TunnelAddedFaces = GetTunnelFaces( Proc, Part)
+      end
+
+      MainFaces.BottomFaces = GetBottomFaces( Proc)
+      MainFaces.LongFaces = GetLongFaces( Proc, MainFaces)
+      MainFaces.SideFaces = GetSideFaces( Proc, MainFaces)
+
+      -- scrivo informazioni delle facce nel log
+      if EgtGetDebugLevel() >= 3 then
+         Logs.WriteMainFacesLog( Proc, MainFaces)
+      end
+   else
+      MainFaces = nil
+      EgtOutLog( '---MainFaces NOT NEEDED---')
+   end
+
+   EgtOutLog( '---MainFaces END---')
+   return MainFaces
+end
+
+
+-------------------------------------------------------------------------------------------------------------
+return FaceData

LuaLibs/FeatureLib.lua

@@ -0,0 +1,590 @@
+-- FeatureLib.lua by Egalware s.r.l. 2024/04/02
+-- Libreria lettura o calcolo dati e proprietà della feature
+-- 2024/04/02 PRIMA VERSIONE CALCOLO LAVORAZIONI CON STRATEGIE
+
+-- Tabella per definizione modulo
+local FeatureLib = {}
+
+-- Carico i dati globali
+local BeamData = require( 'BeamData')
+
+-- carico librerie
+local BeamLib = require( 'BeamLib')
+local FaceData = require( 'FaceData')
+local ID = require( 'Identity')
+
+
+-------------------------------------------------------------------------------------------------------------
+-- recupero topologia della feature
+function FeatureLib.NeedTopologyFeature( Proc)
+   -- features tipo taglio
+   if ID.IsCut( Proc) then
+      return true
+   elseif ID.IsHeadCut( Proc) then
+      return true
+   elseif ID.IsTailCut( Proc) then
+      return true
+   elseif ID.IsDoubleCut( Proc) then
+      return true
+   elseif ID.IsSawCut( Proc) then
+      return true
+   -- features tipo taglio longitudinale
+   elseif ID.IsLongitudinalCut( Proc) then
+      return true
+   elseif ID.IsDoubleLongitudinalCut( Proc) then
+      return true
+   elseif ID.IsChamfer( Proc) then
+      return true
+   -- features tipo LapJoint
+   elseif ID.IsSlot( Proc) then
+      return true
+   elseif ID.IsFrontSlot( Proc) then
+      return true
+   elseif ID.IsRidgeLap( Proc) then
+      return true
+   elseif ID.IsLapJoint( Proc) then
+      return true
+   elseif ID.IsNotchRabbet( Proc) then
+      return true
+   elseif ID.IsNotch( Proc) then
+      return true
+   elseif ID.IsPocket( Proc) then
+      return true
+   -- calcolo topologia SOLO se non raggiata
+   -- TODO oppure riconoscerla come feature speciale; valutare se controllare il numero di facce è un metodo efficace
+   elseif ID.IsMortise( Proc) and Proc.nFct < 6 then
+      return true
+   -- calcolo topologia SOLO se non raggiata
+   -- TODO oppure riconoscerla come feature speciale; valutare se controllare il numero di facce è un metodo efficace
+   elseif ID.IsFrontMortise( Proc) and Proc.nFct < 6 then
+      return true
+   end
+
+   -- se feature non tra quelle sopra, riconoscimento topologico non necessario
+   return false
+end
+
+---------------------------------------------------------------------
+-- restituisce true se Proc ha tutti gli angoli concavi (bAllConcave) e, nei casi in cui ha senso, se questi sono esattamente 90 deg (bAllRight)
+local function AreAllAnglesConcaveOrRight( vAdj)
+   -- se la feature ha una sola faccia, esco subito
+   if #vAdj <= 1 then
+      return
+   end
+
+   local bAllConcave, bAllRight = true, true
+
+   local nFct = #( vAdj or {})
+   for i = 1, nFct do
+      for j = 1, nFct do
+         -- se trovo un angolo convesso restituisco falso e esco subito
+         if vAdj[i][j] and vAdj[i][j] > 0 then
+            bAllConcave = false
+            bAllRight = false
+            break
+         elseif vAdj[i][j] and vAdj[i][j] ~= 0 and vAdj[i][j] + 90 > 500 * GEO.EPS_ANG_SMALL then
+            bAllRight = false
+         end
+      end
+   end
+
+   -- se 1 faccia oppure 2 facce con angolo convesso non ha senso ritornare valori per bAllRight
+   if nFct < 2 or ( nFct == 2 and vAdj[1][2] > 0) then
+      return bAllConcave
+   else
+      return bAllConcave, bAllRight
+   end
+end
+
+---------------------------------------------------------------------
+-- restituisce true se almeno una delle dimensioni della feature è maggiore o uguale ad una delle dimensioni principali del pezzo (tolleranza 1 mm)
+local function IsAnyDimensionLongAsPart( Proc, Part)
+   local bResult = false
+
+   if Proc.b3Box:getDimX() > Part.b3Part:getDimX() - 1000 * GEO.EPS_SMALL or
+      Proc.b3Box:getDimY() > Part.b3Part:getDimY() - 1000 * GEO.EPS_SMALL or
+      Proc.b3Box:getDimZ() > Part.b3Part:getDimZ() - 1000 * GEO.EPS_SMALL then
+      bResult = true
+   end
+
+   return bResult
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- restituisce vero se la feature con box b3Proc taglia l'intera sezione della barra, rappresentata dalle sue dimensioni W e H
+local function IsFeatureCuttingEntireSection( b3Proc, Part)
+   return ( b3Proc:getDimY() > ( Part.b3Raw:getDimY() - 500 * GEO.EPS_SMALL)  and  b3Proc:getDimZ() > ( Part.b3Raw:getDimZ() - 500 * GEO.EPS_SMALL))
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- restituisce vero se la feature con box b3Proc taglia l'intera lunghezza della barra, rappresentata dalle sue dimensioni W e L oppure H e L
+local function IsFeatureCuttingEntireLength( b3Proc, Part)
+   return ( ( b3Proc:getDimY() > ( Part.b3Raw:getDimY() - 500 * GEO.EPS_SMALL)  and  b3Proc:getDimX() > ( Part.b3Raw:getDimX() - 500 * GEO.EPS_SMALL)) or
+            ( b3Proc:getDimZ() > ( Part.b3Raw:getDimZ() - 500 * GEO.EPS_SMALL)  and  b3Proc:getDimX() > ( Part.b3Raw:getDimX() - 500 * GEO.EPS_SMALL)))
+end
+
+---------------------------------------------------------------------
+-- restituisce una stringa con il nome esteso della topologia della feature
+-- *famiglia - numero di facce - passante*
+local function GetTopologyName( sFamily, nNumberOfFaces, bIsThrough)
+   return sFamily .. '-' .. tostring( nNumberOfFaces) .. '-' .. EgtIf( bIsThrough, 'Through', 'Blind')
+end
+
+---------------------------------------------------------------------
+-- recupera topologia feature
+function FeatureLib.ClassifyTopology( Proc, Part)
+   local FeatureTopology = {}
+
+   if not Proc.AffectedFaces then Proc.AffectedFaces = BeamLib.GetAffectedFaces( Proc, Part) end
+
+   local bIsFeatureCuttingEntireSection = IsFeatureCuttingEntireSection( Proc.b3Box, Part)
+   local bIsFeatureCuttingEntireLength = IsFeatureCuttingEntireLength( Proc.b3Box, Part)
+   local bIsAnyDimensionLongAsPart = IsAnyDimensionLongAsPart( Proc, Part)
+   local vAdj = Proc.AdjacencyMatrix
+   local bAllAnglesConcave, bAllRightAngles = AreAllAnglesConcaveOrRight( vAdj)
+   local vTriangularFaces = FaceData.GetTriangularFaces( Proc)
+   local vFacesByAdjNumber = FaceData.GetFacesByAdjacencyNumber( Proc)
+
+   local sFamily
+   local bIsThrough
+   if Proc.nFct == 1 and ( bIsFeatureCuttingEntireSection or bIsFeatureCuttingEntireLength) then
+      sFamily = 'Cut'
+      bIsThrough = true
+   elseif Proc.nFct == 1 then
+      sFamily = 'Bevel'
+      bIsThrough = true
+   elseif Proc.nFct == 2 and bAllAnglesConcave and #vTriangularFaces == 1 then
+      sFamily = 'Bevel'
+      bIsThrough = false
+   elseif Proc.nFct == 2 and bAllAnglesConcave and ( Proc.AffectedFaces.bLeft or Proc.AffectedFaces.bRight) and ( Proc.AffectedFaces.bFront or Proc.AffectedFaces.bBack) then
+      sFamily = 'Rabbet'
+      bIsThrough = true
+   elseif Proc.nFct == 2 and bAllAnglesConcave then
+      sFamily = 'VGroove'
+      bIsThrough = true
+   elseif Proc.nFct == 2 and not bAllAnglesConcave and bIsAnyDimensionLongAsPart then
+      sFamily = 'DoubleBevel'
+      bIsThrough = true
+   elseif Proc.nFct == 3 and bAllAnglesConcave and #vFacesByAdjNumber[2] == 1 and #vTriangularFaces == 2 then
+      sFamily = 'Bevel'
+      bIsThrough = false
+   elseif Proc.nFct == 3 and bAllAnglesConcave and #vFacesByAdjNumber[2] == 1 and bIsAnyDimensionLongAsPart then
+      sFamily = 'Groove'
+      bIsThrough = true
+   elseif Proc.nFct == 3 and bAllAnglesConcave and #vFacesByAdjNumber[2] == 3 then
+      sFamily = 'Groove'
+      bIsThrough = false
+   elseif Proc.nFct == 4 and #vFacesByAdjNumber[2] == 4  and #vTriangularFaces == 2 then
+      sFamily = 'DoubleBevel'
+      bIsThrough = false
+   elseif Proc.nFct == 4 and bAllAnglesConcave and #vFacesByAdjNumber[3] == 2 then
+      sFamily = 'Groove'
+      bIsThrough = false
+   elseif Proc.nFct == 4 and bAllAnglesConcave and #vFacesByAdjNumber[2] == 4 and bIsAnyDimensionLongAsPart then
+      sFamily = 'Tunnel'
+      bIsThrough = true
+   elseif Proc.nFct >= 4 and #vFacesByAdjNumber[1] == 2 and bIsAnyDimensionLongAsPart then
+      sFamily = 'Strip'
+      bIsThrough = true
+   elseif Proc.nFct == 5 and bAllAnglesConcave and #vFacesByAdjNumber[4] == 1 then
+      sFamily = 'Pocket'
+      bIsThrough = false
+   elseif Proc.nFct == 6 and #vFacesByAdjNumber[2] == 4 and #vFacesByAdjNumber[3] == 2 and #vTriangularFaces == 4 then
+      sFamily = 'DoubleBevel'
+      bIsThrough = false
+   end
+
+   if sFamily then
+      FeatureTopology.sFamily = sFamily
+      FeatureTopology.bIsThrough = bIsThrough
+      FeatureTopology.bAllRightAngles = bAllRightAngles
+      FeatureTopology.sName = GetTopologyName( sFamily, Proc.nFct, bIsThrough)
+      FeatureTopology.AdjacencyMatrix = vAdj
+   -- feature che necessita di essere catalogata, ma non si capisce come
+   else
+      FeatureTopology.sFamily = 'NOT_IMPLEMENTED'
+      FeatureTopology.sName = FeatureTopology.sFamily
+   end
+
+   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)
+   local AuxId = EgtGetInfo( Proc.id, 'AUXID', 'i')
+
+   -- verifico se foro da adattare
+   if EgtExistsInfo( Proc.id, 'DiamUser') then
+      if AuxId then AuxId = AuxId + Proc.id end
+      if AuxId and EgtGetType( AuxId) == GDB_TY.CRV_ARC and BeamData.USER_HOLE_DIAM and BeamData.USER_HOLE_DIAM > 1 then
+         EgtModifyArcRadius( AuxId, BeamData.USER_HOLE_DIAM / 2)
+      end
+   end
+
+   local dDiam = EgtGetInfo( Proc.id, 'P12', 'd') or 0
+   local dLen = abs( EgtCurveThickness( Proc.id + AuxId)) or 0
+   local nFcs = EgtGetInfo( Proc.id, 'FCS', 'i') or 0
+   local nFce = EgtGetInfo( Proc.id, 'FCE', 'i') or 0
+
+   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)
+   -- indice di completamento
+   local nCompletionIndex = 0
+
+   -- nullo
+   if dCompletionPercentage < 5 then
+      nCompletionIndex = 0
+   -- Low
+   elseif dCompletionPercentage < 50 then
+      nCompletionIndex = 1
+   -- Medium
+   elseif dCompletionPercentage < 80 then
+      nCompletionIndex = 2
+   -- High / Complete
+   else
+      nCompletionIndex = 5
+   end
+
+   return nCompletionIndex
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- funzione che restituisce qualità della lavorazione in base agli utensili utilizzati
+function FeatureLib.GetFeatureQuality( sTypeTools)
+   local nQuality = 5
+   local TypeTools = EgtSplitString( sTypeTools)
+
+   -- indice in base a utensile
+   for i=1, #TypeTools do
+      if TypeTools[i] == 'Blade' then
+         nQuality = min( nQuality, 5)
+      elseif TypeTools[i] == 'Mill' then
+         nQuality = min( nQuality, 4)
+      elseif TypeTools[i] == 'Chainsaw' then
+         nQuality = min( nQuality, 2)
+      else
+         nQuality = min( nQuality, 1)
+      end
+   end
+   -- se si utilizzano più utensili si perde in qualità
+   if #TypeTools > 1 then
+      nQuality = max( nQuality - 1, 0.5)
+   end
+
+   return nQuality
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- funzione che calcola il 'CompositeRating' di ogni strategia
+function FeatureLib.CalculateCompositeRating( StrategyResult)
+   -- se ho tutti i dati che mi servono calcolo il rating della strategia applicato alla feature
+   if StrategyResult and StrategyResult.nQuality and StrategyResult.nCompletionIndex and StrategyResult.dMRR then
+      StrategyResult.dCompositeRating = ceil( StrategyResult.nQuality * StrategyResult.nCompletionIndex * StrategyResult.dMRR)
+   else
+      StrategyResult.dCompositeRating = 0
+   end
+
+   return StrategyResult
+end
+
+-------------------------------------------------------------------------------------------------------------
+function FeatureLib.IsMachiningLong( dMachiningLengthOnX, Part, OptionalParameters)
+   local bIsMachiningLong
+
+   -- parametri opzionali
+   if not OptionalParameters then
+      OptionalParameters = {}
+   end
+   local dMaxSegmentLength = OptionalParameters.dMaxSegmentLength or BeamData.LONGCUT_MAXLEN
+
+   bIsMachiningLong = ( dMachiningLengthOnX > dMaxSegmentLength + 10 * GEO.EPS_SMALL)
+                      or ( dMachiningLengthOnX > 0.7 * Part.b3Part:getDimX() + 10 * GEO.EPS_SMALL)
+
+   return bIsMachiningLong
+end
+
+-------------------------------------------------------------------------------------------------------------
+function FeatureLib.GetFeatureSplittingPoints( Proc, Part, OptionalParameters)
+   local FeatureSplittingPoints = {}
+   local bFeatureStartsOnEdgeLeft = false
+   local bFeatureStartsOnEdgeRight = false
+   local dSplitXLeft = Proc.b3Box:getMin():getX()
+   local dSplitXRight = Proc.b3Box:getMax():getX()
+   local dFeatureCentralLength = Proc.b3Box:getDimX()
+
+   -- parametri opzionali
+   if not OptionalParameters then
+      OptionalParameters = {}
+   end
+   local dMaxSegmentLength = OptionalParameters.dMaxSegmentLength or BeamData.LONGCUT_MAXLEN
+   local dMaxSegmentLengthOnEdges = OptionalParameters.dMaxSegmentLengthOnEdges or BeamData.LONGCUT_ENDLEN
+   local dMinSegmentLength = OptionalParameters.dMinSegmentLength or dMaxSegmentLengthOnEdges / 2
+   local dToolOverlapBetweenSegments = OptionalParameters.dToolOverlapBetweenSegments or BeamData.MILL_OVERLAP
+
+   -- verifica spezzatura necessaria
+   if not FeatureLib.IsMachiningLong( Proc.b3Box:getDimX(), Part) then
+      return {}
+   end
+
+   -- verifica se necessari spezzoni differenti sugli estremi
+   if Proc.b3Box:getMin():getX() < Part.b3Part:getMin():getX() + dMaxSegmentLengthOnEdges - 10 * GEO.EPS_SMALL then
+      bFeatureStartsOnEdgeLeft = true
+   end
+   if Proc.b3Box:getMax():getX() > Part.b3Part:getMax():getX() - dMaxSegmentLengthOnEdges + 10 * GEO.EPS_SMALL then
+      bFeatureStartsOnEdgeRight = true
+   end
+
+   -- calcolo punto estremo sinistro
+   local ptSplitXLeft
+   if bFeatureStartsOnEdgeLeft then
+      -- decido punto spezzatura verso la coda
+      if Proc.b3Box:getDimX() > dMaxSegmentLengthOnEdges * 2 then
+         dSplitXLeft = max( Part.b3Part:getMin():getX() + dMaxSegmentLengthOnEdges, Proc.b3Box:getMin():getX() + dMinSegmentLength)
+      else
+         -- se pezzo abbastanza piccolo, spezzo in mezzo al 'pezzo + grezzo restante'
+         if Part.dRestLength + Part.b3Part:getDimX() < BeamData.dMinRaw * 1.5 then
+            dSplitXLeft = Part.b3Part:getMax():getX() - ( ( Part.dRestLength + Part.b3Part:getDimX()) / 2)
+         else
+            dSplitXLeft = max( Proc.b3Box:getMin():getX() + ( BeamData.dMinRaw)/2 + 150, Part.b3Part:getMax():getX() - dMaxSegmentLengthOnEdges)
+         end
+      end
+      dFeatureCentralLength = abs( dSplitXRight - dSplitXLeft)
+      ptSplitXLeft = Point3d( dSplitXLeft, 0, 0)
+   end
+
+   -- calcolo punto estremo destro
+   local ptSplitXRight
+   if bFeatureStartsOnEdgeRight then
+      dSplitXRight = min( ( Proc.b3Box:getMax():getX() - dMinSegmentLength), Part.b3Part:getMax():getX() - dMaxSegmentLengthOnEdges)
+      if dSplitXRight - dSplitXLeft < 500 * GEO.EPS_SMALL then
+         dSplitXRight = dSplitXLeft - dToolOverlapBetweenSegments
+         dFeatureCentralLength = 0
+      else
+         dFeatureCentralLength = dSplitXRight - dSplitXLeft
+      end
+      ptSplitXRight = Point3d( dSplitXRight, 0, 0)
+   end
+
+   -- aggiungo eventuale punto estremo destro
+   if bFeatureStartsOnEdgeRight then
+      table.insert( FeatureSplittingPoints, ptSplitXRight)
+   end
+
+   -- aggiungo punti centrali della feature
+   if dFeatureCentralLength > 0 then
+      local nSplitParts = max( ceil( dFeatureCentralLength / dMaxSegmentLength + 10 * GEO.EPS_SMALL), 1)
+      local dSplitPartsLen = dFeatureCentralLength / nSplitParts
+      for i = 1, ( nSplitParts - 1) do
+         local ptOn
+         local dCurrentPointX = dSplitXRight - i * dSplitPartsLen
+         ptOn = Point3d( dCurrentPointX, 0, 0)
+         table.insert( FeatureSplittingPoints, ptOn)
+      end
+   end
+
+   -- aggiungo eventuale punto estemo sinistro
+   if bFeatureStartsOnEdgeLeft then
+      table.insert( FeatureSplittingPoints, ptSplitXLeft)
+   end
+
+   return FeatureSplittingPoints
+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)
+   end
+   return Proc
+end
+
+-------------------------------------------------------------------------------------------------------------
+function FeatureLib.GetFeatureVolume( Proc, Part)
+   local dProcVolume = 0
+
+   local nAddGrpId = BeamLib.GetAddGroup( Proc.idPart)
+   if not nAddGrpId then
+      -- TODO gestire meglio questo errore. Non conviene creare e verificare all'inizio se il gruppo esiste?
+      EgtOutLog( 'Error : missing AddGroup')
+      return 0
+   end
+
+   local idProcCopy = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
+   local b3PartCopy = BBox3d( Part.b3Part)
+   b3PartCopy:expand( -100 * GEO.EPS_SMALL)
+   local idPartCopy = EgtSurfTmBBox( nAddGrpId, b3PartCopy , false, GDB_RT.GLOB)
+
+   EgtSurfTmSubtract( idPartCopy, idProcCopy)
+   dProcVolume = EgtSurfVolume( idPartCopy)
+
+   EgtErase( { idProcCopy, idPartCopy})
+
+   return dProcVolume
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- TODO funzione copiata direttamente da automatismo vecchio, da migliorare / completare
+function FeatureLib.CalculateFeatureNotClampableLengths( Proc, Part)
+   local NotClampableLength = {}
+
+   -- verifico siano una o due facce
+   if Proc.nFct > 2 then return end
+
+   -- eventuale segnalazione ingombro di testa o coda
+   local dMinHIng = min( 0.5 * BeamData.VICE_MINH, 0.5 * Part.b3Raw:getDimZ())
+   local dMinZ = max( BeamData.MIN_HEIGHT, 0.35 * Part.b3Raw:getDimZ())
+   -- calcolo punto massimo in Z fino a dove considerare il pinzaggio. Minimo tra pinzaggio massimo e altezza pezzo 
+   local dMaxHZ = Part.b3Raw:getMin():getZ() + min( BeamData.VICE_MAXH or BeamData.MAX_HEIGHT, Part.b3Raw:getDimZ())
+   -- punto massimo in Z considerando anche la Z della feature
+   local dMaxHZFeat = min( dMaxHZ, Proc.b3Box:getMax():getZ())
+   -- dimensione Z del pinzaggio (differenza massima Z pinzabile e box feature)
+   local dDeltaZClamp = ( ( dMaxHZ - Part.b3Raw:getMin():getZ()) - max( 0, dMaxHZFeat - Proc.b3Box:getMin():getZ()))
+   -- se pinzaggio minimo è come il massimo (oppure come l'altezza massima del pezzo) significa che è verticale
+   local bIsVertClamps = BeamData.VICE_MINH > BeamData.MAX_HEIGHT - 100 * GEO.EPS_SMALL
+
+   -- condizioni per limitare pinzaggio testa/coda
+   local bUpdateIng = true
+   -- se dimensione del box della feature maggiore di metà pinzaggio minimo o metà spessore pezzo
+   bUpdateIng = bUpdateIng and Proc.b3Box:getDimZ() > dMinHIng
+   -- se la feature si trova più in basso del minimo pinzabile in Z o il 35% dello spessore pezzo
+   bUpdateIng = bUpdateIng and Proc.b3Box:getMin():getZ() < Part.b3Raw:getMin():getZ() + dMinZ
+   -- se feature è al di sotto del pinzaggio massimo
+   bUpdateIng = bUpdateIng and Proc.b3Box:getMin():getZ() < dMaxHZ
+   -- se ho le morse verticali, o se la feature è in centro o verso alto, controllo se non prendo abbastanza.
+   if bIsVertClamps or ( Proc.b3Box:getMin():getZ() - Part.b3Raw:getMin():getZ()) > BeamData.MIN_HEIGHT  then
+      bUpdateIng = bUpdateIng and dDeltaZClamp < BeamData.VICE_MINH
+   end
+
+   local dNotClampableLengthHead = 0
+   local dNotClampableLengthTail = 0
+
+   if bUpdateIng then
+      if Proc.AffectedFaces.bRight then
+         local dOffs = Part.b3Part:getMax():getX() - Proc.b3Box:getMin():getX()
+         -- se pinze a 45° e pinza abbastanza materiale, compenso comunque, ma solo inclinazione morse
+         if not bIsVertClamps and dDeltaZClamp > BeamData.VICE_MINH and BeamData.VICE_MAXH then
+            dOffs = min( dOffs, BeamData.VICE_MAXH - BeamData.VICE_MINH)
+         end
+         dNotClampableLengthHead = dOffs
+      elseif Proc.AffectedFaces.bLeft then
+         local dOffs = Proc.b3Box:getMax():getX() - Part.b3Part:getMin():getX()
+         -- se pinze a 45° e pinza abbastanza materiale, compenso comunque, ma solo inclinazione morse
+         if not bIsVertClamps and dDeltaZClamp > BeamData.VICE_MINH and BeamData.VICE_MAXH then
+            dOffs = min( dOffs, BeamData.VICE_MAXH - BeamData.VICE_MINH)
+         end
+         dNotClampableLengthTail = dOffs
+      elseif Proc.b3Box:getCenter():getX() > Part.b3Part:getCenter():getX() then
+         local dOffs = Part.b3Part:getMax():getX() - Proc.b3Box:getMin():getX()
+         local dDist = Part.b3Part:getMax():getX() - Proc.b3Box:getMax():getX()
+         -- se pinze a 45° e pinza abbastanza materiale, compenso comunque, ma solo inclinazione morse
+         if not bIsVertClamps and dDeltaZClamp > BeamData.VICE_MINH and BeamData.VICE_MAXH then
+            dOffs = min( dOffs, BeamData.VICE_MAXH - BeamData.VICE_MINH)
+         end
+         -- dDist serve??
+         dNotClampableLengthHead = dOffs
+      end
+   end
+
+   NotClampableLength.dNotClampableLengthHead = dNotClampableLengthHead
+   NotClampableLength.dNotClampableLengthTail = dNotClampableLengthTail
+
+   return NotClampableLength
+end
+
+-------------------------------------------------------------------------------------------------------------
+function FeatureLib.GetFeatureMaxNotClampableLengths( Proc, Part)
+   local nPartIndex = Part.nIndexInParts
+   local nProcIndex = Proc.nIndexInVProc
+   local Rotations = PROCESSINGS[nPartIndex].Rotation
+   
+   local dMaxOnHead = 0
+   local dMaxOnTail = 0
+   for i = 1, #Part.CombinationList do
+      for j = 1, 4 do
+         -- controllo che la rotazione sia attiva
+         if string.sub( Part.CombinationList[i].sBitIndexCombination, j, j) == '1' then
+            dMaxOnHead = max( Rotations[j][nProcIndex].NotClampableLength.dNotClampableLengthHead, dMaxOnHead)
+            dMaxOnTail = max( Rotations[j][nProcIndex].NotClampableLength.dNotClampableLengthTail, dMaxOnTail)
+         end
+      end
+   end
+
+   return dMaxOnHead, dMaxOnTail
+end
+
+-------------------------------------------------------------------------------------------------------------
+return FeatureLib

LuaLibs/Identity.lua

@@ -0,0 +1,275 @@
+-- Identity.lua by Egalware s.r.l. 2024/04/02
+-- Libreria Riconoscimento della feature
+-- 2024/04/02 PRIMA VERSIONE CALCOLO LAVORAZIONI CON STRATEGIE
+
+-- Tabella per definizione modulo
+local Identity = {}
+
+---------------------------------------------------------------------
+------------------------  EGALWARE FEATURES  ------------------------
+---------------------------------------------------------------------
+-- Feature : Head Cut
+function Identity.IsHeadCut( Proc)
+   return ( Proc.nGrp == 1  and  Proc.nPrc == 340)
+end
+---------------------------------------------------------------------
+-- Feature : Tail Cut
+function Identity.IsTailCut( Proc)
+   return ( Proc.nGrp == 2  and  Proc.nPrc == 350)
+end
+
+---------------------------------------------------------------------
+------------------------  STANDARD FEATURES  ------------------------
+---------------------------------------------------------------------
+-- Feature : Cut
+function Identity.IsCut( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 10)
+end
+---------------------------------------------------------------------
+-- Feature : Longitudinal Cut
+function Identity.IsLongitudinalCut( Proc)
+   return (( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 10)
+end
+---------------------------------------------------------------------
+-- Feature : Double Cut
+function Identity.IsDoubleCut( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 11)
+end
+---------------------------------------------------------------------
+-- Feature : Ridge or Valley Cut
+function Identity.IsDoubleLongitudinalCut( Proc)
+   return ( Proc.nGrp == 0  and  Proc.nPrc == 12)
+end
+---------------------------------------------------------------------
+-- Feature : Saw Cut
+function Identity.IsSawCut( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 13)
+end
+---------------------------------------------------------------------
+-- Feature : Slot
+function Identity.IsSlot( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 16)
+end
+---------------------------------------------------------------------
+-- Feature : Front Slot
+function Identity.IsFrontSlot( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 17)
+end
+---------------------------------------------------------------------
+-- Feature : Birds Mouth
+function Identity.IsBirdsMouth( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 20)
+end
+---------------------------------------------------------------------
+-- Feature : Hip or Valley Rafter Notch
+function Identity.IsHipValleyRafterNotch( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 25)
+end
+---------------------------------------------------------------------
+-- Feature : Ridge Lap
+function Identity.IsRidgeLap( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 30)
+end
+---------------------------------------------------------------------
+-- Feature : Lap Joint
+function Identity.IsLapJoint( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 30)
+end
+---------------------------------------------------------------------
+-- Feature : Notch/Rabbet
+function Identity.IsNotchRabbet( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 32)
+end
+---------------------------------------------------------------------
+-- Feature : Block Haus
+function Identity.IsBlockHaus( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 33)
+end
+---------------------------------------------------------------------
+-- Feature : Notch
+function Identity.IsNotch( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 34)
+end
+---------------------------------------------------------------------
+-- Feature : French Ridge Lap
+function Identity.IsFrenchRidgeLap( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 35)
+end
+---------------------------------------------------------------------
+-- Feature : Chamfer
+function Identity.IsChamfer( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 36)
+end
+---------------------------------------------------------------------
+-- Feature : Block Haus Half Lap
+function Identity.IsHalfBlockHaus( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 37)
+end
+---------------------------------------------------------------------
+-- Feature : Block Haus Front
+function Identity.IsFrontBlockHaus( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 38)
+end
+---------------------------------------------------------------------
+-- Feature : Pocket
+function Identity.IsPocket( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 39)
+end
+---------------------------------------------------------------------
+-- Feature : Drilling
+function Identity.IsDrilling( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 40)
+end
+---------------------------------------------------------------------
+-- Feature : Tenon
+function Identity.IsTenon( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 50)
+end
+---------------------------------------------------------------------
+-- Feature : Mortise
+function Identity.IsMortise( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 50)
+end
+---------------------------------------------------------------------
+-- Feature : Front Mortise
+function Identity.IsFrontMortise( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 51)
+end
+---------------------------------------------------------------------
+-- Feature : House
+function Identity.IsHouse( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 52)
+end
+---------------------------------------------------------------------
+-- Feature : House Mortise
+function Identity.IsHouseMortise( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 53)
+end
+---------------------------------------------------------------------
+-- Feature : Dovetail Tenon
+function Identity.IsDovetailTenon( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 55)
+end
+---------------------------------------------------------------------
+-- Feature : Dovetail Mortise
+function Identity.IsDovetailMortise( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 55)
+end
+---------------------------------------------------------------------
+-- Feature : Dovetail Mortise Front
+function Identity.IsFrontDovetailMortise( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 56)
+end
+---------------------------------------------------------------------
+-- Feature : Marking
+function Identity.IsMarking( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 60)
+end
+---------------------------------------------------------------------
+-- Feature : Text
+function Identity.IsText( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 61)
+end
+---------------------------------------------------------------------
+-- Feature : Scarf Simple
+function Identity.IsScarfSimple( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 70)
+end
+---------------------------------------------------------------------
+-- Feature : Scarf Joint
+function Identity.IsScarfJoint( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 71)
+end
+---------------------------------------------------------------------
+-- Feature : Step Joint
+function Identity.IsStepJoint( Proc)
+   return ( ( Proc.nGrp == 1 or Proc.nGrp == 2)  and  Proc.nPrc == 80)
+end
+---------------------------------------------------------------------
+-- Feature : Step Joint Notch
+function Identity.IsStepJointNotch( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 80)
+end
+---------------------------------------------------------------------
+-- Feature : Planing
+function Identity.IsPlaning( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 90)
+end
+---------------------------------------------------------------------
+-- Feature : Front Profile
+function Identity.IsFrontProfile( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 100)
+end
+---------------------------------------------------------------------
+-- Feature : Head Concave Profile
+function Identity.IsHeadConcaveProfile( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 101)
+end
+---------------------------------------------------------------------
+-- Feature : Head Convex Profile
+function Identity.IsHeadConvexProfile( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 102)
+end
+---------------------------------------------------------------------
+-- Feature : Head Cambered Profile
+function Identity.IsHeadCamberedProfile( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 103)
+end
+---------------------------------------------------------------------
+-- Feature : Round Arch
+function Identity.IsRoundArch( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 104)
+end
+---------------------------------------------------------------------
+-- Feature : Head Profile
+function Identity.IsHeadProfile( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 106)
+end
+---------------------------------------------------------------------
+-- Feature : Sphere
+function Identity.IsSphere( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 107)
+end
+---------------------------------------------------------------------
+-- Feature : Triangle Cut
+function Identity.IsTriangleCut( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 120)
+end
+---------------------------------------------------------------------
+-- Feature : TyroleanDovetail
+function Identity.IsTyroleanDovetail( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 1 or Proc.nGrp == 2 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 136)
+end
+---------------------------------------------------------------------
+-- Feature : Dovetail
+function Identity.IsDovetail( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 1 or Proc.nGrp == 2 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 138)
+end
+---------------------------------------------------------------------
+-- Feature : Free Contour
+function Identity.IsFreeContour( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 250)
+end
+---------------------------------------------------------------------
+-- Feature : Outline
+function Identity.IsOutline( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 251)
+end
+---------------------------------------------------------------------
+-- Feature : Aperture
+function Identity.IsAperture( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 252)
+end
+---------------------------------------------------------------------
+-- Feature : Variant
+function Identity.IsVariant( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 1 or Proc.nGrp == 2 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 900)
+end
+---------------------------------------------------------------------
+-- Feature Decor
+function Identity.IsDecor( Proc)
+   return ( ( Proc.nGrp == 0 or Proc.nGrp == 3 or Proc.nGrp == 4)  and  Proc.nPrc == 959)
+end
+---------------------------------------------------------------------
+
+return Identity

LuaLibs/Logs.lua

@@ -0,0 +1,213 @@
+-- Logs.lua by Egalware s.r.l. 2024/11/20
+-- Libreria per logs vari
+
+-- Tabella per definizione modulo
+local Logs = {}
+
+-------------------------------------------------------------------------------------------------------------
+function Logs.WriteFeaturesLog( ProcessingsOnPart, PartInfo)
+   EgtOutLog( ' === === === === === === === === === === FEATURES STRATEGIES === === === === === === === === === === === ===')
+   EgtOutLog( '  Feature ID         |    BTL POSITION    |    90 ROTATION     |    180 ROTATION    |    270 ROTATION    |')
+   EgtOutLog( '----------------------------------------------------------------------------------------------------------')
+
+   local nProcessingsNumber
+   local nFirstAvailableRotation
+   -- ricerco prima rotazione effettivamente calcolata. In genere è sempre la prima
+   for i = 1, 4 do
+      if PartInfo.CombinationList.Rotations[i] == 1 then
+         nProcessingsNumber = #ProcessingsOnPart.Rotation[i]
+         nFirstAvailableRotation = i
+         break
+      end
+   end
+
+   -- per ogni feature
+   for ProcLog = 1, nProcessingsNumber do
+      -- ricavo il massimo numero di strategie per feature
+      local nMaxStrategiesPerFeature = 0
+      for nRotLog = 1, 4 do
+         if PartInfo.CombinationList.Rotations[nRotLog] == 1 and ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies then
+            nMaxStrategiesPerFeature = max( nMaxStrategiesPerFeature, #ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies)
+         end
+      end
+
+      -- ciclo su tutte le strategie
+      for nCountStrategies = 1, nMaxStrategiesPerFeature do
+         local sLogLine = ''
+         -- al primo ciclo scrivo ID feature
+         if nCountStrategies == 1 then
+            sLogLine = '  ' ..  tostring( ProcessingsOnPart.Rotation[nFirstAvailableRotation][ProcLog].id)
+            while string.len( sLogLine) <= 20 do
+               sLogLine = sLogLine .. ' '
+            end
+            sLogLine = sLogLine .. '|'
+         else
+            sLogLine = '                     |'
+         end
+
+         for nRotLog = 1, 4 do
+            -- se rotazione abilitata
+            if PartInfo.CombinationList.Rotations[nRotLog] == 1 then
+               -- se ci sono strategie
+               if ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies and ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies] then
+                  -- se la strategia è stat processata e ha un risultato
+                  if ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].Result then
+                     -- leggo lo stato della strategia per aggiungere un suffisso
+                     local sStatusStrategy = ' '
+                     if not ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].Result.sStatus or
+                        ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].Result.sStatus == 'Not-Applicable' then
+                        sStatusStrategy = 'N'
+                     elseif ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].Result.sStatus == 'Completed' then
+                        sStatusStrategy = 'C'
+                     elseif ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].Result.sStatus == 'Not-Completed' then
+                        sStatusStrategy = 'P'
+                     end
+                     -- se c'è una chosen strategy, si aggiunge prefisso '*' per indicare nel log qual è la strategia che è stata scelta 
+                     local nIndexBestStrategy = ProcessingsOnPart.Rotation[nRotLog][ProcLog].nIndexBestStrategy or 0
+                     local sLogLineProc = EgtIf( nIndexBestStrategy == nCountStrategies, '*', '') ..
+                                          tostring( ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].Result.dCompositeRating) ..' (' .. 
+                                          tostring( ProcessingsOnPart.Rotation[nRotLog][ProcLog].AvailableStrategies[nCountStrategies].sStrategyId) .. ')' .. 
+                                          sStatusStrategy .. '  |'
+                     while string.len( sLogLineProc) <= 20 do
+                        sLogLineProc = ' ' .. sLogLineProc
+                     end
+                     sLogLine = sLogLine .. sLogLineProc
+                  else
+                     sLogLine = sLogLine .. '      0 (STR----)-  |'
+                  end
+               else
+                  sLogLine = sLogLine .. '                    |'
+               end
+            -- rotazione non presa in considerazione
+            else
+               if nCountStrategies == 1 then
+                  sLogLine = sLogLine .. '        ----------  |'
+               else
+                  sLogLine = sLogLine .. '                    |'
+               end
+            end
+         end
+         EgtOutLog( sLogLine)
+      end
+
+   end
+   EgtOutLog( '----------------------------------------------------------------------------------------------------------')
+end
+
+-------------------------------------------------------------------------------------------------------------
+function Logs.WriteMatrixLog( ProcessingsOnPart, PartInfo)
+   EgtOutLog( ' === === === === === === === === === === ROTATION MATRIX === === === === === === === === === === === === ===')
+   EgtOutLog( '  Feature ID         |    BTL POSITION    |    90 ROTATION     |    180 ROTATION    |    270 ROTATION    |')
+   EgtOutLog( '----------------------------------------------------------------------------------------------------------')
+
+   local nProcessingsNumber
+   local nFirstAvailableRotation
+   -- ricerco prima rotazione effettivamente calcolata. In genere è sempre la prima
+   for i = 1, 4 do
+      if PartInfo.CombinationList.Rotations[i] == 1 then
+         nProcessingsNumber = #ProcessingsOnPart.Rotation[i]
+         nFirstAvailableRotation = i
+         break
+      end
+   end
+
+   for ProcLog = 1, nProcessingsNumber do
+      local sLogLine = '  ' ..  tostring( ProcessingsOnPart.Rotation[nFirstAvailableRotation][ProcLog].id)
+      while string.len( sLogLine) <= 20 do
+         sLogLine = sLogLine .. ' '
+      end
+      sLogLine = sLogLine .. '|'
+      for nRotLog = 1, 4 do
+         if PartInfo.CombinationList.Rotations[nRotLog] == 1 then
+            if ProcessingsOnPart.Rotation[nRotLog][ProcLog].ChosenStrategy then
+               local sStatusStrategy = EgtIf( ProcessingsOnPart.Rotation[nRotLog][ProcLog].ChosenStrategy.Result.sStatus == 'Completed', 'C', 'P')
+               local sLogLineProc = tostring( ProcessingsOnPart.Rotation[nRotLog][ProcLog].ChosenStrategy.Result.dCompositeRating) ..
+                                    ' (' .. tostring( ProcessingsOnPart.Rotation[nRotLog][ProcLog].ChosenStrategy.sStrategyId) .. ')' .. sStatusStrategy .. '  |'
+               while string.len( sLogLineProc) <= 20 do
+                  sLogLineProc = ' ' .. sLogLineProc
+               end
+               sLogLine = sLogLine .. sLogLineProc
+            else
+               sLogLine = sLogLine .. '      0 (STR----)-  |'
+            end
+         else
+            sLogLine = sLogLine .. '        ----------  |'
+         end
+      end
+      EgtOutLog( sLogLine)
+   end
+   EgtOutLog( '----------------------------------------------------------------------------------------------------------')
+end
+
+-------------------------------------------------------------------------------------------------------------
+function Logs.WriteCombinationLog( CombinationsList, BestCombination)
+   EgtOutLog( ' === === === === === === === === === === COMBINATIONS === === === === === === ')
+   EgtOutLog( '  COMBI (UNL) |   RATING  |  COMPLETE |  NO COMPL |   NO EXEC |    ROTATE |')
+   EgtOutLog( '---------------------------------------------------------------------------')
+
+   for CombiLog = 1, #CombinationsList do
+      local sLogLine = ' ' .. CombinationsList[CombiLog].sBitIndexCombination .. ' (' .. CombinationsList[CombiLog].nUnloadPos .. ')     |'
+      -- rating
+      local sOtherField = tostring( CombinationsList[CombiLog].dTotalRating) .. '  |'
+      while string.len( sOtherField) <= 11 do
+         sOtherField = ' ' .. sOtherField
+      end
+      sLogLine = sLogLine .. sOtherField
+      -- completed
+      sOtherField = tostring( CombinationsList[CombiLog].nComplete) .. '  |'
+      while string.len( sOtherField) <= 11 do
+         sOtherField = ' ' .. sOtherField
+      end
+      sLogLine = sLogLine .. sOtherField
+      -- not completed
+      sOtherField = tostring( CombinationsList[CombiLog].nNotComplete) .. '  |'
+      while string.len( sOtherField) <= 11 do
+         sOtherField = ' ' .. sOtherField
+      end
+      sLogLine = sLogLine .. sOtherField
+      -- not executed
+      sOtherField = tostring( CombinationsList[CombiLog].nNotExecute) .. '  |'
+      while string.len( sOtherField) <= 11 do
+         sOtherField = ' ' .. sOtherField
+      end
+      sLogLine = sLogLine .. sOtherField
+      -- rotations
+      sOtherField = tostring( CombinationsList[CombiLog].nRotations) .. '  |'
+      while string.len( sOtherField) <= 11 do
+         sOtherField = ' ' .. sOtherField
+      end
+      sLogLine = sLogLine .. sOtherField
+      
+      EgtOutLog( sLogLine)
+   end
+   EgtOutLog( '---------------------------------------------------------------------------')
+   EgtOutLog( ' BEST ROTATION : ' .. BestCombination.sBitIndexCombination .. ' (' .. BestCombination.nUnloadPos .. ')')
+   EgtOutLog( '---------------------------')
+end
+
+-------------------------------------------------------------------------------------------------------------
+function Logs.WriteMainFacesLog( Proc, MainFaces)
+   if MainFaces.BottomFaces then
+      for i = 1, #MainFaces.BottomFaces do
+         EgtOutLog( 'Bottom Face : ' .. MainFaces.BottomFaces[i].id)
+      end
+      -- colore differente per la faccia di fondo principale
+      EgtSurfTmSetFaceColor( Proc.id, MainFaces.BottomFaces[1].id, 1)
+   end
+   if MainFaces.LongFaces then
+      for i = 1, #MainFaces.LongFaces do
+         EgtOutLog( 'Long Face : ' .. MainFaces.LongFaces[i].id)
+      end
+   end
+   if MainFaces.SideFaces then
+      for i = 1, #MainFaces.SideFaces do
+         EgtOutLog( 'Side Face : ' .. MainFaces.SideFaces[i].id)
+      end
+   end
+   if MainFaces.TunnelAddedFaces then
+      EgtOutLog( 'Middle Face (Trimesh): ' .. MainFaces.TunnelAddedFaces.MiddleFaceTm.id)
+   end
+end
+---------------------------------------------------------------------
+
+return Logs

LuaLibs/MachiningLib.lua

@@ -0,0 +1,950 @@
+-- MachiningLib.lua by Egalware s.r.l. 2024/04/02
+-- Libreria ricerca lavorazioni per Travi
+-- 2024/04/02 PRIMA VERSIONE CALCOLO LAVORAZIONI CON STRATEGIE
+
+-- Tabella per definizione modulo
+local MachiningLib = {}
+
+-- Include
+require( 'EgtBase')
+
+-- Carico i dati globali
+local BeamData = require( 'BeamData')
+local BeamLib = require( 'BeamLib')
+local FeatureLib = require( 'FeatureLib')
+
+EgtOutLog( ' MachiningLib started', 1)
+
+---------------------------------------------------------------------
+-- TODO da considerare solo angolo 2D??
+local function GetToolEntryAngle( Proc, vtTool)
+   local Angle = {}
+
+   local dSinAngle = -10 * GEO.EPS_SMALL
+   local vtNorm
+   if Proc.AffectedFaces.bTop then
+      vtNorm = Z_AX()
+      dSinAngle = max( dSinAngle, vtTool * vtNorm)
+   end
+   if Proc.AffectedFaces.bBottom then
+      vtNorm = -Z_AX()
+      dSinAngle = max( dSinAngle, vtTool * vtNorm)
+   end
+   if Proc.AffectedFaces.bFront then
+      vtNorm = -Y_AX()
+      dSinAngle = max( dSinAngle, vtTool * vtNorm)
+   end
+   if Proc.AffectedFaces.bBack then
+      vtNorm = Y_AX()
+      dSinAngle = max( dSinAngle, vtTool * vtNorm)
+   end
+   if Proc.AffectedFaces.bLeft then
+      vtNorm = -X_AX()
+      dSinAngle = max( dSinAngle, vtTool * vtNorm)
+   end
+   if Proc.AffectedFaces.bRight then
+      vtNorm = X_AX()
+      dSinAngle = max( dSinAngle, vtTool * vtNorm)
+   end
+
+   local dCosAngle = sqrt( 1 - sqr( dSinAngle))
+   local dAngle = acos( dCosAngle)
+   local dTanAngle
+   if dAngle ~= 0 and dAngle ~= 90 then
+      dTanAngle = sqrt( 1 - dCosAngle * dCosAngle) / dCosAngle
+   end
+
+   Angle.dValue = dAngle
+   Angle.dSin = dSinAngle
+   Angle.dCos = dCosAngle
+   Angle.dTan = dTanAngle
+
+   return Angle
+end
+
+-------------------------------------------------------------------------------------------------------------
+function MachiningLib.StartsLeftSide( Machining)
+   local bStartsLeftSide = ( Machining.vtEdgeDirection:getX() > 10 * GEO.EPS_SMALL and not Machining.bInvert)
+                             or ( not( Machining.vtEdgeDirection:getX() > 10 * GEO.EPS_SMALL) and Machining.bInvert)
+
+   return bStartsLeftSide
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- TODO valutare se c'è un modo più preciso di prevedere i casi in cui le lavorazioni dopo separazione sono da saltare
+function MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part)
+   local bCanMoveAfterSplitcut = ( Part.dLength > BeamData.dMinRaw + 10 * GEO.EPS_SMALL)
+                                 and ( dLengthOnX < 0.7 * Part.dLength - 10 * GEO.EPS_SMALL)
+
+   return bCanMoveAfterSplitcut
+end
+
+-------------------------------------------------------------------------------------------------------------
+function MachiningLib.CanExtendAfterTail( sCanDamageNextPiece, Part)
+   local bCanExtendAfterTail = false
+
+   if sCanDamageNextPiece == 'ALWAYS' then
+      bCanExtendAfterTail = true
+   elseif sCanDamageNextPiece == 'ONLY_IF_RAWPART' then
+      bCanExtendAfterTail = Part.bIsLastPart
+   end
+
+   return bCanExtendAfterTail
+end
+
+-------------------------------------------------------------------------------------------------------------
+function MachiningLib.GetMachiningSteps( dMachiningDepth, dStep)
+   local MachiningSteps = {}
+   MachiningSteps.dStep = 0
+   MachiningSteps.nCount = ceil( ( dMachiningDepth - 10 * GEO.EPS_SMALL) / dStep)
+   if MachiningSteps.nCount > 1 then
+      MachiningSteps.dStep = ( dMachiningDepth - dStep) / ( MachiningSteps.nCount - 1)
+   else
+      MachiningSteps.nCount = 1
+   end
+
+   return MachiningSteps
+end
+
+-------------------------------------------------------------------------------------------------------------
+function MachiningLib.GetSplitMachinings( Machinings, SplittingPoints, Part )
+   for i = #Machinings, 1, -1 do
+      local nParts = #SplittingPoints + 1
+      local dEdgeMaxX = Machinings[i].ptEdge1:getX()
+      local dEdgeMinX = Machinings[i].ptEdge2:getX()
+      if Machinings[i].ptEdge1:getX() < Machinings[i].ptEdge2:getX() - 10 * GEO.EPS_SMALL then
+         dEdgeMaxX = Machinings[i].ptEdge2:getX()
+         dEdgeMinX = Machinings[i].ptEdge1:getX()
+      end
+      local dOriginalStartAddLength = Machinings[i].LeadIn.dStartAddLength
+      local dOriginalEndAddLength = Machinings[i].LeadOut.dEndAddLength
+      local sOriginalStage = Machinings[i].sStage
+      if FeatureLib.IsMachiningLong( Machinings[i].dLengthOnX, Part) then
+         local nCurrentMachiningIndex = i
+         -- lo spezzone attivo è quello precedente al punto di spezzatura corrente
+         for j = 1, nParts do
+            -- check ultimo segmento della lavorazione (NON della feature)
+            local bIsLastSegment = ( nParts == 1)
+                                   or ( ( ( j ~= 1) and SplittingPoints[j - 1]:getX() > dEdgeMinX + 10 * GEO.EPS_SMALL)
+                                   and ( j == nParts or SplittingPoints[j]:getX() < dEdgeMinX + 10 * GEO.EPS_SMALL))
+            -- se non è l'ultimo segmento della lavorazione, il punto di spezzatura deve essere all'interno del lato che si sta lavorando
+            if ( j ~= nParts and ( SplittingPoints[j]:getX() > dEdgeMinX + 10 * GEO.EPS_SMALL and SplittingPoints[j]:getX() < dEdgeMaxX - 10 * GEO.EPS_SMALL))
+               or bIsLastSegment then
+               if j > 1 then
+                  nCurrentMachiningIndex = nCurrentMachiningIndex + 1
+                  table.insert( Machinings, nCurrentMachiningIndex, BeamLib.TableCopyDeep( Machinings[i]))
+               end
+               local dStartAddLength = dOriginalStartAddLength
+               local dEndAddLength = dOriginalEndAddLength
+               if MachiningLib.StartsLeftSide( Machinings[i]) then
+                  dStartAddLength, dEndAddLength = dEndAddLength, dStartAddLength
+               end
+               if j == 1 then
+                  dEndAddLength = - ( SplittingPoints[j]:getX() - dEdgeMinX) + BeamData.MILL_OVERLAP
+                  Machinings[nCurrentMachiningIndex].ptCenter = Point3d( SplittingPoints[j]:getX() + ( dEdgeMaxX - SplittingPoints[j]:getX()) / 2, 0, 0)
+               elseif j == nParts then
+                  dStartAddLength = - ( dEdgeMaxX - SplittingPoints[j - 1]:getX()) + BeamData.MILL_OVERLAP
+                  Machinings[nCurrentMachiningIndex].ptCenter = Point3d( dEdgeMinX + ( SplittingPoints[j - 1]:getX() - dEdgeMinX) / 2, 0, 0)
+               else
+                  dStartAddLength = - ( dEdgeMaxX - SplittingPoints[j - 1]:getX()) + BeamData.MILL_OVERLAP
+                  dEndAddLength = - ( SplittingPoints[j]:getX() - dEdgeMinX) + BeamData.MILL_OVERLAP
+                  Machinings[nCurrentMachiningIndex].ptCenter = Point3d( SplittingPoints[j]:getX() + ( SplittingPoints[j - 1]:getX() - SplittingPoints[j]:getX()) / 2, 0, 0)
+               end
+               if MachiningLib.StartsLeftSide( Machinings[nCurrentMachiningIndex]) then
+                  dStartAddLength, dEndAddLength = dEndAddLength, dStartAddLength
+               end
+
+               Machinings[nCurrentMachiningIndex].LeadIn.dStartAddLength = dStartAddLength
+               Machinings[nCurrentMachiningIndex].LeadOut.dEndAddLength = dEndAddLength
+            end
+            if not bIsLastSegment then
+               Machinings[nCurrentMachiningIndex].sStage = ''
+            else
+               Machinings[nCurrentMachiningIndex].sStage = sOriginalStage
+            end
+            Machinings[nCurrentMachiningIndex].nFeatureSegment = j
+         end
+      -- anche le lavorazioni non splittate necessitano del segmento assegnato
+      else
+         local dRightAddLength = 0
+         local dLeftAddLength = 0
+         -- si considerano allungamenti e accorciamenti solo se la feature è orientata principalmente lungo X
+         -- TODO il modo corretto è proiettare tutto, allungamenti e accorciamenti compresi, sulla faccia frontale
+         if abs( Machinings[i].vtToolDirection:getX()) < 0.707 then
+            dRightAddLength = dOriginalStartAddLength
+            dLeftAddLength = dOriginalEndAddLength
+            if MachiningLib.StartsLeftSide( Machinings[i]) then
+               dRightAddLength, dLeftAddLength = dLeftAddLength, dRightAddLength
+            end
+         end
+         for j = 1, nParts do
+            local dNextSplitX = dEdgeMinX
+            local dPreviousSplitX = dEdgeMaxX
+            if j ~= 1 then
+               dPreviousSplitX = SplittingPoints[j - 1]:getX()
+            end
+            if j ~= nParts then
+               dNextSplitX = SplittingPoints[j]:getX()
+            end
+            if ( dEdgeMinX - dLeftAddLength) > dNextSplitX - 10 * GEO.EPS_SMALL and ( dEdgeMinX - dLeftAddLength) < dPreviousSplitX + 10 * GEO.EPS_SMALL then
+               Machinings[i].nFeatureSegment = j
+               Machinings[i].ptCenter = Point3d( dNextSplitX + ( dPreviousSplitX - dNextSplitX) / 2, 0, 0)
+            end
+         end
+      end
+   end
+
+   return Machinings
+end
+
+ -------------------------------------------------------------------------------------------------------------
+-- funzione per cercare utensile tipo FRESA con certe caratteristiche
+function MachiningLib.FindMill( Proc, ToolSearchParameters)
+   local ToolInfo = {}
+
+   local nBestToolIndex
+   local dBestToolResidualDepth = 0
+   for i = 1, #TOOLS do
+      -- prima verifico che utensile sia compatibile
+      local bIsToolCompatible = true
+      -- se viene passato il nome, tutti gli altri sono incompatibili
+      if ToolSearchParameters.sName and ToolSearchParameters.sName ~= TOOLS[i].sName then
+         bIsToolCompatible = false
+      -- si cercano solo frese standard. Se utensile disegnato manualmente, si setta subito che è incompatibile
+      elseif TOOLS[i].bIsProfiledTool then
+         bIsToolCompatible = false
+      -- controlli standard
+      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
+      elseif TOOLS[i].SetupInfo.bIsBottomHead  and  ToolSearchParameters.vtToolDirection:getZ() > TOOLS[i].SetupInfo.dMaxPositiveAngle then
+         bIsToolCompatible = false
+      elseif ToolSearchParameters.sMillShape == 'STANDARD' and  ( TOOLS[i].dSideAngle ~= 0 or TOOLS[i].bIsPen) then
+         bIsToolCompatible = false
+      elseif ToolSearchParameters.sMillShape == 'DOVETAIL' and  not TOOLS[i].bIsDoveTail then
+         bIsToolCompatible = false
+      elseif ToolSearchParameters.sMillShape == 'TSHAPEMILL' and  not TOOLS[i].bIsTMill then
+         bIsToolCompatible = false
+      elseif ToolSearchParameters.sMillShape == 'PEN' and  not TOOLS[i].bIsPen then
+         bIsToolCompatible = false
+      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
+         else
+            bIsToolCompatible = false
+         end
+      end
+
+      -- scelgo il migliore
+      if bIsToolCompatible then
+         -- calcolo riduzione del massimo materiale utilizzabile
+         local ToolEntryAngle = GetToolEntryAngle( Proc, ToolSearchParameters.vtToolDirection)
+         -- se ToolHolder più grande dell'utensile, il primo oggetto in collisione è il ToolHolder. Altrimenti il motore.
+         local dDimObjToCheck = EgtIf( TOOLS[i].ToolHolder.dDiameter > TOOLS[i].dDiameter, TOOLS[i].ToolHolder.dDiameter, BeamData.C_SIMM_ENC)
+         local dCurrentMaxMatReduction = BeamData.COLL_SIC or 5
+
+         -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
+         -- TODO considerare anche il caso in cui lo stelo sia più grande del diametro utensile
+         -- TODO nei confronti tra valori gestire tolleranze
+         -- calcolo riduzione per non toccare con ToolHolder / Motore
+         if ToolEntryAngle.dValue > 0 and ToolEntryAngle.dValue < 90  then
+            dCurrentMaxMatReduction = dCurrentMaxMatReduction / ToolEntryAngle.dSin + ( ( dDimObjToCheck - TOOLS[i].dDiameter) / 2) / ToolEntryAngle.dTan
+         end
+         -- 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
+         if not nBestToolIndex or ( dBestToolResidualDepth > 0 and dCurrentResidualDepth <= 0) then
+            nBestToolIndex = i
+            dBestToolResidualDepth = dCurrentResidualDepth
+         -- altrimenti scelgo il migliore
+         else
+            -- se entrambi completi
+            if dBestToolResidualDepth <= 0 and dCurrentResidualDepth <= 0 then
+               -- se il migliore era su aggregato e corrente montanto direttamente, prediligo utensile montato direttamente
+               if not TOOLS[i].SetupInfo.bToolOnAggregate and TOOLS[i].SetupInfo.bToolOnAggregate then
+                  nBestToolIndex = i
+                  dBestToolResidualDepth = dCurrentResidualDepth
+               -- se hanno stesso montaggio
+               elseif TOOLS[i].SetupInfo.bToolOnAggregate == TOOLS[nBestToolIndex].SetupInfo.bToolOnAggregate then
+                  -- scelgo utensile con indice di bontà utensile calcolato come:  lunghezza / massimo materiale / diametro
+                  if TOOLS[i].dPerformanceIndex > TOOLS[nBestToolIndex].dPerformanceIndex then
+                     nBestToolIndex = i
+                     dBestToolResidualDepth = dCurrentResidualDepth
+                  end
+               end
+            -- se entrambi incompleti
+            elseif dBestToolResidualDepth > 0 and dCurrentResidualDepth > 0 then
+               --scelgo quello che lavora di più
+               if dCurrentResidualDepth < dBestToolResidualDepth then
+                  nBestToolIndex = i
+                  dBestToolResidualDepth = dCurrentResidualDepth
+               end
+            end
+         end
+      end
+   end
+
+   ToolInfo.nToolIndex = nBestToolIndex
+   ToolInfo.dResidualDepth = dBestToolResidualDepth
+
+   return ToolInfo
+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 = {}
+
+   -- parametri obbligatori
+   if type( ToolSearchParameters.vtToolDirection) ~= 'table' then
+      error( 'FindBlade : missing tool direction')
+   end
+   if type( ToolSearchParameters.bAllowTopHead) ~= 'boolean' then
+      error( 'FindBlade : missing top head info')
+   end
+   if type( ToolSearchParameters.bAllowBottomHead) ~= 'boolean' then
+      error( 'FindBlade : missing bottom head info')
+   end
+   if not ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
+      error( 'FindBlade : wrong head info')
+   end
+
+   -- parametri opzionali
+   ToolSearchParameters.dElevation = ToolSearchParameters.dElevation or 0
+   ToolSearchParameters.bForceLongcutBlade = ToolSearchParameters.bForceLongcutBlade or false
+
+   local nBestToolIndex
+   for i = 1, #TOOLS do
+      local bIsToolCompatible = false
+
+      if TOOLS[i].sFamily == 'SAWBLADE' then
+         if ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
+            bIsToolCompatible = TOOLS[i].SetupInfo.bIsTopHead
+         elseif ToolSearchParameters.bAllowBottomHead and not ToolSearchParameters.bAllowTopHead then
+            bIsToolCompatible = TOOLS[i].SetupInfo.bIsBottomHead
+         else
+            bIsToolCompatible = true
+         end
+      end
+
+      if bIsToolCompatible then
+         if not nBestToolIndex then
+            nBestToolIndex = i
+         else
+            -- prediligo utensile per tagli lunghi, se richiesto
+            if ToolSearchParameters.bForceLongcutBlade and not TOOLS[nBestToolIndex].bIsUsedForLongCut and TOOLS[i].bIsUsedForLongCut then
+               nBestToolIndex = i
+            end
+         end
+      end
+   end
+
+   ToolInfo.nToolIndex = nBestToolIndex
+
+   return ToolInfo
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- funzione per cercare utensile tipo PUNTA A FORARE con certe caratteristiche
+-- TODO da fare
+function MachiningLib.FindDrill()
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- funzione per cercare utensile tipo SEGA A CATENA con certe caratteristiche
+-- TODO da completare
+function MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
+   local ToolInfo = {}
+
+   -- parametri obbligatori
+   if type( ToolSearchParameters.vtToolDirection) ~= 'table' then
+      error( 'FindChainSaw : missing tool direction')
+   end
+   if type( ToolSearchParameters.bAllowTopHead) ~= 'boolean' then
+      error( 'FindChainSaw : missing top head info')
+   end
+   if type( ToolSearchParameters.bAllowBottomHead) ~= 'boolean' then
+      error( 'FindChainSaw : missing bottom head info')
+   end
+   if not ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
+      error( 'FindChainSaw : wrong head info')
+   end
+
+   -- parametri opzionali
+   ToolSearchParameters.dElevation = ToolSearchParameters.dElevation or 0
+   ToolSearchParameters.bExtendWithCornerRadius = ToolSearchParameters.bExtendWithCornerRadius or false
+
+   local nBestToolIndex
+   local dBestToolResidualDepth = 0
+   for i = 1, #TOOLS do
+      local bIsToolCompatible = false
+
+      if TOOLS[i].sFamily == 'MORTISE' then
+         if ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
+            bIsToolCompatible = TOOLS[i].SetupInfo.bIsTopHead
+         elseif ToolSearchParameters.bAllowBottomHead and not ToolSearchParameters.bAllowTopHead then
+            bIsToolCompatible = TOOLS[i].SetupInfo.bIsBottomHead
+         else
+            bIsToolCompatible = true
+         end
+      end
+
+      -- TODO nei confronti tra valori gestire tolleranze
+      if bIsToolCompatible then
+         if ToolSearchParameters.dElevation > 10 * GEO.EPS_SMALL and ToolSearchParameters.bExtendWithCornerRadius then
+            ToolSearchParameters.dElevation = ToolSearchParameters.dElevation + TOOLS[i].dCornerRadius
+         end
+         -- TODO gestire accorciamento massimo materiale per inclinazione
+         local dCurrentResidualDepth = ToolSearchParameters.dElevation - TOOLS[i].dMaxDepth
+         -- se non ancora trovato, oppure se completo e il migliore fino ad ora non è completo: corrente è il migliore
+         if not nBestToolIndex or ( dBestToolResidualDepth > 0 and dCurrentResidualDepth <= 0) then
+            nBestToolIndex = i
+            dBestToolResidualDepth = dCurrentResidualDepth
+         -- altrimenti scelgo il migliore
+         else
+            -- se entrambi completi
+            if dBestToolResidualDepth <= 0 and dCurrentResidualDepth <= 0 then
+               -- scelgo utensile con rapporto lunghezza / diametro minore
+               if TOOLS[i].dPerformanceIndex > TOOLS[nBestToolIndex].dPerformanceIndex then
+                  nBestToolIndex = i
+                  dBestToolResidualDepth = dCurrentResidualDepth
+               end
+            -- se entrambi incompleti
+            elseif dBestToolResidualDepth > 0 and dCurrentResidualDepth > 0 then
+               --scelgo quello che lavora di più
+               if dCurrentResidualDepth > dBestToolResidualDepth then
+                  nBestToolIndex = i
+                  dBestToolResidualDepth = dCurrentResidualDepth
+               end
+            end
+         end
+      end
+   end
+
+   ToolInfo.nToolIndex = nBestToolIndex
+   ToolInfo.dResidualDepth = dBestToolResidualDepth
+
+   return ToolInfo
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- salva in lista globale la lavorazione appena calcolata
+function MachiningLib.AddNewMachining( ProcToAdd, MachiningToAdd, AuxiliaryDataToAdd)
+   -- Controllo parametri obbligatori
+   if not MachiningToAdd.nType or not MachiningToAdd.nToolIndex or not MachiningToAdd.Geometry or not ProcToAdd.id then
+      return false
+   end
+
+   -- se nome non definito, assegno alla lavorazioen un nome standard
+   if not MachiningToAdd.sOperationName then
+      -- Drilling
+      if MachiningToAdd.nType == MCH_MY.DRILLING then
+         MachiningToAdd.sTypeName = 'Drill_'
+      -- Milling
+      elseif MachiningToAdd.nType == MCH_MY.MILLING then
+         -- se utensile lama
+         if TOOLS[MachiningToAdd.nToolIndex].sFamily == 'SAWBLADE' then
+            MachiningToAdd.sTypeName = 'Cut_'
+         else
+            MachiningToAdd.sTypeName = 'Mill_'
+         end
+      -- Pocketing
+      elseif MachiningToAdd.nType == MCH_MY.POCKETING then
+         MachiningToAdd.sTypeName = 'Pocket_'
+      -- Mortising
+      elseif MachiningToAdd.nType == MCH_MY.MORTISING then
+         MachiningToAdd.sTypeName = 'ChSaw_'
+      end
+      MachiningToAdd.sOperationName = MachiningToAdd.sTypeName .. ( EgtGetName( ProcToAdd.id) or tostring( ProcToAdd.id)) --  .. '_' .. tostring( MachiningToAdd.Geometry)
+   end
+   if not MachiningToAdd.sToolName then
+      MachiningToAdd.sToolName = TOOLS[MachiningToAdd.nToolIndex].sName
+   end
+   local Machining = {}
+   Machining.Proc = ProcToAdd
+   Machining.Machining = MachiningToAdd
+   Machining.AuxiliaryData = AuxiliaryDataToAdd or {}
+   table.insert( MACHININGS, Machining)
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- funzione per aggiungere una nuova lavorazione
+function MachiningLib.AddOperations( vProc, Part, sRotation)
+   local nErr
+   local sErr = ''
+   local bAreAllMachiningApplyOk = true
+   local bSplitExecuted = false
+
+   -- parametri generali lavorazione
+   local MachiningParameters = {
+      { sName = 'sDepth',                    nMchParam = MCH_MP.DEPTH_STR},
+      { sName = 'bInvert',                   nMchParam = MCH_MP.INVERT},
+      { sName = 'nWorkside',                 nMchParam = MCH_MP.WORKSIDE},
+      { sName = 'nFaceuse',                  nMchParam = MCH_MP.FACEUSE},
+      { sName = 'nSCC',                      nMchParam = MCH_MP.SCC},
+      { sName = 'bToolInvert',               nMchParam = MCH_MP.TOOLINVERT},
+      { sName = 'sBlockedAxis',              nMchParam = MCH_MP.BLOCKEDAXIS},
+      { sName = 'sInitialAngles',            nMchParam = MCH_MP.INITANGS},
+      { sName = 'nHeadSide',                 nMchParam = MCH_MP.HEADSIDE},
+      { sName = 'nSubType',                  nMchParam = MCH_MP.SUBTYPE},
+      { sName = 'dOverlap',                  nMchParam = MCH_MP.OVERL},
+      { sName = 'nStepType',                 nMchParam = MCH_MP.STEPTYPE},
+      { sName = 'dStartSafetyLength',        nMchParam = MCH_MP.STARTPOS},
+      { sName = 'dReturnPos',                nMchParam = MCH_MP.RETURNPOS},
+      { sName = 'dRadialOffset',             nMchParam = MCH_MP.OFFSR},
+      { sName = 'dLongitudinalOffset',       nMchParam = MCH_MP.OFFSL},
+      { sName = 'dStartSlowLen',             nMchParam = MCH_MP.STARTSLOWLEN},
+      { sName = 'dEndSlowLen',               nMchParam = MCH_MP.ENDSLOWLEN},
+      { sName = 'dThrouAddLen',              nMchParam = MCH_MP.THROUADDLEN},
+      { sName = 'sSystemNotes',              nMchParam = MCH_MP.SYSNOTES},
+      { sName = 'sUserNotes',                nMchParam = MCH_MP.USERNOTES}
+   }
+
+   -- parametri relativi allo step
+   MachiningParameters.Steps = {
+      { sName = 'nStepType',                 nMchParam = MCH_MP.STEPTYPE},
+      { sName = 'dStep',                     nMchParam = MCH_MP.STEP},
+      { sName = 'dSideStep',                 nMchParam = MCH_MP.SIDESTEP}
+   }
+
+   -- parametri relativi all'approccio
+   MachiningParameters.LeadIn = {
+      { sName = 'nType',                     nMchParam = MCH_MP.LEADINTYPE},
+      { sName = 'dStartAddLength',           nMchParam = MCH_MP.STARTADDLEN},
+      { sName = 'dTangentDistance',          nMchParam = MCH_MP.LITANG},
+      { sName = 'dPerpDistance',             nMchParam = MCH_MP.LIPERP},
+      { sName = 'dElevation',                nMchParam = MCH_MP.LIELEV},
+      { sName = 'dCompLength',               nMchParam = MCH_MP.LICOMPLEN}
+   }
+
+   -- parametri relativi alla retrazione
+   MachiningParameters.LeadOut = {
+      { sName = 'nType',                     nMchParam = MCH_MP.LEADOUTTYPE},
+      { sName = 'dEndAddLength',             nMchParam = MCH_MP.ENDADDLEN},
+      { sName = 'dTangentDistance',          nMchParam = MCH_MP.LOTANG},
+      { sName = 'dPerpDistance',             nMchParam = MCH_MP.LOPERP},
+      { sName = 'dElevation',                nMchParam = MCH_MP.LOELEV},
+      { sName = 'dCompLength',               nMchParam = MCH_MP.LOCOMPLEN}
+   }
+
+   -- parametri da scrivere nelle note utente
+   local UserNotes = {
+      { sName = 'dMaxElev',                   sMchParam = 'MaxElev'},
+      { sName = 'dOpenMinSafe',               sMchParam = 'OpenMinSafe'},
+      { sName = 'nVMRS',                      sMchParam = 'VMRS'},
+      { sName = 'dStartZmax',                 sMchParam = 'StartZmax'},
+      { sName = 'nOutRaw',                    sMchParam = 'OutRaw'},
+      { sName = 'nOpenOutRaw',                sMchParam = 'OpenOutRaw'},
+      { sName = 'nPlunge',                    sMchParam = 'Plunge'}
+   }
+
+   -- parametri da scrivere nelle note di sistema
+   local SystemNotes = {
+   }
+
+   for i = 1, #MACHININGS do
+      -- si aggiungono solo quelle della fase richiesta
+      if ( sRotation == 'STD' and not MACHININGS[i].Proc.bDown and not MACHININGS[i].Proc.bSide) or
+         ( MACHININGS[i].Proc.bDown and sRotation == 'DOWN') or
+         ( MACHININGS[i].Proc.bSide and sRotation == 'SIDE') then
+         local nClonesToAdd = 1
+         if MACHININGS[i].AuxiliaryData.Clones then
+            nClonesToAdd = #MACHININGS[i].AuxiliaryData.Clones
+         end
+         for j = 1, nClonesToAdd do
+            -- creazione lavorazione
+            local nOperationId = EgtCreateMachining( MACHININGS[i].Machining.sOperationName, MACHININGS[i].Machining.nType, MACHININGS[i].Machining.sToolName)
+
+            if nOperationId then
+               -- impostazione geometria
+               local Geometry
+               if MACHININGS[i].AuxiliaryData.Clones and MACHININGS[i].AuxiliaryData.Clones[j].Geometry then
+                  Geometry = MACHININGS[i].AuxiliaryData.Clones[j].Geometry
+               elseif MACHININGS[i].Machining.Geometry then
+                  Geometry = MACHININGS[i].Machining.Geometry
+               end
+               EgtSetMachiningGeometry( Geometry)
+
+               -- impostazione parametri lavorazione
+               -- TODO scrivere sempre Steps, LeadIn, LeadOut nelle tabelle in modo da non dover controllare ogni volta che ci siano
+               for k = 1, #MachiningParameters do
+                  local sValue
+                  if MACHININGS[i].AuxiliaryData.Clones and MACHININGS[i].AuxiliaryData.Clones[j][MachiningParameters[k].sName] then
+                     sValue = MACHININGS[i].AuxiliaryData.Clones[j][MachiningParameters[k].sName]
+                  elseif MACHININGS[i].Machining[MachiningParameters[k].sName] then
+                     sValue = MACHININGS[i].Machining[MachiningParameters[k].sName]
+                  end
+                  if sValue then
+                     EgtSetMachiningParam( MachiningParameters[k].nMchParam, sValue)
+                  end
+               end
+               for k = 1, #MachiningParameters.Steps do
+                  local sValue
+                  if MACHININGS[i].AuxiliaryData.Clones and MACHININGS[i].AuxiliaryData.Clones[j].Steps and MACHININGS[i].AuxiliaryData.Clones[j].Steps[MachiningParameters.Steps[k].sName] then
+                     sValue = MACHININGS[i].AuxiliaryData.Clones[j].Steps[MachiningParameters.Steps[k].sName]
+                  elseif MACHININGS[i].Machining.Steps and MACHININGS[i].Machining.Steps[MachiningParameters.Steps[k].sName] then
+                     sValue = MACHININGS[i].Machining.Steps[MachiningParameters.Steps[k].sName]
+                  end
+                  if sValue then
+                     EgtSetMachiningParam( MachiningParameters.Steps[k].nMchParam, sValue)
+                  end
+               end
+               for k = 1, #MachiningParameters.LeadIn do
+                  local sValue
+                  if MACHININGS[i].AuxiliaryData.Clones and MACHININGS[i].AuxiliaryData.Clones[j].LeadIn and MACHININGS[i].AuxiliaryData.Clones[j].LeadIn[MachiningParameters.LeadIn[k].sName] then
+                     sValue = MACHININGS[i].AuxiliaryData.Clones[j].LeadIn[MachiningParameters.LeadIn[k].sName]
+                  elseif MACHININGS[i].Machining.LeadIn and MACHININGS[i].Machining.LeadIn[MachiningParameters.LeadIn[k].sName] then
+                     sValue = MACHININGS[i].Machining.LeadIn[MachiningParameters.LeadIn[k].sName]
+                  end
+                  if sValue then
+                     EgtSetMachiningParam( MachiningParameters.LeadIn[k].nMchParam, sValue)
+                  end
+               end
+               for k = 1, #MachiningParameters.LeadOut do
+                  local sValue
+                  if MACHININGS[i].AuxiliaryData.Clones and MACHININGS[i].AuxiliaryData.Clones[j].LeadOut and MACHININGS[i].AuxiliaryData.Clones[j].LeadOut[MachiningParameters.LeadOut[k].sName] then
+                     sValue = MACHININGS[i].AuxiliaryData.Clones[j].LeadOut[MachiningParameters.LeadOut[k].sName]
+                  elseif MACHININGS[i].Machining.LeadOut and MACHININGS[i].Machining.LeadOut[MachiningParameters.LeadOut[k].sName] then
+                     sValue = MACHININGS[i].Machining.LeadOut[MachiningParameters.LeadOut[k].sName]
+                  end
+                  if sValue then
+                     EgtSetMachiningParam( MachiningParameters.LeadOut[k].nMchParam, sValue)
+                  end
+               end
+               for k = 1, #UserNotes do
+                  local sValue
+                  if MACHININGS[i].AuxiliaryData.Clones and MACHININGS[i].AuxiliaryData.Clones[j][UserNotes[k].sName] then
+                     sValue = MACHININGS[i].AuxiliaryData.Clones[j][UserNotes[k].sName]
+                  elseif MACHININGS[i].Machining[UserNotes[k].sName] then
+                     sValue = MACHININGS[i].Machining[UserNotes[k].sName]
+                  end
+                  if sValue then
+                     local sUserNotes = ''
+                     sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
+                     sUserNotes = EgtSetValInNotes( sUserNotes, UserNotes[k].sMchParam, sValue)
+                     EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
+                  end
+               end
+               -- parametri da settare nelle note di sistema
+               -- TODO da decidere quali sono le note da salvare qui. Probabilmente tutte quelle relative all'ordine delle lavorazioni
+               --if MACHININGS[i].Machining.nMachiningOrder then
+               --   sSystemNotes = EgtSetValInNotes( sSystemNotes, 'MachiningOrder', MACHININGS[i].Machining.nMachiningOrder)
+               --end
+               for k = 1, #SystemNotes do
+                  local sValue
+                  if MACHININGS[i].AuxiliaryData.Clones and MACHININGS[i].AuxiliaryData.Clones[j][SystemNotes[k].sName] then
+                     sValue = MACHININGS[i].AuxiliaryData.Clones[j][SystemNotes[k].sName]
+                  elseif MACHININGS[i].Machining[SystemNotes[k].sName] then
+                     sValue = MACHININGS[i].Machining[SystemNotes[k].sName]
+                  end
+                  if sValue then
+                     local sSystemNotes = ''
+                     sSystemNotes = EgtGetMachiningParam( MCH_MP.SYSNOTES)
+                     sSystemNotes = EgtSetValInNotes( sSystemNotes, SystemNotes[k].sMchParam, sValue)
+                     EgtSetMachiningParam( MCH_MP.SYSNOTES, sSystemNotes)
+                  end
+               end
+
+               local bIsApplyOk = MachiningLib.ApplyMachining( true, false)
+               if not bIsApplyOk then
+                  bAreAllMachiningApplyOk = false
+                  nErr, sErr = EgtGetLastMachMgrError()
+                  EgtSetOperationMode( nOperationId, false)
+               end
+
+               -- TODO è giusto inserire queste info alla fine della lavorazione? oppure conviene creare un record in MACHININGS apposito per la disposizione?
+               -- se era taglio di separazione, aggiungo nuova fase
+               if MACHININGS[i].AuxiliaryData.bIsSplitOrCut then
+                  bSplitExecuted = true
+                  BeamLib.AddPhaseWithRawParts( MACHININGS[i].Proc.idRaw, BeamData.ptOriXR, BeamData.dPosXR, BeamData.RAW_OFFSET)
+                  -- se grezzo successivo senza pezzi e finale, va tolto
+                  local nNextRawId = EgtGetNextRawPart( MACHININGS[i].Proc.idRaw)
+                  if nNextRawId  and  EgtGetPartInRawPartCount( nNextRawId) == 0  and  EgtGetRawPartBBox( nNextRawId):getDimX() < BeamData.dMinRaw then
+                     EgtRemoveRawPartFromCurrPhase( nNextRawId)
+                  end
+                  local nPhase = EgtGetCurrPhase()
+                  local nDispId = EgtGetPhaseDisposition( nPhase)
+
+                  if sRotation == 'DOWN' then
+                     local nRotation = EgtIf( Part.nInitialPosition + 2 > 4, Part.nInitialPosition + 2 - 4, Part.nInitialPosition + 2)
+                     BeamLib.RotatePart( Part, nRotation)
+                     EgtSetInfo( nDispId, 'ROT', -2)
+                     EgtSetInfo( nDispId, 'TYPE', 'MID2')
+                  elseif sRotation == 'SIDE' then
+                     local nRotation = EgtIf( Part.nInitialPosition + 1 > 4, Part.nInitialPosition + 1 - 4, Part.nInitialPosition + 1)
+                     BeamLib.RotatePart( Part, nRotation)
+                     EgtSetInfo( nDispId, 'ROT', -1)
+                     EgtSetInfo( nDispId, 'TYPE', 'MID2')
+                  else
+                     local nRotation = Part.nInitialPosition
+                     BeamLib.RotatePart( Part, nRotation)
+                     EgtSetInfo( nDispId, 'TYPE', 'END')
+                  end
+                  EgtSetInfo( nDispId, 'ORD', MACHININGS[i].Proc.nIndexPartInParts)
+               end
+            else
+               return false, 'UNEXPECTED ERROR: Error on creating machining', bSplitExecuted
+            end
+         end
+      end
+   end
+
+   return bAreAllMachiningApplyOk, sErr, bSplitExecuted
+end
+
+-------------------------------------------------------------------------------------------------------------
+function MachiningLib.ApplyMachining( bRecalc, bApplyPost)
+   local bResult = EgtApplyMachining( bRecalc, bApplyPost)
+   
+   return bResult
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- funzione che restituisce l'indice MRR (Material Removal Rate) della strategia. Dati in ingresso: Step, SideStep, Feed, ToolIndex, MachiningType
+function MachiningLib.GetToolMRR( Parameters)
+   local dMRR = 1
+
+   -- se ho già tutti i parametri
+   if not Parameters.dStep or not Parameters.dSideStep or not Parameters.dFeed then
+      -- se manca qualche parametro, lo recupero da parametro di default dell'utensile
+      if Parameters.nToolIndex then
+         Parameters.dStep = Parameters.dStep or TOOLS[Parameters.nToolIndex].dStep
+         Parameters.dSideStep = Parameters.dSideStep or TOOLS[Parameters.nToolIndex].dSideStep
+         Parameters.dFeed = Parameters.dFeed or TOOLS[Parameters.nToolIndex].Feeds.dFeed
+      -- se non riesco a calcolare, ritorno un indice molto basso
+      else
+         return GEO.EPS_SMALL
+      end
+   end
+
+   dMRR = Parameters.dStep * Parameters.dSideStep * Parameters.dFeed
+
+   -- Unità: dm/min per avere un indice vicino alle unità
+   return dMRR / pow( 10, 6)
+end
+
+-------------------------------------------------------------------------------------------------------------
+function MachiningLib.PrepareMachiningsForSorting( Part)
+   local nFeatureInternalIndex = 1
+   for i = 1, #MACHININGS do
+      local MachiningCurrent = MACHININGS[i].Machining
+      local ProcCurrent = MACHININGS[i].Proc
+      if not MachiningCurrent.ptCenter then
+         MachiningCurrent.ptCenter = Point3d( ProcCurrent.b3Box:getCenter():getX(), 0, 0)
+      end
+
+      -- conversione campo sStage in nStage, numerico e ordinabile
+      if not MachiningCurrent.sStage or MachiningCurrent.sStage == '' then
+         MachiningCurrent.sStage = 'Middle'
+      end
+      if MachiningCurrent.sStage == 'Head' then
+         MachiningCurrent.nStage = 1
+      elseif MachiningCurrent.sStage == 'Tail' then
+         MachiningCurrent.nStage = 3
+      elseif MachiningCurrent.sStage == 'AfterTail' then
+         MachiningCurrent.nStage = 4
+      else
+         MachiningCurrent.nStage = 2
+      end
+
+      if i > 1 then
+         local MachiningPrevious = MACHININGS[i - 1].Machining
+         local ProcPrevious = MACHININGS[i - 1].Proc
+         if ProcCurrent.id == ProcPrevious.id then
+            -- nStage devono essere sempre uguali o crescenti nella stessa feature
+            if MachiningCurrent.nStage < MachiningPrevious.nStage then
+               MachiningCurrent.nStage = MachiningPrevious.nStage
+            end
+            -- assegnazione indice interno alla feature
+            nFeatureInternalIndex = nFeatureInternalIndex + 1
+         else
+            nFeatureInternalIndex = 1
+         end
+      end
+      MachiningCurrent.nFeatureInternalIndex = nFeatureInternalIndex
+      
+      -- se fase di lavoro standard, assegnazione dello spezzone
+      if MachiningCurrent.nStage == 2 then
+         local nParts = #Part.SplittingPoints + 1
+         local dPartMinX = Part.b3Part:getMin():getX()
+         local dPartMaxX = Part.b3Part:getMax():getX()
+         for j = 1, nParts do
+            local dNextSplitX = dPartMinX
+            local dPreviousSplitX = dPartMaxX
+            if j ~= 1 then
+               dPreviousSplitX = Part.SplittingPoints[j - 1]:getX()
+            end
+            if j ~= nParts then
+               dNextSplitX = Part.SplittingPoints[j]:getX()
+            end
+            if MachiningCurrent.ptCenter:getX() > dNextSplitX - 10 * GEO.EPS_SMALL and MachiningCurrent.ptCenter:getX() < dPreviousSplitX + 10 * GEO.EPS_SMALL then
+               MachiningCurrent.nPartSegment = j
+            end
+         end
+      else
+         MachiningCurrent.nPartSegment = -1
+      end
+   end
+
+   return MACHININGS
+end
+
+-- TODO convertire in tabella in cui si chiamano direttamente i nomi delle funzioni, in modo da poter cambiare l'ordine facilmente
+-- TODO libreria Sorting??
+-------------------------------------------------------------------------------------------------------------
+local SortingComparisonRules = {
+   -- ordine interno alla feature
+   function( MachiningA, MachiningB)
+      if MachiningA.Proc.id == MachiningB.Proc.id then
+         if MachiningA.Machining.nFeatureInternalIndex < MachiningB.Machining.nFeatureInternalIndex then
+            return 1
+         elseif MachiningA.Machining.nFeatureInternalIndex > MachiningB.Machining.nFeatureInternalIndex then
+            return -1
+         end
+      end
+
+      return 0
+   end,
+
+   -- dipendenze solo spostamento stage 2->4
+   -- TODO da fare
+
+   -- stage
+   function( MachiningA, MachiningB)
+      if MachiningA.Machining.nStage < MachiningB.Machining.nStage then
+         return 1
+      elseif MachiningA.Machining.nStage > MachiningB.Machining.nStage then
+         return -1
+      else
+         return 0
+      end
+   end,
+
+   -- dipendenze
+   -- TODO da fare
+
+   -- segment
+   function ( MachiningA, MachiningB)
+      if MachiningA.Machining.nPartSegment < MachiningB.Machining.nPartSegment then
+         return 1
+      elseif MachiningA.Machining.nPartSegment > MachiningB.Machining.nPartSegment then
+         return -1
+      else
+         return 0
+      end
+   end,
+
+   -- testa
+   -- TODO da fare
+
+   -- famiglia utensile
+   function ( MachiningA, MachiningB)
+      -- TODO tirare fuori da qua??
+      local ToolFamilyOrder = {
+         SAWBLADE = 1,
+         DRILLBIT = 2,
+         MILL = 3,
+         MORTISE = 4
+      }
+      local nToolFamilyOrderA = ToolFamilyOrder[ TOOLS[ MachiningA.Machining.nToolIndex].sFamily]
+      local nToolFamilyOrderB = ToolFamilyOrder[ TOOLS[ MachiningB.Machining.nToolIndex].sFamily]
+
+      if nToolFamilyOrderA < nToolFamilyOrderB then
+         return 1
+      elseif nToolFamilyOrderA > nToolFamilyOrderB then
+         return -1
+      else
+         return 0
+      end
+   end,
+
+   -- performance utensile
+   function( MachiningA, MachiningB)
+      local dToolPerformanceIndexA = TOOLS[MachiningA.Machining.nToolIndex].dPerformanceIndex
+      local dToolPerformanceIndexB = TOOLS[MachiningB.Machining.nToolIndex].dPerformanceIndex
+
+      if dToolPerformanceIndexA > dToolPerformanceIndexB then
+         return 1
+      elseif dToolPerformanceIndexA < dToolPerformanceIndexB then
+         return -1
+      else
+         return 0
+      end
+   end,
+
+   -- probabilmente arrivati qui significa che gli utensili A e B sono gli stessi
+   -- se così non fosse e tutte le caratteristiche sopra sono uguali, ordine alfabetico
+   function( MachiningA, MachiningB)
+      local sToolNameA = TOOLS[MachiningA.Machining.nToolIndex].sName
+      local sToolNameB = TOOLS[MachiningB.Machining.nToolIndex].sName
+
+      if sToolNameA < sToolNameB then
+         return 1
+      elseif sToolNameA > sToolNameB then
+         return -1
+      else
+         return 0
+      end
+   end,
+
+   -- lato di lavoro
+   -- TODO questo, insieme all'ordinamento X, andrà sostituito dallo shortest path pesato sulla quantità di rotazione della testa
+   function( MachiningA, MachiningB)
+      if MachiningA.Machining.vtToolDirection:getY() < 10 * GEO.EPS_SMALL and MachiningB.Machining.vtToolDirection:getY() >= 10 * GEO.EPS_SMALL  then
+         return 1
+      elseif MachiningA.Machining.vtToolDirection:getY() >= 10 * GEO.EPS_SMALL and MachiningB.Machining.vtToolDirection:getY() < 10 * GEO.EPS_SMALL then
+         return -1
+      else
+         return 0
+      end
+   end,
+
+   -- ordinamento X
+   -- TODO questo andrà sostituito dallo shortest path pesato sulla quantità di rotazione della testa
+   function( MachiningA, MachiningB)
+      local bIsMachiningOnFront = MachiningA.Machining.vtToolDirection:getY() < 10 * GEO.EPS_SMALL
+      local nResult = 0
+      
+      -- se lavorazione davanti ordine testa->coda
+      if bIsMachiningOnFront then
+         if MachiningA.Machining.ptCenter:getX() > MachiningB.Machining.ptCenter:getX() + 10 * GEO.EPS_SMALL then
+            nResult = 1
+         elseif MachiningA.Machining.ptCenter:getX() < MachiningB.Machining.ptCenter:getX() - 10 * GEO.EPS_SMALL then
+            nResult = -1
+         end
+      -- se lavorazione dietro ordine coda->testa
+      else
+         if MachiningA.Machining.ptCenter:getX() < MachiningB.Machining.ptCenter:getX() - 10 * GEO.EPS_SMALL then
+            nResult = 1
+         elseif MachiningA.Machining.ptCenter:getX() > MachiningB.Machining.ptCenter:getX() + 10 * GEO.EPS_SMALL then
+            nResult = -1
+         end
+      end
+
+      return nResult
+   end
+}
+
+-------------------------------------------------------------------------------------------------------------
+function MachiningLib.CompareMachinings( MachiningA, MachiningB)
+   -- itera le SortingComparisonRules una per volta. Se non vi è alcuna scelta va avanti (result = 0), altrimenti ritorna true/false in base al risultato
+   for i = 1, #SortingComparisonRules do
+      local CompareFunction = SortingComparisonRules[i]
+      local result = CompareFunction( MachiningA, MachiningB)
+      if result ~= 0 then
+         return result > 0
+      end
+   end
+
+   return false
+end
+
+-------------------------------------------------------------------------------------------------------------
+return MachiningLib

Process.lua

@@ -0,0 +1,352 @@
+-- Process.lua by Egalware s.r.l. 2024/04/02
+-- Gestione calcolo disposizione e lavorazioni per Travi
+-- Si opera sulla macchina corrente
+-- 2024/04/02 PRIMA VERSIONE
+
+
+-- Intestazioni
+require( 'EgtBase')
+_ENV = EgtProtectGlobal()
+EgtEnableDebug( true)
+
+-- Imposto direttorio libreria specializzata per Travi
+EgtAddToPackagePath( BEAM.BASEDIR .. '\\LuaLibs\\?.lua')
+-- Imposto direttorio strategie. N.B. Le strategie dovranno essere caricate con il nome del direttorio padre
+EgtAddToPackagePath( BEAM.BASEDIR .. '\\Strategies\\Standard\\?.lua')
+EgtAddToPackagePath( BEAM.BASEDIR .. '\\StrategyLibs\\?.lua')
+
+-- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
+local sMachDir = EgtGetCurrMachineDir()
+if not sMachDir then
+   EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Travi', 'ERROR')
+   return
+end
+if not EgtExistsFile( sMachDir .. '\\Beam\\BeamData.lua') then
+   EgtOutBox( 'La macchina corrente non è configurata per lavorare travi', 'Lavora Travi', 'ERROR')
+   return
+end
+
+-- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie
+EgtRemoveBaseMachineDirFromPackagePath()
+EgtAddToPackagePath( sMachDir .. '\\Beam\\?.lua')
+
+-- Segnalazione avvio
+EgtOutLog( '*** Beam Process Start ***', 1)
+
+-- Carico le librerie
+_G.package.loaded.BeamExec = nil
+_G.package.loaded.BeamLib = nil
+_G.package.loaded.BeamData = nil
+_G.package.loaded.Identity = nil
+_G.package.loaded.BasicCustomerStrategies = nil
+_G.package.loaded.FeatureLib = nil
+_G.package.loaded.FaceData = nil
+_G.package.loaded.MachiningLib = nil
+_G.package.loaded.DiceCut = nil
+_G.package.loaded.Logs = nil
+-- strategie di base sempre presenti
+_G.package.loaded['HEADCUT\\HEADCUT'] = nil
+_G.package.loaded['HEADCUT\\HEADCUTConfig'] = nil
+_G.package.loaded['TAILCUT\\TAILCUT'] = nil
+_G.package.loaded['TAILCUT\\TAILCUTConfig'] = nil
+
+-- TODO controllare se c'è un modo migliore per resettare librerie delle strategie caricate precedentemente
+-- Per ottimizzare potremmo anche ciclare solo fino al numero di strategie raggiunto per il momento.
+-- Infatti difficile ci siano 9999 strategie.
+-- reset strategie caricate come librerie
+for i = 1, 9999 do
+   local IdSTRTemp = EgtReplaceString( tostring( i/10000, 4), '0.', '')
+   local sLibraryToReload = "STR" .. IdSTRTemp .. "\\STR" .. IdSTRTemp
+   local sLibraryConfigToReload = sLibraryToReload .. "Config"
+   if _G.package.loaded[sLibraryToReload] then
+      _G.package.loaded[sLibraryToReload] = nil
+   end
+   if _G.package.loaded[sLibraryConfigToReload] then
+      _G.package.loaded[sLibraryConfigToReload] = nil
+   end
+end
+local vtCoreStrategiesNames = EgtFindAllFiles( BEAM.BASEDIR .. '\\StrategyLibs\\*.lua')
+for i = 1, #vtCoreStrategiesNames do
+   local sCurrentName = EgtSplitString( vtCoreStrategiesNames[i], '.')[1]
+   if _G.package.loaded[sCurrentName] then
+      _G.package.loaded[sCurrentName] = nil
+   end
+end
+
+
+-- Variabili globali
+PARTS = {}          -- tabella contenente tutte le informazioni di ogni pezzo
+
+-- Carico i dati globali
+local BeamData = require( 'BeamData')
+-- carico librerie
+local BeamExec = require( 'BeamExec')
+
+-- Variabili di modulo
+local dRawW
+local dRawH
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Recupero le travi selezionate ***
+-------------------------------------------------------------------------------------------------------------
+local function MyProcessInputData()
+
+   -- Recupero le travi selezionate
+   local nId = EgtGetFirstSelectedObj()
+   while nId do
+      local nPartId = EgtGetParent( EgtGetParent( nId or GDB_ID.NULL) or GDB_ID.NULL)
+      if nPartId then
+         local bFound = false
+         for i = 1, #PARTS do
+            if PARTS[i].id == nPartId then
+               bFound = true
+               break
+            end
+         end
+         if not bFound then
+            table.insert( PARTS, { nInd = #PARTS + 1, id = nPartId, sName = ( EgtGetName( nPartId) or ( 'Id=' .. tonumber( nPartId)))})
+         end
+      end
+      nId = EgtGetNextSelectedObj()
+   end
+   if #PARTS == 0 then
+      EgtOutBox( 'Non sono state selezionate travi', 'Lavora Travi', 'ERROR')
+      return false
+   else
+      local sOut = ''
+      for i = 1, #PARTS do
+         sOut = sOut .. PARTS[i].sName .. ', '
+      end
+      sOut = sOut:sub( 1, -3)
+      EgtOutLog( 'Travi selezionate : ' .. sOut, 1)
+   end
+
+   -- Ne recupero e verifico le dimensioni
+   for i = 1, #PARTS do
+      local Ls = EgtGetFirstNameInGroup( PARTS[i].id, 'Box')
+      local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
+      if not b3Solid then
+         EgtOutBox( 'Box non definito per la trave ' .. PARTS[i].sName, 'Lavora Travi', 'ERROR')
+         return false
+      else
+         PARTS[i].b3PartOriginal = b3Solid
+      end
+   end
+   dRawW = PARTS[1].b3PartOriginal:getDimY()
+   dRawH = PARTS[1].b3PartOriginal:getDimZ()
+   local vBeamErr = {}
+   for i = 2, #PARTS do
+      local dDimW = PARTS[i].b3PartOriginal:getDimY()
+      local dDimH = PARTS[i].b3PartOriginal:getDimZ()
+      if ( abs( dDimW - dRawW) > 10 * GEO.EPS_SMALL  or  abs( dDimH - dRawH) > 10 * GEO.EPS_SMALL)  and
+         ( abs( dDimH - dRawW) > 10 * GEO.EPS_SMALL  or  abs( dDimW - dRawH) > 10 * GEO.EPS_SMALL) then
+         table.insert( vBeamErr, i)
+      end
+   end
+   if #vBeamErr > 0 then
+      local sOut = 'Rimosse travi con sezioni diverse dalla prima :\n'
+      for i = #vBeamErr, 1, -1 do
+         sOut = sOut .. PARTS[vBeamErr[i]].sName .. '\n'
+         EgtDeselectPartObjs( PARTS[vBeamErr[i]].id)
+         table.remove( PARTS, vBeamErr[i])
+      end
+      EgtOutLog( sOut, 1)
+      EgtOutBox( sOut, 'Lavora Travi', 'INFO')
+      EgtDraw()
+      return false
+   end
+   EgtDeselectAll()
+
+   return true
+end
+
+
+-------------------------------------------------------------------------------------------------------------
+local function GetDataConfig()
+   -- recupero utensili dal magazzino
+   BeamExec.GetToolsFromDB()
+   -- se si utilizza interfaccia B&W, si carica il file JSON
+   local bIsBeamWall = true    -- TODO serve parametro per capire se stiamo utilizzando B&W
+   if bIsBeamWall then
+      BeamExec.GetStrategiesFromJSONinBD()
+   end
+   -- TODO da gestire eventuali errori bloccanti
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Inserimento delle travi nel grezzo ***
+-------------------------------------------------------------------------------------------------------------
+local function MyProcessBeams()
+   -- Determinazione minimo grezzo scaricabile
+   BeamExec.CalcMinUnloadableRaw( dRawW, dRawH)
+
+   -- Lunghezza totale delle travi
+   local dTotLen = 0
+   for i = 1, #PARTS - 1 do
+      dTotLen = dTotLen + PARTS[i].b3PartOriginal:getDimX()
+   end
+   dTotLen = dTotLen + max( PARTS[#PARTS].b3PartOriginal:getDimX(), BeamData.dMinRaw)
+   local dAddLen = BeamData.OVM_HEAD + ( #PARTS - 1) * BeamData.OVM_MID
+   EgtOutLog( 'Ltot : '..EgtNumToString( dTotLen, 1) .. ' Lagg : '..EgtNumToString( dAddLen, 1)..' MinUnloadRaw : '.. EgtNumToString( BeamData.dMinRaw + BeamData.OVM_MID, 1), 1)
+
+   -- Richiedo lunghezza del grezzo, sovramateriale di testa, forzatura verticale e ordinamento automatico secondo la lunghezza
+   local vsVal = EgtDialogBox( 'Lavora Travi' .. '     (Ltot='..EgtNumToString( dTotLen + dAddLen + 0.5, 0)..
+                                                       ', Lmax='..EgtNumToString( BeamData.MAX_RAW, 0)..',MinUlr='..EgtNumToString( BeamData.dMinRaw + BeamData.OVM_MID, 0)..')',
+                              --{'Lunghezza grezzo', EgtNumToString( BeamData.STD_RAW, 0)},  -- TODO RIPRISTINARE
+                              {'Lunghezza grezzo', EgtNumToString( 0)},
+                              {'Sovramateriale di testa', EgtNumToString( BeamData.OVM_HEAD, 0)},
+                              {'Offset intermedio', EgtNumToString( BeamData.OVM_MID, 0)},
+                              {'Forza sezione verticale', ' CB:true,*false'},
+                              {'Ordina per lunghezza', ' CB:true,*false'},
+                              {'Calcolo Lavorazioni', ' CB:*Da progetto,Ricalcolo standard,Ricalcolo IA'})
+   if not vsVal then
+      EgtDraw()
+      return
+   end
+   local dRawL = EgtEvalNumExpr( vsVal[1])
+   if not dRawL then
+      local sOut = 'Lunghezza grezzo errata : ' .. vsVal[1]
+      EgtOutLog( sOut)
+      EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
+      EgtDraw()
+      return false
+   end
+   if dRawL < GEO.EPS_SMALL then dRawL = dTotLen + dAddLen + 0.5 end
+   dRawL = min( dRawL, BeamData.MAX_RAW)
+   local dOvmHead = EgtEvalNumExpr( vsVal[2])
+   if not dOvmHead then
+      local sOut = 'Sovramateriale di testa errato : ' .. vsVal[2]
+      EgtOutLog( sOut)
+      EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
+      EgtDraw()
+      return false
+   end
+   local dOvmMid = EgtEvalNumExpr( vsVal[3])
+   if not dOvmMid then
+      local sOut = 'Offset intermedio : ' .. vsVal[3]
+      EgtOutLog( sOut)
+      EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
+      EgtDraw()
+      return false
+   end
+
+   -- Sistemo sezione barra con travi
+   local bVert = ( vsVal[4] == 'true')
+   if bVert then
+      if dRawW > dRawH then dRawW, dRawH = dRawH, dRawW end
+   end
+   EgtOutLog( 'Lraw : ' .. EgtNumToString( dRawL, 1) .. ' Lovm : '.. EgtNumToString( dOvmHead, 1), 1)
+
+   -- Verifico sezione barra non troppo grande
+   if not BeamData.MAX_WIDTH2 or not BeamData.MAX_HEIGHT2 then
+      if ( dRawW > BeamData.MAX_WIDTH + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT + 10 * GEO.EPS_SMALL) then
+         local sOut = 'Sezione ('  .. EgtNumToString( dRawW, 2) .. ' x ' .. EgtNumToString( dRawH, 2) .. ') ' ..
+                      'oltre i limiti della macchina (' .. EgtNumToString( BeamData.MAX_WIDTH, 2) .. ' x ' .. EgtNumToString( BeamData.MAX_HEIGHT, 2) .. ') '
+         EgtOutLog( sOut)
+         EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
+         EgtDraw()
+         return false
+      end
+   else
+      if ( dRawW > BeamData.MAX_WIDTH + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT + 10 * GEO.EPS_SMALL) and
+         ( dRawW > BeamData.MAX_WIDTH2 + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT2 + 10 * GEO.EPS_SMALL) then
+         local sOut = 'Sezione ('  .. EgtNumToString( dRawW, 2) .. ' x ' .. EgtNumToString( dRawH, 2) .. ') ' ..
+                      'oltre i limiti della macchina (' .. EgtNumToString( BeamData.MAX_WIDTH, 2) .. ' x ' .. EgtNumToString( BeamData.MAX_HEIGHT, 2) .. ') ' ..
+                      'e (' .. EgtNumToString( BeamData.MAX_WIDTH2, 2) .. ' x ' .. EgtNumToString( BeamData.MAX_HEIGHT2, 2) .. ')'
+         EgtOutLog( sOut)
+         EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
+         EgtDraw()
+         return false
+      end
+   end
+
+   -- Verifico sezione barra non troppo piccola
+   if dRawW < BeamData.MIN_WIDTH - 10 * GEO.EPS_SMALL or dRawH < BeamData.MIN_HEIGHT - 10 * GEO.EPS_SMALL then
+      local sOut = 'Sezione ('  .. EgtNumToString( dRawW, 2) .. ' x ' .. EgtNumToString( dRawH, 2) .. ') ' ..
+                   'sotto i limiti della macchina (' .. EgtNumToString( BeamData.MIN_WIDTH, 2) .. ' x ' .. EgtNumToString( BeamData.MIN_HEIGHT, 2) .. ')'
+      EgtOutLog( sOut)
+      EgtOutBox( sOut, 'Lavora Travi', 'WARNING')
+      EgtDraw()
+      return false
+   end
+
+   -- Se richiesto, ordino le travi in senso di lunghezza crescente
+   local bOrd = ( vsVal[5] == 'true')
+   if bOrd then
+      table.sort( PARTS, function( B1, B2)
+                           if abs( B1.b3PartOriginal:getDimX() - B2.b3PartOriginal:getDimX()) < 1 then
+                              return B1.nInd < B2.nInd
+                           else
+                              return B1.b3PartOriginal:getDimX() < B2.b3PartOriginal:getDimX()
+                           end
+                        end)
+   end
+   do
+      local sOut = ''
+      for i = 1, #PARTS do
+         sOut = sOut .. PARTS[i].sName .. ', '
+      end
+      sOut = sOut:sub( 1, -3)
+      EgtOutLog( 'Travi ordinate : ' .. sOut, 1)
+   end
+
+   -- Sistemo le travi nel grezzo
+   local bOk, sErr = BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS)
+   if not bOk then
+      EgtOutLog( sErr)
+      EgtOutBox( sErr, 'Lavora Travi', 'ERROR')
+      return false
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Inserimento delle lavorazioni nelle travi ***
+-------------------------------------------------------------------------------------------------------------
+local function MyProcessFeatures()
+   BeamExec.GetProcessings( PARTS)
+   local bOk, Stats = BeamExec.ProcessMachinings( PARTS)
+   local nErrCnt = 0
+   local nWarnCnt = 0
+   local sOutput = ''
+   for i = 1, #Stats do
+      if Stats[i].nErr > 0 then
+         nErrCnt = nErrCnt + 1
+         sOutput = sOutput .. string.format( '[%d,%d] %s\n', Stats[i].idCut, Stats[i].idTask, Stats[i].sMsg)
+      elseif Stats[i].nErr < 0 then
+         -- se segnalazione scarico pezzo standard, incompleto o a caduta
+         if Stats[i].nErr == -100 or Stats[i].nErr == -101 or Stats[i].nErr == -102 then
+            -- non faccio niente
+         else
+            nWarnCnt = nWarnCnt + 1
+            sOutput = sOutput .. string.format( '[%d,%d] %s\n', Stats[i].idCut, Stats[i].idTask, Stats[i].sMsg)
+         end
+      end
+   end
+   if #sOutput > 0 then EgtOutLog( sOutput) end
+   if nErrCnt > 0 then
+      EgtOutBox( sOutput, 'Lavora Travi', 'ERRORS')
+      return false
+   elseif nWarnCnt > 0 then
+      EgtOutBox( sOutput, 'Lavora Travi', 'WARNINGS')
+      return true
+   end
+
+   return true
+end
+
+-------------------------------------------------------------------------------------------------------------
+--    *** Esecuzione ***
+-------------------------------------------------------------------------------------------------------------
+if not MyProcessInputData() then return end
+
+if not MyProcessBeams() then return end
+
+if not GetDataConfig() then return end
+
+-- Abilito Vmill
+EgtSetInfo( EgtGetCurrMachGroup(), 'Vm', '1')
+
+if not MyProcessFeatures() then return end

README.md

@@ -1,93 +0,0 @@
-# DataBeamNEW
-
-
-
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
-```
-cd existing_repo
-git remote add origin https://gitlab.steamware.net/egalware-cadcam/lua/databeamnew.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://gitlab.steamware.net/egalware-cadcam/lua/databeamnew/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Set auto-merge](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
-
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
-
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
-
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
-
-## License
-For open source projects, say how it is licensed.
-
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.

Rotate.lua

@@ -0,0 +1,32 @@
+-- Rotate.lua by Egaltech s.r.l. 2017/11/04
+-- Gestione rotazione di una Trave
+
+-- Intestazioni
+require( 'EgtBase')
+_ENV = EgtProtectGlobal()
+EgtEnableDebug( false)
+
+
+-- recupero il pezzo del primo oggetto selezionato
+local nId = EgtGetFirstSelectedObj()
+local nPartId = EgtGetParent( EgtGetParent( nId or GDB_ID.NULL) or GDB_ID.NULL)
+if not nPartId or not EgtIsPart( nPartId) then
+   EgtOutBox( 'Nessuna trave selezionata', 'Rotate Trave', 'ERROR')
+   return
+end
+
+-- recupero il box del pezzo
+local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
+local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
+if not b3Solid then
+   local sName = EgtGetName( nPartId) or ( 'Id=' .. tonumber( nPartId))
+   EgtOutBox( 'Box non definito per la trave ' .. sName, 'Rotate Trave', 'ERROR')
+   return
+end  
+
+-- eseguo rotazione di 90 gradi attorno asse X
+local ptRot = b3Solid:getMin() + Vector3d( 0, b3Solid:getDimZ() / 2, b3Solid:getDimZ() / 2)
+EgtRotate( nPartId, ptRot, X_AX(), 90, GDB_RT.GLOB)
+EgtDraw()
+
+-- end

Strategies/Standard/HEADCUT/HEADCUT.lua

@@ -0,0 +1,367 @@
+-- Strategia: HEADCUT
+-- Descrizione 
+-- HeadCut
+-- Feature: HeadCut
+
+
+---------------------------------------------------------------------------------------------------------
+-- TODO: HEADCUT copiata da SPLITCUT. Da sistemare e capire se fare solo una strategia oppure due divise. 
+---------------------------------------------------------------------------------------------------------
+
+
+-- 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 HEADCUT = {}
+local Strategy = {}
+
+-------------------------------------------------------------------------------------------------------------
+local function LoadStrategyParameters( CustomParameters)
+   local StrategyLib = {}
+   StrategyLib.Config = require( 'HEADCUT\\HEADCUTConfig')
+   Strategy.sName = StrategyLib.Config.sStrategyId
+   CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
+   Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
+   Strategy.Result = {}
+   Strategy.Machining = {}
+   Strategy.Result.sInfo = ''
+   return Strategy
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function CalculateLeadInOut( Machining, EdgeToMachine)
+
+   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
+   LeadIn.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
+   LeadOut.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
+   LeadIn.dElevation = 0
+   LeadOut.dElevation = 0
+   LeadIn.dCompLength = 0
+   LeadOut.dCompLength = 0
+   LeadIn.dStartAddLength = BeamData.CUT_EXTRA
+   LeadOut.dEndAddLength = BeamData.CUT_EXTRA
+
+   return LeadIn, LeadOut
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function MakeChamfer()
+   -- TODO funzionalit� da aggiungere
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetEdgeToMachine( Proc, vtEdge)
+   local Edge
+   for i = 1, #Proc.Faces[1].Edges do
+      if AreSameVectorApprox( Proc.Faces[1].Edges[i].vtN, vtEdge) then
+         Edge = Proc.Faces[1].Edges[i]
+      end
+   end
+   return Edge
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetSplitStrategy( Proc, Part)
+   -- se non sono stati caricati i parametri, si ricaricano
+   if not Strategy.Parameters then
+      Strategy = LoadStrategyParameters()
+   end
+
+   -- separazione solo se esiste grezzo successivo con pezzi o scaricabile
+   local nNextRawId = EgtGetNextRawPart( Part.idRaw)
+   Strategy.bSplit = ( nNextRawId  and  ( EgtGetPartInRawPartCount( nNextRawId) > 0  or  EgtGetRawPartBBox( nNextRawId):getDimX() >= BeamData.dMinRaw))
+
+   -- imposto paraemtri di ricerca utensile in base a topologia
+   local Machining = {}
+   -- sTypeMachining = BladeSideSingle\ BladeSideDouble\ BladeHorizontalSingle\ BladeHorizontalDouble\ ChainSawHorizontal\ ChainSawSideSingle\ ChainSawSideDouble\ ChainSawPlusBlade\ Mill\ None
+   Machining.sTypeMachining = 'None'
+   local Splitting = {}
+   local ToolSearchParameters = {}
+   ToolSearchParameters.vtToolDirection = Proc.Faces[1].vtN
+
+
+   --  ===== RICERCA UTENSILE =====
+   -- cerco lama sopra
+   Splitting.bIsApplicable = false
+   ToolSearchParameters.bAllowTopHead = true
+   ToolSearchParameters.bAllowBottomHead = false
+   Splitting.ToolInfo = {}
+   Splitting.ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
+   if Splitting.ToolInfo.nToolIndex then
+      Splitting.bIsApplicable = true
+      local ParametersMRR = {}
+      ParametersMRR.nToolIndex = Splitting.ToolInfo.nToolIndex
+      Splitting.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+   end
+   table.insert( Machining, Splitting)
+
+   -- cerco lama sotto
+   Splitting = {}
+   Splitting.bIsApplicable = false
+   ToolSearchParameters.bAllowTopHead = false
+   ToolSearchParameters.bAllowBottomHead = true
+   Splitting.ToolInfo = {}
+   Splitting.ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
+   if Splitting.ToolInfo.nToolIndex then
+      Splitting.bIsApplicable = true
+      local ParametersMRR = {}
+      ParametersMRR.nToolIndex = Splitting.ToolInfo.nToolIndex
+      Splitting.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+   end
+   table.insert( Machining, Splitting)
+
+   -- cerco motosega
+   Splitting = {}
+   Splitting.bIsApplicable = false
+   table.insert( Machining, Splitting)
+
+   -- cerco fresa
+   Splitting = {}
+   Splitting.bIsApplicable = false
+   table.insert( Machining, Splitting)
+
+   --  ===== SCELTA LAVORAZIONI =====
+   -- forzature da parametri
+   if Strategy.Parameters.bForceChainSaw then
+      Machining[1].bIsApplicable = false
+      Machining[2].bIsApplicable = false
+   end
+
+   -- setto valori di default. Impossibile che taglio di separazione sia incompleto
+   Strategy.Result.sStatus = 'Completed'
+   Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
+   Strategy.Result.dMRR = 1
+
+   -- correzioni sul massimo materiale lama, considerando ingombri vari
+   local dMaxMatBladeSideSingle
+   local dMaxMatBladeSideDouble
+   local dMaxMatBladeHorizontalSingle
+   local dMaxMatBladeHorizontalDouble
+   if Machining[1].bIsApplicable then
+      local dMaxMat = TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial
+      local dRadius = TOOLS[Machining[1].ToolInfo.nToolIndex].dDiameter / 2
+      local sHead = TOOLS[Machining[1].ToolInfo.nToolIndex].sHead
+      -- se taglio di fianco disponibile, si controlla il massimo materiale reale. Per pezzi alti, bisogna controllare anche l'ingombro asse Z nelle 4 direzioni.
+      if Part.dHeight < BeamData.MIN_DIM_HBEAM then
+         dMaxMat = min( dMaxMat, BeamData.MAX_DIM_HTCUT)
+         dMaxMatBladeSideSingle = dMaxMat
+         dMaxMatBladeSideDouble = dMaxMat * 2
+      else
+         if BeamData.GetMaxMatReductionBladeCut then
+            dMaxMatBladeSideSingle = min( max( dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, Y_AX()), dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, -Y_AX())),
+                                          TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial)
+            dMaxMatBladeSideDouble = dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, Y_AX()) + dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, -Y_AX())
+         else
+            dMaxMatBladeSideSingle = abs( BeamData.MAX_DIM_HTCUT_HBEAM)
+            dMaxMatBladeSideDouble = abs( BeamData.MAX_DIM_HTCUT_HBEAM) * 2
+         end
+      end
+      -- se taglio orizzontale
+      if BeamData.GetMaxMatReductionBladeCut then
+         dMaxMatBladeHorizontalSingle = min( TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial, dRadius - BeamData.GetMaxMatReductionBladeCut( TOOLS[Machining[1].ToolInfo.nToolIndex].sHead, -Z_AX()))
+      else
+         dMaxMatBladeHorizontalSingle = TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial
+      end
+   end
+   if Machining[2].bIsApplicable then
+      if BeamData.GetMaxMatReductionBladeCut then
+         local dRadius = TOOLS[Machining[2].ToolInfo.nToolIndex].dDiameter / 2
+         dMaxMatBladeHorizontalDouble = min( TOOLS[Machining[2].ToolInfo.nToolIndex].dMaxMaterial, dRadius - BeamData.GetMaxMatReductionBladeCut( TOOLS[Machining[2].ToolInfo.nToolIndex].sHead, Z_AX()))
+      else
+         dMaxMatBladeHorizontalDouble = TOOLS[Machining[2].ToolInfo.nToolIndex].dMaxMaterial
+      end
+   end
+
+   -- TODO considerare di tagliare con il massimo materiale possibile per non salire troppo in Z (macchine tipo PF), oppure non scendere troppo (tipo Kairos)
+   -- BladeSideSingle   (taglio di lama singolo di fianco)
+   if Machining[1].bIsApplicable  and  ( dMaxMatBladeSideSingle - BeamData.CUT_EXTRA) > Part.dWidth + 10 * GEO.EPS_SMALL then
+      Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+      Machining.sTypeMachining = 'BladeSideSingle'
+      Machining[2].bIsApplicable = false
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining
+   -- TODO considerare di tagliare con il massimo materiale possibile per non salire troppo in Z (macchine tipo PF), oppure non scendere troppo (tipo Kairos)
+   -- BladeSideDouble   (taglio di lama doppio di fianco)
+   elseif Machining[1].bIsApplicable  and  ( dMaxMatBladeSideDouble - BeamData.CUT_EXTRA) > Part.dWidth + 10 * GEO.EPS_SMALL then
+      Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+      Strategy.Result.dMRR = Strategy.Result.dMRR/2
+      Machining.sTypeMachining = 'BladeSideDouble'
+      Machining[2].bIsApplicable = false
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining
+   -- BladeHorizontalSingle   (taglio di lama singolo orizzontale)
+   elseif Machining[1].bIsApplicable  and  ( dMaxMatBladeHorizontalSingle - BeamData.CUT_EXTRA) > Part.dHeight + 10 * GEO.EPS_SMALL then
+      Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+      Machining.sTypeMachining = 'BladeHorizontalSingle'
+      Machining[2].bIsApplicable = false
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining
+   -- BladeHorizontalDouble   (taglio di lama doppio orizzontale)
+   elseif Machining[1].bIsApplicable  and  Machining[2].bIsApplicable and
+         ( dMaxMatBladeHorizontalSingle + dMaxMatBladeHorizontalDouble - BeamData.CUT_EXTRA) > Part.dHeight + 10 * GEO.EPS_SMALL then
+      Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+      Strategy.Result.dMRR = Strategy.Result.dMRR/2
+      Machining.sTypeMachining = 'BladeHorizontalDouble'
+      Machining[1].ToolInfo.dMaxMatBladeFromTop = dMaxMatBladeHorizontalSingle
+      Machining[2].ToolInfo.dMaxMatBladeFromDown = dMaxMatBladeHorizontalDouble
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining
+
+   -- TODO : casi con motosega da completare
+   -- ChainSawHorizontal   (motosega)
+   -- ChainSawSideSingle   (motosega)
+   -- ChainSawSideDouble   (motosega)
+   -- ChainSawPlusBlade   (motosega pi� lama orizzontale)
+   -- Mill   (svuotatura)
+   end
+
+   -- se non ho trovato neanche una lavorazione completa, non posso separare
+   if Machining.sTypeMachining == 'None' then
+      Strategy.Result.sStatus = 'Not-Applicable'
+      Strategy.Result.nCompletionIndex = 0
+      Strategy.Result.dMRR = 0
+      Strategy.Result.nQuality = 0
+      Strategy.Result.sInfo = 'Split not possible'
+   end
+
+   return Machining
+end
+
+-------------------------------------------------------------------------------------------------------------
+function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
+   Strategy = LoadStrategyParameters( CustomParameters)
+   local bAreAllMachiningsAdded = true
+   local Splitting = {}
+   local AuxiliaryData = {}
+
+   Strategy.SplitStrategy = GetSplitStrategy( Proc, Part)
+   if bAddMachining then
+      -- inserimento smussi su spigoli del taglio
+      if Strategy.Parameters.bMakeChamfer then
+         MakeChamfer()
+      end
+
+      local OptionalParameters = {}
+      -- applico le lavorazioni
+   ----------------------------------------------------------------------------------
+      if Strategy.SplitStrategy.sTypeMachining == 'BladeSideSingle' then
+         OptionalParameters = {}
+         OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+
+         -- TODO gestire lavorazione a cubetti
+
+         local EdgeToMachine = GetEdgeToMachine( Proc, -Y_AX())
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
+         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
+   ----------------------------------------------------------------------------------
+      elseif Strategy.SplitStrategy.sTypeMachining == 'BladeSideDouble' then
+         -- Taglio lato frontale
+         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())
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
+         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
+   
+         -- Taglio lato dietro
+         OptionalParameters = {}
+         Splitting = {}
+         AuxiliaryData = {}
+         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())
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
+         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
+   ----------------------------------------------------------------------------------
+      elseif Strategy.SplitStrategy.sTypeMachining == 'BladeHorizontalSingle' then
+         OptionalParameters = {}
+         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())
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
+         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
+   ----------------------------------------------------------------------------------
+      elseif Strategy.SplitStrategy.sTypeMachining == 'BladeHorizontalDouble' then
+         -- Taglio lato frontale
+         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())
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
+         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
+   
+         -- Taglio lato dietro
+         OptionalParameters = {}
+         Splitting = {}
+         AuxiliaryData = {}
+         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())
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
+         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
+   ----------------------------------------------------------------------------------
+      elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawHorizontal' then
+         ; -- TODO
+   ----------------------------------------------------------------------------------
+      elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawSideSingle' then
+         ; -- TODO
+   ----------------------------------------------------------------------------------
+      elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawSideDouble' then
+         ; -- TODO
+   ----------------------------------------------------------------------------------
+      elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawPlusBlade' then
+         ; -- TODO
+   ----------------------------------------------------------------------------------
+      elseif Strategy.SplitStrategy.sTypeMachining == 'Mill' then
+         ; -- TODO
+   ----------------------------------------------------------------------------------
+      end
+
+      return bAreAllMachiningsAdded, Strategy.Result
+   else
+      return nil, Strategy.Result
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+
+ return HEADCUT

Strategies/Standard/HEADCUT/HEADCUTConfig.lua

@@ -0,0 +1,12 @@
+-- Parametri configurabili da cliente per strategia: HEADCUT
+
+local HEADCUTData = {
+   sStrategyId = 'HEADCUT',
+   Parameters = {
+      { sName = 'bMakeChamfer', sValue = 'false', sDescriptionShort = 'Execute Chamfer', sDescriptionLong = 'Use the V-Mill to execute chamfers on cut-edges', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'bForceChainSaw', sValue = 'false', sDescriptionShort = 'Force to use chain saw', sDescriptionLong = 'Force to use chain saw', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'bFinishWithMill', sValue = 'true', sDescriptionShort = 'Finish with mill', sDescriptionLong = 'Use a mill to finish the surface if split with chain saw', sType = 'b', sMessageId = '', sMinUserLevel = '1'}
+   }
+}
+
+return HEADCUTData

Strategies/Standard/STR0001/STR0001.lua

@@ -0,0 +1,216 @@
+-- Strategia: STR0001
+-- Descrizione 
+-- Lama + fresa CodaDiRondine per tenone
+-- Feature: 55,1
+
+-- 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( 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
+
+-------------------------------------------------------------------------------------------------------------
+
+ return STR0001

Strategies/Standard/STR0001/STR0001Config.lua

@@ -0,0 +1,13 @@
+-- Parametri configurabili da cliente per strategia: STR0001
+
+local STR0001Data = {
+   sStrategyId = 'STR0001',
+   Parameters = {
+      { sName = 'dOverMatOnLenght', sNameNge = 'OVM_LENGTH', sValue = '0', sDescription = 'Sovramateriale lunghezza tenone', sType = 'd'},
+      { sName = 'dOverMatOnRadius', sNameNge = 'OVM_RADIUS', sValue = '0', sDescription = 'Sovramateriale larghezza tenone', sType = 'd'},
+      { sName = 'nMaxMillingPaths', sNameNge = 'MAX_PATHS', sValue = '3', sDescription = 'Numero massimo di passaggi di fresatura. Se richiesti più passaggi, si fa svuotatura', sType = 'd'},
+      { sName = 'bUseDTToolOnPocketing', sNameNge = 'ALLOW_DT_POCKET', sValue = 'true', sDescription = 'Utilizza utensile a coda di rondine per fare svuotatura', sType = 'b'}
+   }
+}
+
+return STR0001Data

Strategies/Standard/STR0002/STR0002.lua

@@ -0,0 +1,505 @@
+-- Strategia: STR0002
+-- Descrizione 
+-- Svuotatura tasca
+-- Feature tipo LapJoint
+
+-------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------
+-- TODO
+-- 1 - Inserire antischeggia (fresa o lama)
+-- 2 - Modalità svuotatura con fresa grande e spigoli con fresa piccola
+-- 3 - Smusso a V
+-- 4 - Finitura con motosega (se la fresa non completa)
+-------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------
+
+
+-- carico librerie
+local BeamLib = require( 'BeamLib')
+local BeamData = require( 'BeamData')
+local MachiningLib = require( 'MachiningLib')
+local FeatureLib = require( 'FeatureLib')
+
+-- Tabella per definizione modulo
+local STR0002 = {}
+local Strategy = {}
+
+-------------------------------------------------------------------------------------------------------------
+local function IsTopologyOk( Proc)
+   if Proc.Topology.sName == 'Pocket-5-Blind' or
+      Proc.Topology.sName == 'Tunnel-4-Through' or
+      Proc.Topology.sName == 'Groove-4-Blind' or
+      Proc.Topology.sName == 'Groove-3-Through' or
+      Proc.Topology.sName == 'Groove-3-Blind' or
+      Proc.Topology.sName == 'Rabbet-2-Through' then
+
+      return true
+   else
+      return false
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function CalcMachinedPercentage( Proc, Machining)
+   -- se non ci sono lavorazioni esco subito
+   if Machining.sTypeMachining == 'None' then
+      return 0
+   end
+
+   local dTotalPercentage = 0
+   local dPercentageBottom = 0
+
+   if Machining[1].bIsApplicable then
+      dTotalPercentage = ( Machining[1].dElevation - Machining[1].ToolInfo.dResidualDepth) / Machining[1].dElevation
+      dPercentageBottom = dTotalPercentage
+   end
+   if Machining[2].bIsApplicable then
+      local dAbsPercentage = ( Machining[2].dElevation - Machining[2].ToolInfo.dResidualDepth) / Machining[2].dElevation
+      dTotalPercentage = dTotalPercentage + ( 1 - dTotalPercentage) * dAbsPercentage
+   end
+   if Machining[3].bIsApplicable then
+      local dAbsPercentage
+      if Machining[3].bMachAppliedToTunnelFace then
+         dAbsPercentage = ( Machining[3].dElevation - Machining[3].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation) / Machining[3].dElevation
+      else
+         dAbsPercentage = ( Machining[3].dElevation - Machining[3].ToolInfo.dResidualDepth) / Machining[3].dElevation
+      end
+      dTotalPercentage = dTotalPercentage + ( 1 - dPercentageBottom) * dAbsPercentage
+   end
+   if Machining[4].bIsApplicable then
+      local dAbsPercentage
+      if Machining[3].bMachAppliedToTunnelFace then
+         dAbsPercentage = ( Machining[4].dElevation - Machining[4].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation) / Machining[4].dElevation
+      else
+         dAbsPercentage = ( Machining[4].dElevation - Machining[4].ToolInfo.dResidualDepth) / Machining[4].dElevation
+      end
+      dTotalPercentage = dTotalPercentage + ( 1 - dPercentageBottom) * dAbsPercentage
+   end
+
+   return dTotalPercentage * 100
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetBestPocketingStrategy( Proc)
+   -- imposto parametri di ricerca utensile in base a topologia
+   local Machining = {}
+   local Milling = {}
+   local ToolSearchParameters = {}
+   ToolSearchParameters.sMillShape = 'STANDARD'
+   Machining.sTypeMachining = 'None' -- Bottom-Side1-Side2\ Bottom-Side1\ Bottom-Side2\ Side1-Side2\ Bottom\ Side1 \ Side2 \ None
+   Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Mill')
+
+   -- caso speciale Tunnel che non ha faccia bottom
+   if Proc.Topology.sName == 'Tunnel-4-Through' then
+      local dFaceHeight = Proc.MainFaces.SideFaces[1].MainEdges.OppositeEdges[1].dLength
+      local dFaceWidth = Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1].dLength
+      ToolSearchParameters.sType = 'MILL_STD'
+      ToolSearchParameters.dMaxToolDiameter = min( Strategy.Parameters.dMaxCornerRadius * 2, dFaceHeight, dFaceWidth)
+   -- imposto dati per cercare la fresa migliore
+   elseif Proc.Topology.sName == 'Pocket-5-Blind' then
+      local dFaceWidth = Proc.MainFaces.BottomFaces[1].MainEdges.LongEdges[1].dLength
+      local dFaceHeight = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
+      ToolSearchParameters.sType = 'MILL_STD'
+      ToolSearchParameters.dMaxToolDiameter = min( Strategy.Parameters.dMaxCornerRadius * 2, dFaceHeight, dFaceWidth)
+   -- cerco fresa che può anche non lavorare di testa
+   elseif Proc.Topology.sName == 'Groove-4-Blind' then
+      local dFaceWidth = Proc.MainFaces.BottomFaces[2].MainEdges.BottomEdge.dLength
+      ToolSearchParameters.sType = 'MILL_NOTIP'
+      ToolSearchParameters.dMaxToolDiameter = min( Strategy.Parameters.dMaxCornerRadius * 2, dFaceWidth)
+   elseif Proc.Topology.sName == 'Groove-3-Through' then
+      local dFaceWidth = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
+      ToolSearchParameters.sType = 'MILL_NOTIP'
+      ToolSearchParameters.dMaxToolDiameter = dFaceWidth
+   elseif Proc.Topology.sName == 'Groove-3-Blind' then
+      ToolSearchParameters.sType = 'MILL_NOTIP'
+      ToolSearchParameters.dMaxToolDiameter = Strategy.Parameters.dMaxCornerRadius * 2
+   elseif Proc.Topology.sName == 'Rabbet-2-Through' then
+      ToolSearchParameters.sType = 'MILL_NOTIP'
+      ToolSearchParameters.dMaxToolDiameter = 9999
+   else
+      return nil
+   end
+
+   --  ===== RICERCA UTENSILE =====
+   -- cerco utensile per lavorare faccia Bottom
+   Milling.bIsApplicable = false
+   if Proc.Topology.sName ~= 'Tunnel-4-Through' then
+      ToolSearchParameters.dElevation = Proc.MainFaces.BottomFaces[1].dElevation
+      ToolSearchParameters.vtToolDirection = Proc.MainFaces.BottomFaces[1].vtN
+      Milling.idFaceToMachine = Proc.MainFaces.BottomFaces[1].id
+      Milling.idProc = Proc.id
+      Milling.vtFaceNormal = Proc.MainFaces.BottomFaces[1].vtN
+      Milling.dElevation = Proc.MainFaces.BottomFaces[1].dElevation
+      Milling.ToolInfo = {}
+      Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
+      if Milling.ToolInfo.nToolIndex then
+         -- se utensile scelto è su aggregato, ricalcolo la qualità
+         if TOOLS[Milling.ToolInfo.nToolIndex].SetupInfo.bToolOnAggregate then
+            Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'MillOnAggregate')
+         end
+         Milling.bIsApplicable = true
+         local ParametersMRR = {}
+         ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
+         Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+      end
+   end
+   table.insert( Machining, Milling)
+
+   -- caso speciale 'Rabbet-2-Through' seconda faccia principale
+   Milling = {}
+   Milling.bIsApplicable = false
+   if Proc.Topology.sName == 'Rabbet-2-Through' then
+      ToolSearchParameters.dElevation = Proc.MainFaces.LongFaces[1].dElevation
+      ToolSearchParameters.vtToolDirection = Proc.MainFaces.LongFaces[1].vtN
+      Milling.vtFaceNormal = Proc.MainFaces.LongFaces[1].vtN
+      Milling.idFaceToMachine = Proc.MainFaces.LongFaces[1].id
+      Milling.idProc = Proc.id
+      Milling.dElevation = Proc.MainFaces.LongFaces[1].dElevation
+      Milling.ToolInfo = {}
+      Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
+      if Milling.ToolInfo.nToolIndex then
+         Milling.bIsApplicable = true
+         local ParametersMRR = {}
+         ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
+         Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+      end
+   end
+   table.insert( Machining, Milling)
+
+   -- cerco utensile per lavorare di fianco 1
+   Milling = {}
+   Milling.bIsApplicable = false
+   if Proc.Topology.sName ~= 'Pocket-5-Blind' then
+      if Proc.Topology.sName ==  'Groove-4-Blind' then
+         ToolSearchParameters.dElevation = Proc.MainFaces.BottomFaces[2].dElevation
+         ToolSearchParameters.vtToolDirection = Proc.MainFaces.BottomFaces[2].vtN
+         Milling.vtFaceNormal = Proc.MainFaces.BottomFaces[2].vtN
+         Milling.idFaceToMachine = Proc.MainFaces.BottomFaces[2].id
+         Milling.idProc = Proc.id
+         Milling.dElevation = Proc.MainFaces.BottomFaces[2].dElevation
+      elseif Proc.Topology.sName ==  'Groove-3-Blind' then
+         ToolSearchParameters.dElevation = Proc.MainFaces.LongFaces[1].dElevation
+         ToolSearchParameters.vtToolDirection = Proc.MainFaces.LongFaces[1].vtN
+         Milling.vtFaceNormal = Proc.MainFaces.LongFaces[1].vtN
+         Milling.idFaceToMachine = Proc.MainFaces.LongFaces[1].id
+         Milling.idProc = Proc.id
+         Milling.dElevation = Proc.MainFaces.LongFaces[1].dElevation
+      else -- 'Tunnel-4-Through', 'Groove-3-Through', 'Rabbet-2-Through'
+         -- se lavoro di fianco, devo comunque rispettare il raggio massimo
+         ToolSearchParameters.dMaxToolDiameter = min( ToolSearchParameters.dMaxToolDiameter, Strategy.Parameters.dMaxCornerRadius * 2)
+         ToolSearchParameters.dElevation = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP
+         ToolSearchParameters.vtToolDirection = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].vtN
+         Milling.vtFaceNormal = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].vtN
+         Milling.idFaceToMachine = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].id
+         Milling.idProc = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.id
+         Milling.dElevation = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP
+         Milling.bMachAppliedToTunnelFace = true
+      end
+      Milling.ToolInfo = {}
+      Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
+      if Milling.ToolInfo.nToolIndex then
+         Milling.bIsApplicable = true
+         local ParametersMRR = {}
+         ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
+         Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+      end
+   end
+   table.insert( Machining, Milling)
+
+   -- cerco utensile per lavorare di fianco 2
+   Milling = {}
+   Milling.bIsApplicable = false
+   if Proc.Topology.sName ~= 'Pocket-5-Blind' and Proc.Topology.sName ~=  'Groove-4-Blind' then
+      if Proc.MainFaces.TunnelAddedFaces then --  Tunnel-4-Through, Groove-3-Through, Rabbet-2-Through
+         -- se lavoro di fianco, devo comunque rispettare il raggio massimo
+         ToolSearchParameters.dMaxToolDiameter = min( ToolSearchParameters.dMaxToolDiameter, Strategy.Parameters.dMaxCornerRadius * 2)
+         ToolSearchParameters.dElevation = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP
+         ToolSearchParameters.vtToolDirection = -Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].vtN
+         Milling.vtFaceNormal = -Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].vtN
+         Milling.idFaceToMachine = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].id
+         Milling.idProc = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.id
+         Milling.dElevation = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP
+         Milling.bToolInvert = true
+         Milling.bMachAppliedToTunnelFace = true
+      else -- 'Groove-3-Blind'
+         ToolSearchParameters.dElevation = Proc.MainFaces.SideFaces[1].dElevation
+         ToolSearchParameters.vtToolDirection = Proc.MainFaces.SideFaces[1].vtN
+         Milling.vtFaceNormal = Proc.MainFaces.SideFaces[1].vtN
+         Milling.idFaceToMachine = Proc.MainFaces.SideFaces[1].id
+         Milling.idProc = Proc.id
+         Milling.dElevation = Proc.MainFaces.SideFaces[1].dElevation
+      end
+      Milling.ToolInfo = {}
+      Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
+      if Milling.ToolInfo.nToolIndex then
+         Milling.bIsApplicable = true
+         local ParametersMRR = {}
+         ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
+         Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+      end
+   end
+   table.insert( Machining, Milling)
+
+   --  ===== SCELTA LAVORAZIONI =====
+   -- se bottom completa tutto
+   if Machining[1].bIsApplicable and Machining[1].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
+      Machining.sTypeMachining = 'Bottom'
+      Strategy.Result.sStatus = 'Completed'
+      Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
+      Strategy.Result.dMRR = Machining[1].dMRR
+      Machining[1].ToolInfo.dResidualDepth = 0
+      Machining[2].bIsApplicable = false
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining
+   -- caso speciale 'Rabbet-2-Through' che ha la sweconda faccia come se fosse una seconda bottom
+   elseif Proc.Topology.sName == 'Rabbet-2-Through' and Machining[2].bIsApplicable and Machining[2].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
+      Machining.sTypeMachining = 'Bottom2'
+      Strategy.Result.sStatus = 'Completed'
+      Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
+      Strategy.Result.dMRR = Machining[2].dMRR
+      Machining[2].ToolInfo.dResidualDepth = 0
+      Machining[1].bIsApplicable = false
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining
+   -- se la 3 completa tutto
+   elseif Machining[3].bIsApplicable and Machining[3].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
+      Machining.sTypeMachining = 'Side1'
+      Strategy.Result.sStatus = 'Completed'
+      Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
+      Strategy.Result.dMRR = Machining[3].dMRR
+      if Proc.MainFaces.TunnelAddedFaces then
+         Machining[3].ToolInfo.dResidualDepth = -( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP)
+      else
+         Machining[3].ToolInfo.dResidualDepth = 0
+      end
+      Machining[1].bIsApplicable = false
+      Machining[2].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining
+   -- se la 4 completa tutto
+   elseif Machining[4].bIsApplicable and Machining[4].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
+      Machining.sTypeMachining = 'Side2'
+      Strategy.Result.sStatus = 'Completed'
+      Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
+      Strategy.Result.dMRR = Machining[4].dMRR
+      if Proc.MainFaces.TunnelAddedFaces then
+         Machining[4].ToolInfo.dResidualDepth = -( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP)
+      else
+         Machining[4].ToolInfo.dResidualDepth = 0
+      end
+      Machining[1].bIsApplicable = false
+      Machining[2].bIsApplicable = false
+      Machining[3].bIsApplicable = false
+      return Machining
+   -- se tunnel 2+3 completa tutto
+   elseif Proc.MainFaces.TunnelAddedFaces and Machining[3].bIsApplicable and Machining[4].bIsApplicable and
+      Machining[3].ToolInfo.dResidualDepth + Machining[4].ToolInfo.dResidualDepth < (Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP then
+      Machining.sTypeMachining = 'Side1-Side2'
+      Strategy.Result.sStatus = 'Completed'
+      Machining[3].ToolInfo.dResidualDepth = Machining[3].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation
+      Machining[4].ToolInfo.dResidualDepth = -Machining[3].ToolInfo.dResidualDepth - BeamData.MILL_OVERLAP
+      Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
+      Strategy.Result.dMRR = ( Machining[3].dMRR + Machining[4].dMRR) / 2
+      Machining[1].bIsApplicable = false
+      Machining[2].bIsApplicable = false
+      return Machining
+   end
+
+   Strategy.Result.sStatus = 'Not-Completed'
+   Strategy.Result.dMRR = 0
+   if Machining[1].bIsApplicable then
+      Machining.sTypeMachining = 'Bottom'
+      Strategy.Result.dMRR = Machining[1].dMRR
+   end
+   if Machining[2].bIsApplicable then
+      Machining.sTypeMachining = EgtIf( Machining.sTypeMachining == 'None', 'Bottom2', Machining.sTypeMachining .. '-Bottom2')
+      Strategy.Result.dMRR = ( Strategy.Result.dMRR + Machining[2].dMRR) / EgtIf( Strategy.Result.dMRR == 0, 1, 2)
+   end
+   if Machining[3].bIsApplicable then
+      if Proc.MainFaces.TunnelAddedFaces then
+         Machining[3].ToolInfo.dResidualDepth = Machining[3].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP
+      end
+      Machining.sTypeMachining = EgtIf( Machining.sTypeMachining == 'None', 'Side1', Machining.sTypeMachining .. '-Side1')
+      Strategy.Result.dMRR = ( Strategy.Result.dMRR + Machining[3].dMRR) / EgtIf( Strategy.Result.dMRR == 0, 1, 2)
+   end
+   if Machining[4].bIsApplicable then
+      if Proc.MainFaces.TunnelAddedFaces then
+         Machining[4].ToolInfo.dResidualDepth = Machining[4].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP
+      end
+      Machining.sTypeMachining = EgtIf( Machining.sTypeMachining == 'None', 'Side2', Machining.sTypeMachining .. '-Side2')
+      Strategy.Result.dMRR = ( Strategy.Result.dMRR + Machining[4].dMRR) / EgtIf( Strategy.Result.dMRR == 0, 1, 2)
+   end
+
+   local dMachinedPrercentage = CalcMachinedPercentage( Proc, Machining)
+   Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
+   Strategy.Result.sInfo = 'Machining not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
+
+   -- se non ho trovato neanche una lavorazione
+   if Machining.sTypeMachining == 'None' then
+      Strategy.Result.sStatus = 'Not-Applicable'
+      Strategy.Result.nCompletionIndex = 0
+      Strategy.Result.dMRR = 0
+      Strategy.Result.nQuality = 0
+      Strategy.Result.sInfo = 'Mill not found'
+   end
+
+   return Machining
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetSplitSurfaces( Proc, Part)
+   local vAddId = {}
+   local vAddIdTunnel = {}
+   local nAddGrpId = BeamLib.GetAddGroup( Part.id)
+   local nOriginalTmIdTunnel = GDB_ID.NULL
+   if Proc.MainFaces.TunnelAddedFaces then
+      nOriginalTmIdTunnel = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.id
+   end
+
+   -- recupero punti di spezzatura - da destra a sinistra
+   local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
+
+   if #FeatureSplittingPoints == 0 then
+      local nAddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
+      local nAddIdTunnel = EgtCopyGlob( nOriginalTmIdTunnel, nAddGrpId) or GDB_ID.NULL
+      table.insert( vAddId, nAddId)
+      table.insert( vAddIdTunnel, nAddIdTunnel)
+   else
+      for i = 1, #FeatureSplittingPoints do
+         local nAddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
+         local nAddIdTunnel = EgtCopyGlob( nOriginalTmIdTunnel, nAddGrpId) or GDB_ID.NULL
+         if i == 1 then
+            -- prima superficie, va tagliata solo a sinistra
+            local ptSplit = FeatureSplittingPoints[i] + Vector3d( -BeamData.MILL_OVERLAP / 2, 0, 0)
+            EgtCutSurfTmPlane( nAddId, ptSplit, -X_AX(), true, GDB_RT.GLOB)
+            EgtCutSurfTmPlane( nAddIdTunnel, ptSplit, -X_AX(), true, GDB_RT.GLOB)
+         else
+            -- taglio della superficie corrente - lato sinistro
+            local ptSplit = FeatureSplittingPoints[i] + Vector3d( -BeamData.MILL_OVERLAP / 2, 0, 0)
+            EgtCutSurfTmPlane( nAddId, ptSplit, -X_AX(), true, GDB_RT.GLOB)
+            EgtCutSurfTmPlane( nAddIdTunnel, ptSplit, -X_AX(), true, GDB_RT.GLOB)
+            -- taglio della superficie corrente - lato destro
+            ptSplit = FeatureSplittingPoints[i - 1] + Vector3d( BeamData.MILL_OVERLAP / 2, 0, 0)
+            EgtCutSurfTmPlane( nAddId, ptSplit, X_AX(), true, GDB_RT.GLOB)
+            EgtCutSurfTmPlane( nAddIdTunnel, ptSplit, X_AX(), true, GDB_RT.GLOB)
+         end
+         table.insert( vAddId, nAddId)
+         table.insert( vAddIdTunnel, nAddIdTunnel)
+      end
+      -- taglio ultima superficie, va tagliata solo a destra
+      local nAddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
+      local nAddIdTunnel = EgtCopyGlob( nOriginalTmIdTunnel, nAddGrpId) or GDB_ID.NULL
+      local ptSplit = FeatureSplittingPoints[#FeatureSplittingPoints] + Vector3d( BeamData.MILL_OVERLAP / 2, 0, 0)
+      EgtCutSurfTmPlane( nAddId, ptSplit, X_AX(), true, GDB_RT.GLOB)
+      EgtCutSurfTmPlane( nAddIdTunnel, ptSplit, X_AX(), true, GDB_RT.GLOB)
+      table.insert( vAddId, nAddId)
+      table.insert( vAddIdTunnel, nAddIdTunnel)
+   end
+
+   return vAddId, vAddIdTunnel
+end
+
+-------------------------------------------------------------------------------------------------------------
+function STR0002.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( 'STR0002\\STR0002Config')
+   Strategy.sName = StrategyLib.Config.sStrategyId
+   CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
+   Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
+   Strategy.Machining = {}
+   Strategy.Result = {}
+
+   if not IsTopologyOk( Proc) then
+      local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. StrategyLib.Config.sStrategyId .. ' not implemented'
+      EgtOutLog( sErr)
+      Strategy.Result.sStatus = 'Not-Applicable'
+      Strategy.Result.nCompletionIndex = 0
+      Strategy.Result.dMRR = 0
+      Strategy.Result.nQuality = 0
+      Strategy.Result.sInfo = sErr
+      return false, Strategy.Result
+   end
+
+   local bAreAllMachiningsAdded = true
+   local ToolInfo = {}
+   local Pocketing = {}
+
+   Strategy.Machining = GetBestPocketingStrategy( Proc)
+
+   if bAddMachining and Strategy.Result.sStatus ~= 'Not-Applicable' then
+      local vAddId = {}
+      local vAddIdTunnel = {}
+      
+      -- recupero superficie, se necessario trimmata sugli spezzoni 
+      vAddId, vAddIdTunnel = GetSplitSurfaces( Proc, Part)
+
+      -- si applicano le lavorazioni
+      for i = 1, #vAddId do
+         for j = 1, #Strategy.Machining do
+            if Strategy.Machining[j].bIsApplicable then
+               Pocketing = {}
+               Pocketing.Steps = {}
+               Pocketing.LeadIn = {}
+               Pocketing.nType = MCH_OY.POCKETING
+               Pocketing.nSubType = EgtIf( Proc.Topology.sName == 'Pocket-5-Blind', MCH_POCK_SUB.SPIRALOUT, MCH_POCK_SUB.SPIRALIN)
+               Pocketing.LeadIn.nType = MCH_POCK_LI.ZIGZAG
+               Pocketing.Steps.dStep = TOOLS[Strategy.Machining[j].ToolInfo.nToolIndex].dStep
+               Pocketing.Steps.dSideStep = TOOLS[Strategy.Machining[j].ToolInfo.nToolIndex].dSideStep
+               Pocketing.nToolIndex = Strategy.Machining[j].ToolInfo.nToolIndex
+               Pocketing.LeadIn.dTangentDistance = TOOLS[Strategy.Machining[j].ToolInfo.nToolIndex].dDiameter/2
+               Pocketing.LeadIn.dElevation = TOOLS[Strategy.Machining[j].ToolInfo.nToolIndex].dDiameter/2
+               Pocketing.sDepth = -Strategy.Machining[j].ToolInfo.dResidualDepth
+               -- il quarto ciclo è la lavorazione opposta sulla faccia Tunnel
+               if Strategy.Machining[j].bToolInvert then
+                  Pocketing.bToolInvert = true
+               end
+               -- se ho una sola trimesh, sto lavorando la Proc direttamente e non ho spezzato. Applico direttamente alla geometria calcolata prima
+               if #vAddId == 1 then
+                  Pocketing.Geometry = {{ Strategy.Machining[j].idProc, Strategy.Machining[j].idFaceToMachine}}
+                  Pocketing.vtToolDirection = Proc.Faces[ Strategy.Machining[j].idFaceToMachine + 1].vtN
+                  if Pocketing.bToolInvert then
+                     Pocketing.vtToolDirection = -Pocketing.vtToolDirection
+                  end
+                  -- TODO controllare parametro danneggiamento ammesso per decidere se spostare dopo taglio seprazione
+                  -- se è aperta sulla coda, dico che deve essere fatta dopo la separazione
+                  if Proc.AffectedFaces.bLeft then
+                     Pocketing.sStage = 'AfterTail'
+                  end
+                  bAreAllMachiningsAdded = MachiningLib.AddNewMachining( Proc, Pocketing)
+               else
+                  -- TODO controllare parametro danneggiamento ammesso per decidere se spostare dopo taglio seprazione
+                  -- se è aperta sulla coda, dico che deve essere fatta dopo la separazione
+                  if Proc.AffectedFaces.bLeft and i == #vAddId then
+                     Pocketing.sStage = 'AfterTail'
+                  end
+                  for k = 1, Proc.nFct do
+                     local vtNSplitFace
+                     local nIdTm = EgtIf( Strategy.Machining[j].bMachAppliedToTunnelFace, vAddIdTunnel[i], vAddId[i])
+                     Pocketing.ptCenter, vtNSplitFace =  EgtSurfTmFacetCenter( nIdTm, k - 1, GDB_ID.ROOT)
+                     Pocketing.vtToolDirection = vtNSplitFace
+                     if Pocketing.bToolInvert then
+                        Pocketing.vtToolDirection = -Pocketing.vtToolDirection
+                     end
+                     if vtNSplitFace and AreSameVectorApprox( vtNSplitFace * EgtIf( Pocketing.bToolInvert, -1, 1), Strategy.Machining[j].vtFaceNormal) then
+                        Pocketing.Geometry = {{ nIdTm, k - 1}}
+                        bAreAllMachiningsAdded = bAreAllMachiningsAdded and MachiningLib.AddNewMachining( Proc, Pocketing)
+                        break
+                     end
+                  end
+               end
+            end
+         end
+      end
+   else
+      bAreAllMachiningsAdded = false
+   end
+
+   return bAreAllMachiningsAdded, Strategy.Result
+end
+
+-------------------------------------------------------------------------------------------------------------
+
+ return STR0002

Strategies/Standard/STR0002/STR0002Config.lua

@@ -0,0 +1,11 @@
+-- Parametri configurabili da cliente per strategia: STR0002
+
+local STR0002Data = {
+   sStrategyId = 'STR0002',
+   Parameters = {
+      { sName = 'dMaxCornerRadius', sNameNge = 'MAX_CORNER_RADIUS', sValue = '15', sDescriptionShort = 'Max radius left on corners', sDescriptionLong = 'Radius-limit left by the tool at each corner of the feature', sType = 'd', sMinUserLevel = '1', sMessageId = ''},
+      { sName = 'bAntiSplint', sNameNge = 'ANTISPLINT', sValue = 'false', sDescriptionShort = 'Use Anti-Splint strategy', sDescriptionLong = 'The strategy will apply blade cuts on corner to avoid wood splint', sType = 'b', sMinUserLevel = '1', sMessageId = ''}
+   }
+}
+
+return STR0002Data

Strategies/Standard/STR0003/STR0003.lua

@@ -0,0 +1,585 @@
+-- Strategia: STR0003
+-- Descrizione 
+-- Lama + motosega per slot
+-- Feature: tipo lapjoint
+
+-------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------
+-- TODO
+-- 1 - Gestire lavorazioni da sotto
+-- 2 - Inserire antischeggia (fresa o lama)
+-- 3 - Smusso a V
+-- 4 - Implementare lavorazione di geometrie inclinate
+-------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------
+
+-- 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')
+local FaceByChainsaw = require( 'FACEBYCHAINSAW')
+
+-- 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
+
+
+-- TODO si può unificare con eguale funzione in STR0004
+local function SortMachiningsBySegment( MachiningA, MachiningB)
+   if MachiningA.nFeatureSegment > MachiningB.nFeatureSegment then
+      return false
+   elseif MachiningB.nFeatureSegment > MachiningA.nFeatureSegment then
+      return true
+   else
+      if TOOLS[ MachiningA.nToolIndex].sFamily == 'SAWBLADE' and TOOLS[ MachiningB.nToolIndex].sFamily == 'MORTISE' then
+         return true
+      elseif TOOLS[ MachiningA.nToolIndex].sFamily == 'MORTISE' and TOOLS[ MachiningB.nToolIndex].sFamily == 'SAWBLADE' then
+         return false
+      else
+         if MachiningA.sEdgeType == 'Side' and MachiningB.sEdgeType ~= 'Side' then
+            return true
+         elseif MachiningB.sEdgeType == 'Side' and MachiningA.sEdgeType ~= 'Side' then
+            return false
+         end
+      end
+   end
+end
+
+
+local function SortMachiningsByTool( MachiningA, MachiningB)
+   if TOOLS[ MachiningA.nToolIndex].sFamily == 'SAWBLADE' and TOOLS[ MachiningB.nToolIndex].sFamily == 'MORTISE' then
+      return true
+   elseif TOOLS[ MachiningA.nToolIndex].sFamily == 'MORTISE' and TOOLS[ MachiningB.nToolIndex].sFamily == 'SAWBLADE' then
+      return false
+   else
+      if MachiningA.nFeatureSegment > MachiningB.nFeatureSegment then
+         return false
+      elseif MachiningB.nFeatureSegment > MachiningA.nFeatureSegment then
+         return true
+      else
+         if MachiningA.sEdgeType == 'Side' and MachiningB.sEdgeType ~= 'Side' then
+            return true
+         elseif MachiningB.sEdgeType == 'Side' and MachiningA.sEdgeType ~= 'Side' then
+            return false
+         end
+      end
+   end
+end
+
+
+local function MergeResults( Result)
+   local SortedResult = {}
+
+   for i = 1, #Result.Side do
+      if Result.Side[i].bIsApplicable then
+         table.insert( SortedResult, Result.Side[i])
+      end
+   end
+   for i = 1, #Result.Bottom do
+      if Result.Bottom[i].bIsApplicable then
+         table.insert( SortedResult, Result.Bottom[i])
+      end
+   end
+   for i = 1, #Result.Opposite do
+      if Result.Opposite[i].bIsApplicable then
+         table.insert( SortedResult, Result.Opposite[i])
+      end
+   end
+
+   return SortedResult
+end
+
+
+local function AddResult( Machining, Result)
+   table.insert( Result, {})
+   if not Result.Bottom then
+      Result.Bottom = {}
+   end
+   if not Result.Side then
+      Result.Side = {}
+   end
+   if not Result.Opposite then
+      Result.Opposite = {}
+   end
+   if Machining.sEdgeType == 'Bottom' then
+      table.insert( Result.Bottom, Machining)
+   elseif Machining.sEdgeType == 'Side' then
+      table.insert( Result.Side, Machining)
+   elseif Machining.sEdgeType == 'Opposite' then
+      table.insert( Result.Opposite, Machining)
+   else
+      error('AddResult : unknown edge type')
+   end
+
+   return Result
+end
+
+
+local function AddMachinings( Proc, Machinings, bAddMachining)
+   local nIsApplicableCount = 0
+   local bAreAllMachiningsAdded = true
+
+   for i = 1, #Machinings do
+      if Machinings[i].bIsApplicable then
+         nIsApplicableCount = nIsApplicableCount + 1
+         if bAddMachining then
+            local bIsMachiningAdded
+            if TOOLS[ Machinings[i].nToolIndex].sFamily == 'SAWBLADE' then
+               Blade.AddMachiningAllSteps( Proc, Machinings[i])
+            elseif TOOLS[ Machinings[i].nToolIndex].sFamily == 'MORTISE' then
+               Chainsaw.AddMachiningAllSteps( Proc, Machinings[i])
+            else
+               error( 'AddMachinings : tool type not supported')
+            end
+            if not bIsMachiningAdded then
+               bAreAllMachiningsAdded = false
+            end
+         end
+         Strategy.Result.sInfo = Strategy.Result.sInfo .. '\n' .. Machinings[i].sMessage
+      end
+   end
+
+   return bAreAllMachiningsAdded, nIsApplicableCount
+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 = 1, Cutting.HorizontalSteps.nCount do
+      AuxiliaryData.Clones[i] = {}
+      AuxiliaryData.Clones[i].LeadIn = {}
+      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 - AuxiliaryData.Clones[i].dRadialOffset + dOriginalRadialOffset
+      AuxiliaryData.Clones[i].LeadOut.dPerpDistance = dOriginalLeadOutPerpDistance - AuxiliaryData.Clones[i].dRadialOffset + dOriginalRadialOffset
+   end
+   bMachiningAdded = MachiningLib.AddNewMachining( Proc, Cutting, AuxiliaryData)
+
+   return bMachiningAdded
+end
+
+
+function Chainsaw.AddResult( Mortising)
+   AddResult( Mortising, Chainsaw.Result)
+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)
+   -- 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
+
+   local dExtendAfterTail = Strategy.Parameters.dExtendAfterTail or max( Part.dDistanceToNextPiece - BeamData.CUT_EXTRA, 0)
+   if MachiningLib.CanExtendAfterTail( Strategy.Parameters.sCanDamageNextPiece, Part) then
+      dExtendAfterTail = 10000
+   end
+
+   -- eventuali punti di spezzatura
+   local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
+   local bIsSplitFeature = false
+   if #FeatureSplittingPoints > 0 then
+      bIsSplitFeature = true
+   end
+
+   -- altezza tasca
+   local dPocketHeight = 0
+   if Proc.Topology.sFamily == 'Tunnel' then
+      dPocketHeight = Proc.MainFaces.SideFaces[1].MainEdges.OppositeEdges[1].dLength
+   else
+      dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
+   end
+
+   -- lama - calcolo lavorazioni
+   local Cutting = {}
+   local OptionalParameters = { bForceLongcutBlade = Strategy.Parameters.bForceLongcutBlade, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
+   if Proc.Topology.sFamily == 'Tunnel' then
+      OptionalParameters.bOppositeToolDirection = true
+      Cutting = FaceByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+   else
+      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 = 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
+      if Blade.Result.Bottom[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
+            OptionalParameters.bOppositeToolDirection = true
+            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 = 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
+      elseif #( Proc.MainFaces.SideFaces) == 0 then
+         Strategy.Parameters.bFinishWithChainSaw = false
+         Strategy.Parameters.bNotCompleteWithBladeRadius = false
+      end
+   end
+   -- lama - lavorazioni raggruppate in unica lista
+   Blade.Result.Sorted = MergeResults( Blade.Result)
+   -- lama - aggiunta eventuali lavorazioni splittate
+   if bIsSplitFeature then
+      Blade.Result.Sorted = MachiningLib.GetSplitMachinings( Blade.Result.Sorted, FeatureSplittingPoints, Part)
+   end
+   -- lama - nessuna lavorazione successiva - aggiunta lavorazioni e calcolo risultati
+   -- TODO bisogna uscire se la lama non può fare alcuna lavorazione; non ha senso che STR0003 lama+catena sia scelta se la lama non può lavorare, in quel caso deve essere scelta la STR0004 solo catena
+   if not Strategy.Parameters.bFinishWithChainSaw then
+      -- ordinamento
+      if Strategy.Parameters.bSortBySegment then
+         table.sort( Blade.Result.Sorted, SortMachiningsBySegment)
+      else
+         table.sort( Blade.Result.Sorted, SortMachiningsByTool)
+      end
+      -- aggiunta lavorazioni
+      local nIsApplicableCount = 0
+      local bAreAllMachiningsAdded = true
+      local dFinalCompletionPercentage = 100
+      bAreAllMachiningsAdded, nIsApplicableCount = AddMachinings( Proc, Blade.Result.Sorted, bAddMachining)
+      if nIsApplicableCount > 0 then
+         -- TODO sistemare il calcolo completamento - implementare calcolo area lavorata
+         if not Strategy.Parameters.bNotCompleteWithBladeRadius and Cutting.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 = Cutting.dCompletionPercentage
+         end
+      else
+         Strategy.Result.sStatus = 'Not-Applicable'
+         Strategy.Parameters.bFinishWithChainSaw = false
+      end
+      Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dFinalCompletionPercentage)
+      Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+      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 dMRRBlade = MachiningLib.GetToolMRR( MRRParametersBlade)
+      Strategy.Result.dMRR = dMRRBlade
+
+      return bAreAllMachiningsAdded, Strategy.Result
+   end
+
+   -- sega a catena - calcolo lavorazioni
+   local Mortising = {}
+   OptionalParameters = {}
+   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.Bottom[1].dResidualDepth < 10 * GEO.EPS_SMALL) and
+         ( Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.dLength > 3 * Blade.Result.Bottom[1].dBladeMarkLength - 10 * GEO.EPS_SMALL) then
+
+         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 = 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 = 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 = 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
+      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.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 = 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 = FaceByChainsaw.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.Side > 0 then
+               dBladeResidualDepth = Blade.Result.Side[1].dResidualDepth
+            else
+               dBladeResidualDepth = Blade.Result.Bottom[1].dResidualDepth
+            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 = 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 = FaceByChainsaw.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.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 = 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
+            -- si lavora solamente l'impronta lama sul fondo
+            if ( Blade.Result.Side[1].dResidualDepth < 10 * GEO.EPS_SMALL and Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1].dLength > 3 * Blade.Result.Side[1].dBladeMarkLength - 10 * GEO.EPS_SMALL) and
+               ( 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 = 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 = 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 = 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
+                     Chainsaw.Result.Bottom[1].bIsApplicable = false
+                  end
+               end
+            -- 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 = 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 = 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 = 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
+                     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.Opposite[1].dResidualDepth < 10 * GEO.EPS_SMALL and Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1].dLength > 3 * Blade.Result.Opposite[1].dBladeMarkLength - 10 * GEO.EPS_SMALL) and
+         ( 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
+            Chainsaw.AddResult( Mortising)
+         end
+      end
+   end
+   -- sega a catena - lavorazioni raggruppate in unica lista
+   Chainsaw.Result.Sorted = MergeResults( Chainsaw.Result)
+   -- sega a catena - aggiunta eventuali lavorazioni splittate
+   if bIsSplitFeature then
+      Chainsaw.Result.Sorted = MachiningLib.GetSplitMachinings( Chainsaw.Result.Sorted, FeatureSplittingPoints, Part)
+   end
+
+   -- tutte le lavorazioni di tutti gli utensili in unica lista
+   local Result = {}
+   for i = 1, #Blade.Result.Sorted do
+       table.insert( Result, Blade.Result.Sorted[i])
+   end
+   for i = 1, #Chainsaw.Result.Sorted do
+      table.insert( Result, Chainsaw.Result.Sorted[i])
+   end
+   -- ordinamento
+   if Strategy.Parameters.bSortBySegment then
+      table.sort( Result, SortMachiningsBySegment)
+   else
+      table.sort( Result, SortMachiningsByTool)
+   end
+   -- aggiunta lavorazioni per tutti gli utensili
+   local nIsApplicableCount = 0
+   local bAreAllMachiningsAdded = true
+   local dFinalCompletionPercentage = 100
+   bAreAllMachiningsAdded, nIsApplicableCount = AddMachinings( Proc, Result, bAddMachining)
+   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
+   -- calcolo risultati
+   Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dFinalCompletionPercentage)
+   Strategy.Result.nQuality = FeatureLib.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) / 2
+
+   return bAreAllMachiningsAdded, Strategy.Result
+end
+
+-------------------------------------------------------------------------------------------------------------
+
+ return STR0003

Strategies/Standard/STR0003/STR0003Config.lua

@@ -0,0 +1,19 @@
+-- Parametri configurabili da cliente per strategia: STR0003
+
+local STR0003Data = {
+   sStrategyId = 'STR0003',
+   Parameters = {
+      { sName = 'bFinishWithChainSaw', sNameNge = 'ALLOW_FINISH_CHAINSAW', sValue = 'true', sDescriptionShort = 'Finish with chainsaw if needed', sDescriptionLong = 'Finish with chainsaw if needed', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'dExtendAfterTail', sNameNge = 'EXTEND_AFTER_TAIL', sValue = 'false', sDescriptionShort = '', sDescriptionLong = '', sType = 'd', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'bForceLongcutBlade', sNameNge = 'USE_LONGCUT_BLADE', sValue = 'false', sDescriptionShort = 'Force ripping blade', sDescriptionLong = 'Force the use of ripping blade, designed for cuts parallel to the grain', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'bNotCompleteWithBladeRadius', sNameNge = 'NOT_COMPLETE_WITH_BLADE_RADIUS', sValue = 'true', sDescriptionShort = '', sDescriptionLong = '', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'bUseZigZagMortising', sNameNge = 'USE_ZIGZAG_CHAINSAW', sValue = 'false', sDescriptionShort = '', sDescriptionLong = '', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'bSortBySegment', sNameNge = 'SORT_BY_SEGMENT', sValue = 'true', sDescriptionShort = '', sDescriptionLong = '', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'sCanDamageNextPiece', sNameNge = 'DAMAGE_NEXT_PIECE', sValue = 'NEVER', sType = 'combo', sMinUserLevel = '1',
+         Choices = { sValue = 'NEVER', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''},
+                   { sValue = 'ONLY_IF_RAWPART', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''},
+                   { sValue = 'ALWAYS', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''}}
+   }
+}
+
+return STR0003Data

Strategies/Standard/STR0004/STR0004.lua

@@ -0,0 +1,311 @@
+-- Strategia: STR0004
+-- Descrizione 
+-- motosega per slot
+-- Feature: tipo lapjoint
+
+-------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------
+-- TODO
+-- 1 - Inserire antischeggia (fresa o lama)
+-- 2 - Smusso a V
+-- 3 - Implementare lavorazione di geometrie inclinate
+-- 4 - Gestire lavorazioni da sotto (ove possibile, in generale la motosega non lavora da sotto)
+-------------------------------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------------------------
+
+-- carico librerie
+local BeamLib = require( 'BeamLib')
+local BeamData = require( 'BeamData')
+local MachiningLib = require( 'MachiningLib')
+local FeatureLib = require( 'FeatureLib')
+-- strategie di base
+local FaceByChainsaw = require( 'FACEBYCHAINSAW')
+
+-- Tabella per definizione modulo
+local STR0004 = {}
+local Strategy = {}
+local Chainsaw = {}
+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
+
+
+-- TODO si può unificare con Sorting generale
+local function SortMachiningsBySegment( MachiningA, MachiningB)
+   if MachiningA.nFeatureSegment > MachiningB.nFeatureSegment then
+      return false
+   elseif MachiningB.nFeatureSegment > MachiningA.nFeatureSegment then
+      return true
+   else
+      if MachiningA.sEdgeType == 'Side' and MachiningB.sEdgeType ~= 'Side' then
+         return true
+      elseif MachiningB.sEdgeType == 'Side' and MachiningA.sEdgeType ~= 'Side' then
+         return false
+      end
+   end
+end
+
+
+local function AddResult( Machining, Result)
+   table.insert( Result, {})
+   if not Result.Bottom then
+      Result.Bottom = {}
+   end
+   if not Result.Side then
+      Result.Side = {}
+   end
+   if not Result.Opposite then
+      Result.Opposite = {}
+   end
+   if Machining.sEdgeType == 'Bottom' then
+      table.insert( Result.Bottom, Machining)
+   elseif Machining.sEdgeType == 'Side' then
+      table.insert( Result.Side, Machining)
+   elseif Machining.sEdgeType == 'Opposite' then
+      table.insert( Result.Opposite, Machining)
+   else
+      error('AddResult : unknown edge type')
+   end
+
+   return Result
+end
+
+
+function Chainsaw.AddResult( Mortising)
+   AddResult( Mortising, Chainsaw.Result)
+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 STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
+   -- carico parametri da default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
+   local StrategyLib = {}
+   StrategyLib.Config = require( 'STR0004\\STR0004Config')
+   Strategy.sName = StrategyLib.Config.sStrategyId
+   CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
+   Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
+   Strategy.Result = {}
+   Strategy.Result.sInfo = ''
+   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)
+   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
+
+   -- calcolo 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
+   end
+
+   -- eventuali punti di spezzatura
+   local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
+   local bIsSplitFeature = false
+   if #FeatureSplittingPoints > 0 then
+      bIsSplitFeature = true
+   end
+
+   -- altezza tasca
+   local dPocketHeight = 0
+   if Proc.Topology.sFamily == 'Tunnel' then
+      dPocketHeight = Proc.MainFaces.SideFaces[1].MainEdges.OppositeEdges[1].dLength
+   else
+      dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
+   end
+
+   -- calcolo lavorazioni
+   local Mortising = {}
+   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 = 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 = 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 = 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 = 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 = 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 = 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 = 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
+               Chainsaw.Result.Bottom[1].bIsApplicable = false
+            end
+         end
+      end
+   elseif Proc.Topology.sName == 'Tunnel-4-Through' then
+      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
+      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}
+         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}
+         FaceByChainsaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
+         Chainsaw.AddResult( Mortising)
+      end
+   end
+
+   -- lavorazioni raggruppate in unica lista
+   Chainsaw.Result.Sorted = {}
+   for i = 1, #Chainsaw.Result.Side do
+      if Chainsaw.Result.Side[i].bIsApplicable then
+         table.insert( Chainsaw.Result.Sorted, Chainsaw.Result.Side[i])
+      end
+   end
+   for i = 1, #Chainsaw.Result.Bottom do
+      if Chainsaw.Result.Bottom[i].bIsApplicable then
+         table.insert( Chainsaw.Result.Sorted, Chainsaw.Result.Bottom[i])
+      end
+   end
+   for i = 1, #Chainsaw.Result.Opposite do
+      if Chainsaw.Result.Opposite[i].bIsApplicable then
+         table.insert( Chainsaw.Result.Sorted, Chainsaw.Result.Opposite[i])
+      end
+   end
+
+   -- aggiunta eventuali lavorazioni splittate
+   if bIsSplitFeature then
+      Chainsaw.Result.Sorted = MachiningLib.GetSplitMachinings( Chainsaw.Result.Sorted, FeatureSplittingPoints, Part)
+   end
+
+   -- ordinamento
+   -- TODO aggiungere ordinamento per utensile
+   table.sort( Chainsaw.Result.Sorted, SortMachiningsBySegment)
+
+   -- aggiunta lavorazioni
+   local nIsApplicableCount = 0
+   local dFinalCompletionPercentage = 100
+   local bAreAllMachiningsAdded = true
+   for i = 1, #Chainsaw.Result.Sorted do
+      if Chainsaw.Result.Sorted[i].bIsApplicable then
+         nIsApplicableCount = nIsApplicableCount + 1
+         if bAddMachining then
+            local bIsMachiningAdded = Chainsaw.AddMachiningAllSteps( Proc, Chainsaw.Result.Sorted[i])
+            if not bIsMachiningAdded then
+               bAreAllMachiningsAdded = false
+            end
+         end
+         Strategy.Result.sInfo = Strategy.Result.sInfo .. '\n' .. Chainsaw.Result.Sorted[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 = FeatureLib.GetFeatureCompletionIndex( dFinalCompletionPercentage)
+   Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Chainsaw')
+   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 dMRRChainsaw = MachiningLib.GetToolMRR( MRRParametersChainsaw)
+   Strategy.Result.dMRR = dMRRChainsaw
+
+   return bAreAllMachiningsAdded, Strategy.Result
+end
+
+-------------------------------------------------------------------------------------------------------------
+
+ return STR0004

Strategies/Standard/STR0004/STR0004Config.lua

@@ -0,0 +1,15 @@
+-- Parametri configurabili da cliente per strategia: STR0004
+
+local STR0004Data = {
+   sStrategyId = 'STR0004',
+   Parameters = {
+      { sName = 'bUseZigZagMortising', sNameNge = 'USE_ZIGZAG_CHAINSAW', sValue = 'false', sDescriptionShort = '', sDescriptionLong = '', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'dExtendAfterTail', sNameNge = 'EXTEND_AFTER_TAIL', sValue = 'false', sDescriptionShort = '', sDescriptionLong = '', sType = 'd', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'sCanDamageNextPiece', sNameNge = 'DAMAGE_NEXT_PIECE', sValue = 'NEVER', sType = 'combo', sMinUserLevel = '1',
+         Choices = { sValue = 'NEVER', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''},
+                   { sValue = 'ONLY_IF_RAWPART', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''},
+                   { sValue = 'ALWAYS', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''}}
+   }
+}
+
+return STR0004Data

Strategies/Standard/STR0005/STR0005.lua

@@ -0,0 +1,238 @@
+-- Strategia: STR0005
+-- Descrizione 
+-- lama per taglio facce con cubetti se necessario
+-- Feature: tagli singoli con eventuali cubetti
+
+-- carico librerie
+local BeamLib = require( 'BeamLib')
+local BeamData = require( 'BeamData')
+local MachiningLib = require( 'MachiningLib')
+local FeatureLib = require( 'FeatureLib')
+-- strategie di base
+local BladeToWaste = require( 'BLADETOWASTE')
+local FaceByBlade = require( 'FACEBYBLADE')
+
+-- Tabella per definizione modulo
+local STR0005 = {}
+local Strategy = {}
+local Blade = {}
+Blade.Result = {}
+
+-------------------------------------------------------------------------------------------------------------
+local function CompareEdges( EdgeA, EdgeB)
+   -- prima i lati orientati lungo X
+   if abs( EdgeA.vtN:getX()) < abs( EdgeB.vtN:getX()) - 10 * GEO.EPS_SMALL then
+      return true
+   elseif abs( EdgeA.vtN:getX()) > abs( EdgeB.vtN:getX()) + 10 * GEO.EPS_SMALL then
+      return false
+   -- se stessa X si preferiscono i lati più in basso
+   else
+      if EdgeA.vtN:getZ() > EdgeB.vtN:getZ() + 10 * GEO.EPS_SMALL then
+         return true
+      elseif EdgeA.vtN:getZ() < EdgeB.vtN:getZ() - 10 * GEO.EPS_SMALL then
+         return false
+      -- se stessa Z si preferiscono i lati verso il fronte della trave
+      else
+         if EdgeA.vtN:getY() > EdgeB.vtN:getY() + 10 * GEO.EPS_SMALL then
+            return true
+         elseif EdgeA.vtN:getY() < EdgeB.vtN:getY() - 10 * GEO.EPS_SMALL then
+            return false
+         else
+            return false
+         end
+      end
+   end
+end
+
+
+local function SortMachiningsBySegment( MachiningA, MachiningB)
+   if MachiningA.nFeatureSegment > MachiningB.nFeatureSegment then
+      return false
+   elseif MachiningB.nFeatureSegment > MachiningA.nFeatureSegment then
+      return true
+   -- se segmento uguale, si minimizzano i cambi di lato
+   else
+      local bIsOddSegment = ( MachiningA.nFeatureSegment % 2 ~= 0)
+      if MachiningA.vtToolDirection:getY() < MachiningB.vtToolDirection:getY() - 10 * GEO.EPS_SMALL then
+         if bIsOddSegment then
+            return true
+         else
+            return false
+         end
+      elseif MachiningA.vtToolDirection:getY() > MachiningB.vtToolDirection:getY() + 10 * GEO.EPS_SMALL then
+         if bIsOddSegment then
+            return false
+         else
+            return true
+         end
+      else
+         return false
+      end
+   end
+end
+
+
+function Blade.AddResult( Cutting)
+   table.insert( Blade.Result, Cutting)
+   
+   return 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 = 1, Cutting.HorizontalSteps.nCount do
+      AuxiliaryData.Clones[i] = {}
+      AuxiliaryData.Clones[i].LeadIn = {}
+      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
+   end
+   bMachiningAdded = MachiningLib.AddNewMachining( Proc, Cutting, AuxiliaryData)
+
+   return bMachiningAdded
+end
+
+
+function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
+   -- carico parametri da default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
+   local StrategyLib = {}
+   StrategyLib.Config = require( 'STR0005\\STR0005Config')
+   Strategy.sName = StrategyLib.Config.sStrategyId
+   CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
+   Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
+   Strategy.Result = {}
+   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
+   end
+
+   local dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail = FeatureLib.GetFeatureMaxNotClampableLengths( Proc, Part)
+   local bLeaveWasteAttached = Strategy.Parameters.sCuttingStrategy == 'LEAVE_WASTE_ATTACHED'
+   local bFeatureHindersClamping = FeatureLib.IsMachiningLong( max( dFeatureMaxNotClampableLengthHead, dFeatureMaxNotClampableLengthTail), Part, { dMaxSegmentLength = BeamData.LONGCUT_ENDLEN})
+   local Cutting = {}
+   local dMRRBlade = 0
+
+   if bFeatureHindersClamping or bLeaveWasteAttached then
+      -- 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
+         table.insert( EdgesSorted, Proc.Faces[1].Edges[i])
+      end
+      table.sort( EdgesSorted, CompareEdges)
+
+      local dDepthToMachine = EdgesSorted[1].dElevation / 2 - Strategy.Parameters.dStripWidth / 2
+
+      -- eventuali punti di spezzatura
+      local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
+      local bIsSplitFeature = false
+      if #FeatureSplittingPoints > 0 then
+         bIsSplitFeature = true
+      end
+
+      -- primo lato
+      local OptionalParameters = { dDepthToMachine = dDepthToMachine, bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail}
+      Cutting1 = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[1], OptionalParameters)
+      Blade.AddResult( Cutting1)
+      -- secondo lato
+      Cutting2 = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[2], OptionalParameters)
+      Blade.AddResult( Cutting2)
+
+      -- lavorazioni raggruppate in unica lista
+      Blade.Result.Sorted = {}
+      for i = 1, #Blade.Result do
+         if Blade.Result[i].bIsApplicable then
+            table.insert( Blade.Result.Sorted, Blade.Result[i])
+         end
+      end
+
+      -- aggiunta eventuali lavorazioni splittate
+      if bIsSplitFeature then
+         Blade.Result.Sorted = MachiningLib.GetSplitMachinings( Blade.Result.Sorted, FeatureSplittingPoints, Part)
+      end
+
+      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
+
+   if #Blade.Result == 0 and not bLeaveWasteAttached then
+      -- BladeToWaste
+   end
+
+    -- aggiunta lavorazioni
+   local nIsApplicableCount = 0
+   local dFinalCompletionPercentage = 100
+   local bAreAllMachiningsAdded = true
+   for i = 1, #Blade.Result.Sorted do
+      if Blade.Result.Sorted[i].bIsApplicable then
+         nIsApplicableCount = nIsApplicableCount + 1
+         if bAddMachining then
+            local bIsMachiningAdded = Blade.AddMachiningAllSteps( Proc, Blade.Result.Sorted[i])
+            if not bIsMachiningAdded then
+               bAreAllMachiningsAdded = false
+            end
+         end
+         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'
+      else
+         Strategy.Result.sStatus = 'Not-Completed'
+         -- TODO al momento si assume che la percentuale di completamento dell'ultima lavorazione sia quella rilevante
+         dFinalCompletionPercentage = Cutting.dCompletionPercentage
+      end
+   else
+      Strategy.Result.sStatus = 'Not-Applicable'
+   end
+   Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dFinalCompletionPercentage)
+   Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+   Strategy.Result.dMRR = dMRRBlade
+
+   return bAreAllMachiningsAdded, Strategy.Result
+end
+
+-------------------------------------------------------------------------------------------------------------
+
+ return STR0005

Strategies/Standard/STR0005/STR0005Config.lua

@@ -0,0 +1,24 @@
+-- Parametri configurabili da cliente per strategia: STR0004
+
+-- TODO - sostituire dMaxWasteVolume con dMaxWasteWeight? Dove prendere la densità del materiale?
+
+local STR0005Data = {
+   sStrategyId = 'STR0005',
+   Parameters = {
+      { sName = 'bForceLongcutBlade', sNameNge = 'USE_LONGCUT_BLADE', sValue = 'false', sDescriptionShort = 'Force ripping blade', sDescriptionLong = 'Force the use of ripping blade, designed for cuts parallel to the grain', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'dExtendAfterTail', sNameNge = 'EXTEND_AFTER_TAIL', sValue = 'false', sDescriptionShort = '', sDescriptionLong = '', sType = 'd', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'sCanDamageNextPiece', sNameNge = 'DAMAGE_NEXT_PIECE', sValue = 'NEVER', sType = 'combo', sMinUserLevel = '1',
+         Choices = { sValue = 'NEVER', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''},
+                   { sValue = 'ONLY_IF_RAWPART', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''},
+                   { sValue = 'ALWAYS', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''}},
+      { sName = 'sCuttingStrategy', sNameNge = 'CUTTING_STRATEGY', sValue = 'AUTO', sType = 'combo', sMinUserLevel = '1',
+         Choices = { sValue = 'AUTO', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''},
+                   { sValue = 'DROP_WHOLE_WASTE', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''},
+                   { sValue = 'LEAVE_WASTE_ATTACHED', sDescriptionShort = '', sDescriptionLong = '', sMessageId = ''}},
+      { sName = 'dMaxWasteLength', sNameNge = 'MAX_WASTE_LENGTH', sValue = '300', sDescriptionShort = '', sDescriptionLong = '', sType = 'd', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'dMaxWasteVolume', sNameNge = 'MAX_WASTE_VOLUME', sValue = '6000000', sDescriptionShort = '', sDescriptionLong = '', sType = 'd', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'dStripWidth', sNameNge = 'STRIP_WIDTH', sValue = '5', sDescriptionShort = '', sDescriptionLong = '', sType = 'd', sMessageId = '', sMinUserLevel = '1'}
+   }
+}
+
+return STR0005Data

Strategies/Standard/TAILCUT/TAILCUT.lua

@@ -0,0 +1,106 @@
+-- Strategia: TAILCUT
+-- Descrizione
+-- Taglio di separazione
+-- Feature: TailCut
+
+-- carico librerie
+local BeamLib = require( 'BeamLib')
+local BeamData = require( 'BeamData')
+local MachiningLib = require( 'MachiningLib')
+local SPLITCUT = require( 'SPLITCUT')
+local DiceCut = require( 'DiceCut')
+
+-- Tabella per definizione modulo
+local TAILCUT = {}
+local Strategy = {}
+
+
+-------------------------------------------------------------------------------------------------------------
+local function MakeChamfer()
+   -- TODO funzionalità da aggiungere
+end
+
+-------------------------------------------------------------------------------------------------------------
+function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
+   local StrategyDefaultParam = {}
+   StrategyDefaultParam.Config = require( 'TAILCUT\\TAILCUTConfig')
+   Strategy.sName = StrategyDefaultParam.Config.sStrategyId
+   CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyDefaultParam.Config.Parameters)
+   Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
+   Strategy.SplitStrategy = {}
+   Strategy.Result = {}
+   Strategy.Machining = {}
+   Strategy.Result.sInfo = ''
+   local bAreAllMachiningsAdded = true
+
+   -- separazione solo se esiste grezzo successivo con pezzi o scaricabile
+   Strategy.bSplit = not( Part.bIsLastPart)  or  Part.dRestLength >= BeamData.dMinRaw
+
+   -- se devo fare split perchè c'è un grezzo da scaricare o un altro pezzo
+   if Strategy.bSplit then
+      Strategy.SplitStrategy, Strategy.Result = SPLITCUT.GetStrategy( Proc, Part, Strategy.Parameters)
+
+   -- se devo rimuovere tutto il restante
+   else
+      -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
+      if Strategy.Parameters.bExecutePreCut then
+         Strategy.SplitStrategy, Strategy.Result = SPLITCUT.GetStrategy( Proc, Part, Strategy.Parameters)
+      -- se non faccio tagli PRECUT, imposto tabella Result direttamente. Non serve verificare che riesca a rimuovere il materiale extra 
+      else
+         Strategy.Result.sStatus = 'Completed'
+         Strategy.Result.nCompletionIndex = 5
+         Strategy.Result.dMRR = 1
+         Strategy.Result.nQuality = 5
+         Strategy.Result.sInfo = 'Split not possible'
+      end
+   end
+
+   -- se devo applicare le lavorazioni
+   if bAddMachining then
+
+      -- inserimento smussi su spigoli del taglio
+      if Strategy.Parameters.bMakeChamfer then
+         MakeChamfer()
+      end
+
+      local MachiningsToAdd = {}
+      -- se devo fare split perchè c'è un grezzo da scaricare o un altro pezzo
+      if Strategy.bSplit then
+         Strategy.dOffset = 0
+         MachiningsToAdd = SPLITCUT.Execute( Proc, Part, Strategy)
+      -- se devo rimuovere tutto il restante
+      else
+         -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
+         if Strategy.Parameters.bExecutePreCut then
+            Strategy.dOffset = Part.dRestLength
+            MachiningsToAdd = SPLITCUT.Execute( Proc, Part, Strategy)
+         end
+
+         -- TODO: funzione che calcola tagli data una faccia
+         -- BladeToWaste( Proc, Part)
+
+         local Faces = {}
+         local Face1 = {}
+         local Face2 = {}
+         local OptionalParameters = {}
+         Face1.ptCenter = Proc.Faces[1].ptCenter
+         Face1.vtNormal = Proc.Faces[1].vtN
+         OptionalParameters.b3BoxToDicing = Part.b3Raw
+         Faces = DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
+      end
+
+      -- aggiungo lavorazioni trovate alla lista generale
+      for i = 1, #MachiningsToAdd do
+         MachiningsToAdd[i].Splitting.sStage = 'Tail'
+         MachiningLib.AddNewMachining( Proc, MachiningsToAdd[i].Splitting, MachiningsToAdd[i].AuxiliaryData)
+      end
+
+      return bAreAllMachiningsAdded, Strategy.Result
+   else
+      return nil, Strategy.Result
+   end
+end
+
+-------------------------------------------------------------------------------------------------------------
+
+ return TAILCUT

Strategies/Standard/TAILCUT/TAILCUTConfig.lua

@@ -0,0 +1,13 @@
+-- Parametri configurabili da cliente per strategia: TAILCUT
+
+local TAILCUTData = {
+   sStrategyId = 'TAILCUT',
+   Parameters = {
+      { sName = 'bMakeChamfer', sValue = 'false', sDescriptionShort = 'Execute Chamfer', sDescriptionLong = 'Use the V-Mill to execute chamfers on cut-edges', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'bForceChainSaw', sValue = 'false', sDescriptionShort = 'Force to use chain saw', sDescriptionLong = 'Force to use chain saw', sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'bExecutePreCut', sValue = 'true', sDescriptionShort = 'Force to add PreCuts', sDescriptionLong = "Autocam will apply a machining on the theoric zero, to avoid collision if the theoric piece length doesn't correspond to the real length", sType = 'b', sMessageId = '', sMinUserLevel = '1'},
+      { sName = 'bFinishWithMill', sValue = 'true', sDescriptionShort = 'Finish with mill', sDescriptionLong = 'Use a mill to finish the surface if split with chain saw', sType = 'b', sMessageId = '', sMinUserLevel = '1'}
+   }
+}
+
+return TAILCUTData

Strategies/Strategies.ini

@@ -0,0 +1,149 @@
+; Commento per evitare BOM con UTF-8
+[Comments]
+STR0001 = Tenone a coda di rondine. Lama + fresa a coda di rondine
+STR0002 = Topologia tipo LapJoint. Svuotatura con fresa
+STR0003 = Topologia tipo LapJoint. Lama + motosega
+STR0004 = Topologia tipo LapJoint. Motosega
+STR0005 = Faccia singola o doppia. Lama, se necessario cubetti.
+
+[Strategies]
+; Processing , Gruppo , Topologia , Strategie
+;Feature : Cut
+10,1,Feature,STR0005
+;Feature : Longitudinal Cut
+10,0,Feature,
+;Feature : Double Cut
+11,1,Feature,
+; Feature : Ridge or Valley Cut
+12,0,Feature,
+; Feature : Saw Cut
+13,0,Feature,
+; Feature : Slot
+16,0,Pocket-5-Blind,STR0002,STR0003,STR0004
+16,0,Groove-4-Blind,STR0002,STR0003,STR0004
+16,0,Groove-3-Through,STR0002,STR0003,STR0004
+16,0,Groove-3-Blind,STR0002
+16,0,Rabbet-2-Through,STR0002
+16,0,Tunnel-4-Through,STR0003,STR0004
+; Feature : Front Slot
+17,0,Pocket-5-Blind,STR0002,STR0003,STR0004
+17,0,Groove-4-Blind,STR0002,STR0003,STR0004
+17,0,Groove-3-Blind,STR0002
+17,0,Groove-3-Through,STR0002,STR0003,STR0004
+17,0,Rabbet-2-Through,STR0002
+17,0,Tunnel-4-Through,STR0003,STR0004
+; Feature : Birds Mouth
+20,0,Feature,
+; Feature : Hip or Valley Rafter Notch
+25,0,Feature,
+; Feature : Ridge Lap
+30,1,Pocket-5-Blind,STR0002,STR0003,STR0004
+30,1,Groove-4-Blind,STR0002,STR0003,STR0004
+30,1,Groove-3-Blind,STR0002
+30,1,Groove-3-Through,STR0002,STR0003,STR0004
+30,1,Rabbet-2-Through,STR0002
+30,1,Tunnel-4-Through,STR0003,STR0004
+; Feature : Lap Joint
+30,0,Pocket-5-Blind,STR0002,STR0003,STR0004
+30,0,Groove-4-Blind,STR0002,STR0003,STR0004
+30,0,Groove-3-Blind,STR0002
+30,0,Groove-3-Through,STR0002,STR0003,STR0004
+30,0,Rabbet-2-Through,STR0002
+30,0,Tunnel-4-Through,STR0003,STR0004
+; Feature : Notch/Rabbet
+32,0,Pocket-5-Blind,STR0002,STR0003,STR0004
+32,0,Groove-4-Blind,STR0002,STR0003,STR0004
+32,0,Groove-3-Blind,STR0002
+32,0,Groove-3-Through,STR0002,STR0003,STR0004
+32,0,Rabbet-2-Through,STR0002
+32,0,Tunnel-4-Through,STR0003,STR0004
+; Feature : Block Haus
+33,0,Feature,
+; Feature : Notch
+34,0,Pocket-5-Blind,STR0002,STR0003,STR0004
+34,0,Groove-4-Blind,STR0002,STR0003,STR0004
+34,0,Groove-3-Blind,STR0002
+34,0,Groove-3-Through,STR0002,STR0003,STR0004
+34,0,Rabbet-2-Through,STR0002
+34,0,Tunnel-4-Through,STR0003,STR0004
+; Feature : French Ridge Lap
+35,1,Feature,
+; Feature : Chamfer
+36,0,Feature,
+; Feature : Block Haus Half Lap
+37,0,Feature,
+; Feature : Block Haus Front
+38,0,Feature,
+; Feature : Pocket
+39,0,Pocket-5-Blind,STR0002,STR0003,STR0004
+39,0,Groove-4-Blind,STR0002,STR0003,STR0004
+39,0,Groove-3-Blind,STR0002
+39,0,Groove-3-Through,STR0002,STR0003,STR0004
+39,0,Rabbet-2-Through,STR0002
+39,0,Tunnel-4-Through,STR0003,STR0004
+; Feature : Drilling
+40,0,Feature,
+; Feature : Tenon
+50,1,Feature,
+; Feature : Mortise
+50,0,Feature,
+; Feature : Front Mortise
+51,0,Feature,
+; Feature : House
+52,1,Feature,
+; Feature : House Mortise
+53,0,Feature,
+; Feature : Dovetail Tenon
+55,1,Feature,STR0001
+; Feature : Dovetail Mortise
+55,0,Feature,
+; Feature : Dovetail Mortise Front
+56,0,Feature,
+; Feature : Marking
+60,0,Feature,
+; Feature : Text
+61,0,Feature,
+; Feature : Scarf Simple
+70,1,Feature,
+; Feature : Scarf Joint
+71,1,Feature,
+; Feature : Step Joint
+80,1,Feature,
+; Feature : Step Joint Notch
+80,0,Feature,
+; Feature : Planing
+90,0,Feature,
+; Feature : Front Profile
+100,0,Feature,
+; Feature : Head Concave Profile
+101,0,Feature,
+; Feature : Head Convex Profile
+102,0,Feature,
+; Feature : Head Cambered Profile
+103,0,Feature,
+; Feature : Round Arch
+104,0,Feature,
+; Feature : Head Profile
+106,0,Feature,
+; Feature : Sphere
+107,0,Feature,
+; Feature : Triangle Cut
+120,0,Feature,
+; Feature : TyroleanDovetail
+136,0,Feature,
+; Feature : Dovetail
+138,0,Feature,
+; Feature : Free Contour
+250,0,Feature,
+; Feature : Outline
+251,0,Feature,
+; Feature : Aperture
+252,0,Feature,
+; Feature : HEADCUT
+340,0,Feature,HEADCUT
+; Feature : TAILCUT
+350,0,Feature,TAILCUT
+; Feature : Variant
+900,0,Feature,
+; Feature Decor
+959,0,Feature,

StrategyLibs/BLADETOWASTE.lua

@@ -0,0 +1,26 @@
+-- BLADETOWASTE.lua by Egalware s.r.l. 2025/01/08
+-- Libreria di supporto a strategie con funzioni comune a strategie diverse.
+
+-- Tabella per definizione modulo
+local BLADETOWASTE = {}
+
+-- Include
+require( 'EgtBase')
+
+-- Carico i dati globali
+local BeamData = require( 'BeamData')
+local FeatureLib = require( 'FeatureLib')
+local MachiningLib = require( 'MachiningLib')
+-- strategie di base
+local FaceByBlade = require('FACEBYBLADE')
+
+EgtOutLog( ' BLADETOWASTE started', 1)
+
+
+
+
+
+-- if dFeatureVolume < StrategyParameters.dMaxWasteVolume + 10 * GEO.EPS_SMALL
+--    and dFeatureMaxDimension < StrategyParameters.dMaxWasteLength + 10 * GEO.EPS_SMALL then
+
+-- end

StrategyLibs/FACEBYBLADE.lua

@@ -0,0 +1,303 @@
+-- Strategia: FACEBYBLADE
+-- 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 FACEBYBLADE = {}
+
+-------------------------------------------------------------------------------------------------------------
+
+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 - 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
+   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 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
+
+   -- 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 ''
+
+   -- 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
+   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
+
+   -- 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)
+      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
+
+   return Cutting
+   
+end
+
+-------------------------------------------------------------------------------------------------------------
+
+ return FACEBYBLADE

StrategyLibs/FACEBYCHAINSAW.lua

@@ -0,0 +1,261 @@
+-- Strategia: FACEBYCHAINSAW
+-- Descrizione 
+-- Strategia di base per la lavorazione delle slot o tasche con sega a catena
+-- Feature: tipo lapjoint
+
+-- carico librerie
+local BeamLib = require( 'BeamLib')
+local BeamData = require( 'BeamData')
+local MachiningLib = require( 'MachiningLib')
+
+-- Tabella per definizione modulo
+local FACEBYCHAINSAW = {}
+
+-------------------------------------------------------------------------------------------------------------
+
+local function CalculateLeadInOut( Machining, EdgeToMachine, sSideToMachine, dLengthToMachine)
+   -- 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 = 0
+   dAddLengthToReduce = TOOLS[Machining.nToolIndex].dDiameter / 2
+
+   if Machining.bInvert then
+      Machining.bIsStartClosed, Machining.bIsEndClosed = Machining.bIsEndClosed, Machining.bIsStartClosed
+   end
+
+   local LeadIn = {}
+   local LeadOut = {}
+   LeadIn.dStartAddLength = 0
+   LeadOut.dEndAddLength = 0
+   if sSideToMachine == 'End' then
+      LeadIn.dStartAddLength = dAddLengthToReduce + dLengthToMachine + BeamData.CUT_EXTRA - EdgeToMachine.dLength
+   elseif Machining.bIsStartClosed then
+      LeadIn.dStartAddLength = -dAddLengthToReduce
+   else
+      LeadIn.dStartAddLength = BeamData.CUT_EXTRA
+   end
+   if sSideToMachine == 'Start' then
+      LeadOut.dEndAddLength = dAddLengthToReduce + dLengthToMachine + BeamData.CUT_EXTRA - EdgeToMachine.dLength
+   elseif Machining.bIsEndClosed then
+      LeadOut.dEndAddLength = -dAddLengthToReduce
+   else
+      LeadOut.dEndAddLength = BeamData.CUT_EXTRA
+   end
+
+   return LeadIn, LeadOut
+end
+
+
+-- TODO calcolo area lavorata per completamento
+function FACEBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalParameters)
+   local Mortising = {}
+   Mortising.bIsApplicable = true
+   Mortising.dDepthToMachine = 0
+   Mortising.dResidualDepth = EdgeToMachine.dElevation
+   Mortising.sMessage = ''
+   Mortising.idProc = Proc.id
+   Mortising.sEdgeType = EdgeToMachine.sType
+   Mortising.nFeatureSegment = 1
+
+   -- parametri opzionali
+   if not OptionalParameters then
+      OptionalParameters = {}
+   end
+   local bUseZigZagMortising = OptionalParameters.bUseZigZagMortising or false
+   local sSideToMachine = OptionalParameters.sSideToMachine or ''
+   local dLengthToMachine = OptionalParameters.dLengthToMachine or EdgeToMachine.dLength
+   local dCustomMaxElev = OptionalParameters.dMaxElev or EdgeToMachine.dElevation
+   local bStopAtHalfElevation = OptionalParameters.bStopAtHalfElevation or false
+   local dExtendAfterTail = OptionalParameters.dExtendAfterTail or 10000
+   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
+   -- TODO serve un modo migliore di calcolare la lunghezza lungo X; attenzione che serve la lunghezza reale di lavoro, non quella del lato
+   -- TODO andrà aggiornata dopo il calcolo LeadIn/Out
+   Mortising.dLengthOnX = abs( dLengthToMachine * EdgeToMachine.vtN:getY())
+   Mortising.dEdgeLength = EdgeToMachine.dLength
+   if bOppositeToolDirection then
+      Mortising.vtToolDirection = -EdgeToMachine.vtN
+   else
+      Mortising.vtToolDirection = EdgeToMachine.vtN
+   end
+   Mortising.vtEdgeDirection = EdgeToMachine.vtN ^ FaceToMachine.vtN
+   Mortising.ptEdge1, _, Mortising.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -Mortising.vtToolDirection, GDB_ID.ROOT)
+
+   -- ricerca utensile
+   local bExtendWithCornerRadius = false
+   if not bStopAtHalfElevation then
+      if ( EdgeToMachine.sType == 'Side' and Proc.Topology.sName == 'Groove-3-Through') or
+         ( EdgeToMachine.sType == 'Opposite' and Proc.Topology.sFamily == 'Tunnel') then
+            
+         bExtendWithCornerRadius = true
+         Mortising.dDepthToMachine = EdgeToMachine.dElevation + BeamData.CUT_EXTRA
+      else
+         Mortising.dDepthToMachine = EdgeToMachine.dElevation
+      end
+   else
+      bExtendWithCornerRadius = true
+      Mortising.dDepthToMachine = EdgeToMachine.dElevation / 2 + BeamData.CUT_EXTRA_MIN
+   end
+   local ToolSearchParameters = {}
+   local ToolInfo = {}
+   ToolSearchParameters.vtToolDirection = Mortising.vtToolDirection
+   ToolSearchParameters.bAllowTopHead = true
+   ToolSearchParameters.bAllowBottomHead = true
+   ToolSearchParameters.dElevation = Mortising.dDepthToMachine
+   ToolSearchParameters.bExtendWithCornerRadius = bExtendWithCornerRadius
+   ToolInfo = MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
+   Mortising.nToolIndex = ToolInfo.nToolIndex
+   Mortising.nType = MCH_OY.MORTISING
+   if not TOOLS[Mortising.nToolIndex] or not TOOLS[Mortising.nToolIndex].sName then
+      Mortising.sMessage = 'Chainsaw not found'
+      Mortising.bIsApplicable = false
+      EgtOutLog( Mortising.sMessage)
+      return Mortising
+   end
+
+   -- verifica dimensioni tasca compatibili
+   -- se tasca meno spessa della sega a catena la strategia non è applicabile
+   if OptionalParameters.dPocketHeight and ( TOOLS[Mortising.nToolIndex].dThickness > dPocketHeight + 10 * GEO.EPS_SMALL) then
+      Mortising.sMessage = 'Pocket too narrow for chainsaw thickness'
+      Mortising.bIsApplicable = false
+      EgtOutLog( Mortising.sMessage)
+      return Mortising
+   end
+   if Proc.MainFaces and #( Proc.MainFaces.SideFaces) > 1 then
+      -- se tasca più stretta della sega a catena la strategia non è applicabile
+      if TOOLS[Mortising.nToolIndex].dWidth > EdgeToMachine.dLength + 10 * GEO.EPS_SMALL then
+         Mortising.sMessage = 'Pocket too narrow for chainsaw width'
+         Mortising.bIsApplicable = false
+         EgtOutLog( Mortising.sMessage)
+         return Mortising
+      end
+   end
+
+   -- parametri della lavorazione
+   -- TODO gestire ToolInvert per rispettare direzione migliore di lavorazione
+   -- profondità (parametro DEPTH) non usata
+   Mortising.sDepth = 'TH'
+   -- inizio e fine aperti o chiusi
+   Mortising.bIsStartClosed = not EdgeToMachine.bIsStartOpen
+   Mortising.bIsEndClosed = not EdgeToMachine.bIsEndOpen
+   -- lato di lavoro e inversioni
+   Mortising.bInvert = false
+   if bOppositeToolDirection then
+      Mortising.nWorkside = MCH_MILL_WS.LEFT
+      Mortising.bToolInvert = true
+   else
+      Mortising.nWorkside = MCH_MILL_WS.RIGHT
+      Mortising.bToolInvert = false
+   end
+   -- profondità e offset longitudinale
+   if bExtendWithCornerRadius then
+      Mortising.dDepthToMachine = Mortising.dDepthToMachine + TOOLS[Mortising.nToolIndex].dCornerRadius
+   end
+   if TOOLS[Mortising.nToolIndex].dMaxMaterial > Mortising.dDepthToMachine - 10 * GEO.EPS_SMALL then
+      Mortising.dResidualDepth = 0
+      if bOppositeToolDirection then
+         Mortising.dLongitudinalOffset = EdgeToMachine.dElevation - Mortising.dDepthToMachine
+      else
+         Mortising.dLongitudinalOffset = 0
+      end
+   else
+      Mortising.dDepthToMachine = TOOLS[Mortising.nToolIndex].dMaxMaterial - 1
+      Mortising.dResidualDepth = EdgeToMachine.dElevation - Mortising.dDepthToMachine
+      if bOppositeToolDirection then
+         Mortising.dLongitudinalOffset = 0
+      else
+         Mortising.dLongitudinalOffset = EdgeToMachine.dElevation - Mortising.dDepthToMachine
+      end
+      Mortising.sMessage = 'Feature '.. Proc.idFeature .. ' : chainsaw elevation (' .. EgtNumToString( EdgeToMachine.dElevation, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Mortising.dDepthToMachine, 1) .. ')'
+      EgtOutLog( Mortising.sMessage)
+   end
+   -- completamento
+   Mortising.dCompletionPercentage = 100 - Mortising.dResidualDepth / Mortising.dDepthToMachine
+   -- massima elevazione
+   if dCustomMaxElev < Mortising.dDepthToMachine - 10 * GEO.EPS_SMALL then
+      Mortising.dMaxElev = max( dCustomMaxElev, dCustomMaxElev - Mortising.dLongitudinalOffset)
+   end
+   -- offset radiale
+   Mortising.dRadialOffset = 0
+   -- distanza di sicurezza
+   Mortising.dStartSafetyLength = max( EdgeToMachine.dElevation, ( TOOLS[Mortising.nToolIndex].SetupInfo.dZSafeDelta or 60) + EgtMdbGetGeneralParam( MCH_GP.SAFEZ))
+   -- overlap
+   Mortising.dOverlap = 0
+   -- step
+   Mortising.Steps = {}
+   if bUseZigZagMortising then
+      Mortising.Steps.nStepType = MCH_MILL_ST.ZIGZAG
+   else
+      Mortising.Steps.nStepType = MCH_MILL_ST.ONEWAY
+   end
+   Mortising.Steps.dStep = TOOLS[Mortising.nToolIndex].dStep
+   -- faceuse
+   if bOppositeToolDirection then
+      Mortising.nFaceuse = BeamLib.GetNearestParalOpposite( -Mortising.vtToolDirection)
+   else
+      Mortising.nFaceuse = BeamLib.GetNearestParalOpposite( Mortising.vtToolDirection)
+   end
+   -- SCC
+   Mortising.SCC = MCH_SCC.NONE
+   -- asse bloccato e angoli suggeriti
+   local vtRes = FaceToMachine.vtN ^ EdgeToMachine.vtN
+   if abs( vtRes:getZ()) < 10 * GEO.EPS_SMALL then
+      Mortising.sBlockedAxis = BeamLib.GetBlockedAxis( Mortising.nToolIndex, 'perpendicular', Part.b3Raw, FaceToMachine.vtN)
+      Mortising.sSuggestedAngles = BeamLib.GetChainSawInitAngs( FaceToMachine.vtN, EdgeToMachine.vtN, 1)
+   elseif EdgeToMachine.vtN:getZ() < 10 * GEO.EPS_SMALL then
+      Mortising.sBlockedAxis = BeamLib.GetBlockedAxis( Mortising.nToolIndex, 'parallel', Part.b3Raw, FaceToMachine.vtN)
+      Mortising.sSuggestedAngles = BeamLib.GetChainSawInitAngs( FaceToMachine.vtN, EdgeToMachine.vtN, 2)
+   end
+   -- approccio e retrazione
+   Mortising.LeadIn, Mortising.LeadOut = CalculateLeadInOut( Mortising, EdgeToMachine, sSideToMachine, dLengthToMachine)
+   -- eventuale step verticale
+   Mortising.VerticalSteps = MachiningLib.GetMachiningSteps( dPocketHeight, TOOLS[Mortising.nToolIndex].dThickness)
+   -- geometria
+   Mortising.Geometry = {{Proc.id, FaceToMachine.id}}
+   -- nome operazione
+   Mortising.sOperationName = 'Chainsaw_' .. ( EgtGetName( Mortising.idProc) or tostring( Mortising.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 ( Mortising.vtToolDirection:getX() < 0.707)) then
+      local dLengthOnX = Mortising.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( Mortising)
+      local dAddLengthLeftSide = Mortising.LeadOut.dEndAddLength
+      if bStartLeft then
+         dAddLengthLeftSide = Mortising.LeadIn.dStartAddLength
+      end
+      if not AreSameOrOppositeVectorApprox( EdgeToMachine.vtN, Y_AX()) then
+         if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
+            Mortising.sStage = 'AfterTail'
+         else
+            Mortising.bIsApplicable = false
+         end
+      elseif dAddLengthLeftSide + TOOLS[Mortising.nToolIndex].dDiameter / 2 > dExtendAfterTail then
+         if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
+            Mortising.sStage = 'AfterTail'
+         else
+            if bStartLeft then
+               Mortising.LeadIn.dStartAddLength = - TOOLS[Mortising.nToolIndex].dDiameter / 2 + dExtendAfterTail
+            else
+               Mortising.LeadOut.dEndAddLength = - TOOLS[Mortising.nToolIndex].dDiameter / 2 + dExtendAfterTail
+            end
+         end
+      end
+   end
+
+   return Mortising
+end
+
+-------------------------------------------------------------------------------------------------------------
+
+ return FACEBYCHAINSAW

StrategyLibs/SPLITCUT.lua

@@ -0,0 +1,337 @@
+-- SPLITCUT.lua by Egalware s.r.l. 2024/04/02
+-- Libreria di supporto a strategie con funzioni comune a strategie diverse.
+
+-- Tabella per definizione modulo
+local SPLITCUT = {}
+
+-- Include
+require( 'EgtBase')
+
+-- Carico i dati globali
+local BeamData = require( 'BeamData')
+local FeatureLib = require( 'FeatureLib')
+local MachiningLib = require( 'MachiningLib')
+-- strategie di base
+local FaceByBlade = require('FACEBYBLADE')
+
+EgtOutLog( ' SPLITCUT started', 1)
+
+-----------------------------------------------------------------------------------
+---------------------- FUNZIONI DI SPLIT ------------------------------------------
+-----------------------------------------------------------------------------------
+
+function SPLITCUT.GetStrategy( Proc, Part, OptionalParameters)
+   local Machining = {}
+   local Result = {}
+   -- sTypeMachining = BladeSideSingle\ BladeSideDouble\ BladeHorizontalSingle\ BladeHorizontalDouble\ ChainSawHorizontal\ ChainSawSideSingle\ ChainSawSideDouble\ ChainSawPlusBlade\ Mill\ None
+   Machining.sTypeMachining = 'None'
+   local Splitting = {}
+   -- imposto parametri di ricerca utensile in base a topologia
+   local ToolSearchParameters = {}
+   ToolSearchParameters.vtToolDirection = Proc.Faces[1].vtN
+
+   --  ===== RICERCA UTENSILE =====
+   -- cerco lama sopra
+   Splitting.bIsApplicable = false
+   ToolSearchParameters.bAllowTopHead = true
+   ToolSearchParameters.bAllowBottomHead = false
+   Splitting.ToolInfo = {}
+   Splitting.ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
+   if Splitting.ToolInfo.nToolIndex then
+      Splitting.bIsApplicable = true
+      local ParametersMRR = {}
+      ParametersMRR.nToolIndex = Splitting.ToolInfo.nToolIndex
+      Splitting.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+   end
+   table.insert( Machining, Splitting)
+
+   -- cerco lama sotto
+   Splitting = {}
+   Splitting.bIsApplicable = false
+   ToolSearchParameters.bAllowTopHead = false
+   ToolSearchParameters.bAllowBottomHead = true
+   Splitting.ToolInfo = {}
+   Splitting.ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
+   if Splitting.ToolInfo.nToolIndex then
+      Splitting.bIsApplicable = true
+      local ParametersMRR = {}
+      ParametersMRR.nToolIndex = Splitting.ToolInfo.nToolIndex
+      Splitting.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+   end
+   table.insert( Machining, Splitting)
+
+   -- cerco motosega
+   Splitting = {}
+   Splitting.bIsApplicable = false
+   table.insert( Machining, Splitting)
+
+   -- cerco fresa
+   Splitting = {}
+   Splitting.bIsApplicable = false
+   table.insert( Machining, Splitting)
+
+   --  ===== SCELTA LAVORAZIONI =====
+   -- forzature da parametri
+   if OptionalParameters.bForceChainSaw then
+      Machining[1].bIsApplicable = false
+      Machining[2].bIsApplicable = false
+   end
+
+   -- setto valori di default. Impossibile che taglio di separazione sia incompleto
+   Result.sStatus = 'Completed'
+   Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
+   Result.dMRR = 1
+
+   -- correzioni sul massimo materiale lama, considerando ingombri vari
+   local dMaxMatBladeSideSingle
+   local dMaxMatBladeSideDouble
+   local dMaxMatBladeHorizontalSingle
+   local dMaxMatBladeHorizontalDouble
+   if Machining[1].bIsApplicable then
+      local dMaxMat = TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial
+      local dRadius = TOOLS[Machining[1].ToolInfo.nToolIndex].dDiameter / 2
+      local sHead = TOOLS[Machining[1].ToolInfo.nToolIndex].sHead
+      -- se taglio di fianco disponibile, si controlla il massimo materiale reale. Per pezzi alti, bisogna controllare anche l'ingombro asse Z nelle 4 direzioni.
+      if Part.dHeight < BeamData.MIN_DIM_HBEAM then
+         dMaxMat = min( dMaxMat, BeamData.MAX_DIM_HTCUT)
+         dMaxMatBladeSideSingle = dMaxMat
+         dMaxMatBladeSideDouble = dMaxMat * 2
+      else
+         if BeamData.GetMaxMatReductionBladeCut then
+            dMaxMatBladeSideSingle = min( max( dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, Y_AX()), dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, -Y_AX())),
+                                          TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial)
+            dMaxMatBladeSideDouble = dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, Y_AX()) + dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, -Y_AX())
+         else
+            dMaxMatBladeSideSingle = abs( BeamData.MAX_DIM_HTCUT_HBEAM)
+            dMaxMatBladeSideDouble = abs( BeamData.MAX_DIM_HTCUT_HBEAM) * 2
+         end
+      end
+      -- se taglio orizzontale
+      if BeamData.GetMaxMatReductionBladeCut then
+         dMaxMatBladeHorizontalSingle = min( TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial, dRadius - BeamData.GetMaxMatReductionBladeCut( TOOLS[Machining[1].ToolInfo.nToolIndex].sHead, -Z_AX()))
+      else
+         dMaxMatBladeHorizontalSingle = TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial
+      end
+   end
+   if Machining[2].bIsApplicable then
+      if BeamData.GetMaxMatReductionBladeCut then
+         local dRadius = TOOLS[Machining[2].ToolInfo.nToolIndex].dDiameter / 2
+         dMaxMatBladeHorizontalDouble = min( TOOLS[Machining[2].ToolInfo.nToolIndex].dMaxMaterial, dRadius - BeamData.GetMaxMatReductionBladeCut( TOOLS[Machining[2].ToolInfo.nToolIndex].sHead, Z_AX()))
+      else
+         dMaxMatBladeHorizontalDouble = TOOLS[Machining[2].ToolInfo.nToolIndex].dMaxMaterial
+      end
+   end
+
+   -- TODO considerare di tagliare con il massimo materiale possibile per non salire troppo in Z (macchine tipo PF), oppure non scendere troppo (tipo Kairos)
+   -- BladeSideSingle   (taglio di lama singolo di fianco)
+   if Machining[1].bIsApplicable  and  ( dMaxMatBladeSideSingle - BeamData.CUT_EXTRA) > Part.dWidth + 10 * GEO.EPS_SMALL then
+      Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+      Machining.sTypeMachining = 'BladeSideSingle'
+      Machining[2].bIsApplicable = false
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining, Result
+   -- TODO considerare di tagliare con il massimo materiale possibile per non salire troppo in Z (macchine tipo PF), oppure non scendere troppo (tipo Kairos)
+   -- BladeSideDouble   (taglio di lama doppio di fianco)
+   elseif Machining[1].bIsApplicable  and  ( dMaxMatBladeSideDouble - BeamData.CUT_EXTRA) > Part.dWidth + 10 * GEO.EPS_SMALL then
+      Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+      Result.dMRR = Result.dMRR/2
+      Machining.sTypeMachining = 'BladeSideDouble'
+      Machining[2].bIsApplicable = false
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining, Result
+   -- BladeHorizontalSingle   (taglio di lama singolo orizzontale)
+   elseif Machining[1].bIsApplicable  and  ( dMaxMatBladeHorizontalSingle - BeamData.CUT_EXTRA) > Part.dHeight + 10 * GEO.EPS_SMALL then
+      Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+      Machining.sTypeMachining = 'BladeHorizontalSingle'
+      Machining[2].bIsApplicable = false
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining, Result
+   -- BladeHorizontalDouble   (taglio di lama doppio orizzontale)
+   elseif Machining[1].bIsApplicable  and  Machining[2].bIsApplicable and
+         ( dMaxMatBladeHorizontalSingle + dMaxMatBladeHorizontalDouble - BeamData.CUT_EXTRA) > Part.dHeight + 10 * GEO.EPS_SMALL then
+      Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
+      Result.dMRR = Result.dMRR/2
+      Machining.sTypeMachining = 'BladeHorizontalDouble'
+      Machining[1].ToolInfo.dMaxMatBladeFromTop = dMaxMatBladeHorizontalSingle
+      Machining[2].ToolInfo.dMaxMatBladeFromDown = dMaxMatBladeHorizontalDouble
+      Machining[3].bIsApplicable = false
+      Machining[4].bIsApplicable = false
+      return Machining, Result
+
+   -- TODO : casi con motosega da completare
+   -- ChainSawHorizontal   (motosega)
+   -- ChainSawSideSingle   (motosega)
+   -- ChainSawSideDouble   (motosega)
+   -- ChainSawPlusBlade   (motosega più lama orizzontale)
+   -- Mill   (svuotatura)
+   end
+
+   -- se non ho trovato neanche una lavorazione completa, non posso separare
+   if Machining.sTypeMachining == 'None' then
+      Result.sStatus = 'Not-Applicable'
+      Result.nCompletionIndex = 0
+      Result.dMRR = 0
+      Result.nQuality = 0
+      Result.sInfo = 'Split not possible'
+   end
+
+   return Machining, Result
+ end
+
+-------------------------------------------------------------------------------------------------------------
+function SPLITCUT.GetEdgeToMachine( Proc, vtEdge)
+   local Edge
+   for i = 1, #Proc.Faces[1].Edges do
+      if AreSameVectorApprox( Proc.Faces[1].Edges[i].vtN, vtEdge) then
+         Edge = Proc.Faces[1].Edges[i]
+      end
+   end
+   return Edge
+end
+
+-------------------------------------------------------------------------------------------------------------
+function SPLITCUT.CalculateLeadInOut( EdgeToMachine)
+
+   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
+   LeadIn.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
+   LeadOut.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
+   LeadIn.dElevation = 0
+   LeadOut.dElevation = 0
+   LeadIn.dCompLength = 0
+   LeadOut.dCompLength = 0
+   LeadIn.dStartAddLength = BeamData.CUT_EXTRA
+   LeadOut.dEndAddLength = BeamData.CUT_EXTRA
+
+   return LeadIn, LeadOut
+end
+
+-----------------------------------------------------------------------------------
+function SPLITCUT.Execute( Proc, Part, Strategy)
+   local Machinings = {}
+
+   -- applico le lavorazioni
+  --------------------------------------------------------------------------------
+   if Strategy.SplitStrategy.sTypeMachining == 'BladeSideSingle' then
+      local Machining = {}
+      Machining.Splitting = {}
+      Machining.AuxiliaryData = {}
+      local OptionalParameters = {}
+      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Split;', 'Cut;')
+
+      Machining.AuxiliaryData.bIsSplitOrCut = true
+
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Y_AX())
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+
+  ----------------------------------------------------------------------------------
+   elseif Strategy.SplitStrategy.sTypeMachining == 'BladeSideDouble' then
+      local Machining = {}
+      Machining.Splitting = {}
+      Machining.AuxiliaryData = {}
+      local OptionalParameters = {}
+      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+      -- Taglio lato frontale
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      OptionalParameters.dDepthToMachine = Part.dWidth / 2 + BeamData.CUT_EXTRA_MIN
+      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Presplit;', 'Precut;')
+
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Y_AX())
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+
+      -- Taglio lato dietro
+      Machining = {}
+      Machining.Splitting = {}
+      Machining.AuxiliaryData = {}
+      OptionalParameters = {}
+      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      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())
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+  ----------------------------------------------------------------------------------
+   elseif Strategy.SplitStrategy.sTypeMachining == 'BladeHorizontalSingle' then
+      local Machining = {}
+      Machining.Splitting = {}
+      Machining.AuxiliaryData = {}
+      local OptionalParameters = {}
+      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      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())
+      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
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      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())
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+
+      -- Taglio lato dietro
+      Machining = {}
+      Machining.Splitting = {}
+      Machining.AuxiliaryData = {}
+      OptionalParameters = {}
+      OptionalParameters.nToolIndex = Strategy.SplitStrategy[2].ToolInfo.nToolIndex
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      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())
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+  ----------------------------------------------------------------------------------
+   elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawHorizontal' then
+      ; -- TODO
+  ----------------------------------------------------------------------------------
+   elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawSideSingle' then
+      ; -- TODO
+  ----------------------------------------------------------------------------------
+   elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawSideDouble' then
+      ; -- TODO
+  ----------------------------------------------------------------------------------
+   elseif Strategy.SplitStrategy.sTypeMachining == 'ChainSawPlusBlade' then
+      ; -- TODO
+  ----------------------------------------------------------------------------------
+   end
+   return Machinings
+end
+
+-------------------------------------------------------------------------------------------------------------
+return SPLITCUT

Swap.lua

@@ -0,0 +1,31 @@
+-- Swap.lua by Egaltech s.r.l. 2017/11/02
+-- Gestione scambio testa coda di una Trave
+
+-- Intestazioni
+require( 'EgtBase')
+_ENV = EgtProtectGlobal()
+EgtEnableDebug( false)
+
+
+-- recupero il pezzo del primo oggetto selezionato
+local nId = EgtGetFirstSelectedObj()
+local nPartId = EgtGetParent( EgtGetParent( nId or GDB_ID.NULL) or GDB_ID.NULL)
+if not nPartId or not EgtIsPart( nPartId) then
+   EgtOutBox( 'Nessuna trave selezionata', 'Swap Trave', 'ERROR')
+   return
+end
+
+-- recupero il box del pezzo
+local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
+local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
+if not b3Solid then
+   local sName = EgtGetName( nPartId) or ( 'Id=' .. tonumber( nPartId))
+   EgtOutBox( 'Box non definito per la trave ' .. sName, 'Swap Trave', 'ERROR')
+   return
+end  
+
+-- eseguo rotazione di 180 gradi attorno asse Z
+EgtRotate( nPartId, b3Solid:getCenter(), Z_AX(), 180, GDB_RT.GLOB)
+EgtDraw()
+
+-- end

UpdateLog.txt

@@ -0,0 +1,4 @@
+           ==== Beam Update Log ====
+
+Versione 2.6-- (--/--/2024)
+- Primo commit creazione nuovo automatismo BEAM con strategie

Version.lua

@@ -0,0 +1,6 @@
+-- Version.lua by EgalWare s.r.l. 2024/04/02
+-- Gestione della versione di Beam
+
+NAME = 'Beam'
+VERSION = '2.6d1'
+MIN_EXE = '2.6g1'