- STR0005 con codolo funzionante e con ordinamento lavorazioni

- alle funzioni di base si può passare il parametro opzionale bOppositeToolDirection per invertire la direzione di lavoro dell'utensile

LuaLibs/BasicCustomerStrategies.lua

@@ -44,11 +44,12 @@ local function GetStrategies_Egalware( Proc)
       Strategies =  { { sStrategyId = 'HEADCUT'}}
    ---------------------------------------------------------------------
    -- Feature : Cut
-   elseif ID.IsSplitCut( Proc) then
-      Strategies =  { { sStrategyId = 'SPLITCUT'}}
+   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
@@ -302,8 +303,8 @@ local function GetStrategies_Essetre( Proc)
       Strategies =  { { sStrategyId = 'HEADCUT'}}
    ---------------------------------------------------------------------
    -- Feature : Cut
-   elseif ID.IsSplitCut( Proc) then
-      Strategies =  { { sStrategyId = 'SPLITCUT'}}
+   elseif ID.IsTailCut( Proc) then
+      Strategies =  { { sStrategyId = 'TAILCUT'}}
    ---------------------------------------------------------------------
    -- Feature : Cut
    elseif ID.IsCut( Proc) then

LuaLibs/BeamExec.lua

@@ -31,6 +31,7 @@ EgtMdbSave()
 TOOLS = {}           -- tabella contenente tutti gli utensili
 STRATEGIES = nil     -- tabella contenente le strategie disponibili per ogni feature
 MACHININGS = {}      -- tabella contenente le lavorazioni da applicare
+PROCESSINGS = {}     -- tabella contenente tutte le informazioni di ogni feature, processate per ogni rotazione
 
 -------------------------------------------------------------------------------------------------------------
 --    *** COSTANTI ***   TODO -> DA SPOSTARE IN BEAMDATA???
@@ -146,11 +147,13 @@ function BeamExec.GetToolsFromDB()
                Tool.dStep = EgtGetValInNotes( Tool.sUserNotes, 'STEP', 'd') or ( Tool.dMaxMaterial / 3)       -- se non settato nell'utensile, considero metà del tagliente
                Tool.dSideStep = EgtGetValInNotes( Tool.sUserNotes, 'SIDESTEP', 'd') or floor( Tool.dDiameter / 3)  -- se non settato nell'utensile, considero metà del diametro
                Tool.bIsPen = abs( Tool.dSpeed) < 5
+               Tool.dPerformanceIndex = ( Tool.dDiameter * Tool.dMaxMaterial) / Tool.dLength
                -- recupero parametri propri delle lame
             elseif sToolFamily == 'SAWBLADE' then
                Tool.bIsUsedForLongCut = EgtGetValInNotes( Tool.sUserNotes, 'LONGCUT') == 1 or false     -- false come valore di default
                Tool.dStep = EgtGetValInNotes( Tool.sUserNotes, 'STEP', 'd') or Tool.dThickness                    -- se non settato nell'utensile, considero lo spessore lama
                Tool.dSideStep = EgtGetValInNotes( Tool.sUserNotes, 'SIDESTEP', 'd') or Tool.dMaxMaterial  -- se non settato nell'utensile, considero un quarto del diametro
+               Tool.dPerformanceIndex = 1 / ( Tool.dDiameter * Tool.dLength)
             -- recupero parametri propri delle motoseghe
             elseif sToolFamily == 'MORTISE' then
                Tool.dDistance = EgtTdbGetCurrToolParam( MCH_TP.DIST) or 90 -- 90mm dimensione standard aggregato catena
@@ -160,7 +163,11 @@ function BeamExec.GetToolsFromDB()
                Tool.dSideStep = EgtGetValInNotes( Tool.sUserNotes, 'SIDESTEP', 'd') or ( Tool.dThickness - 1)  -- se non settato nell'utensile, considero spessore catena meno 1mm di sicurezza
                Tool.dCornerRadius = EgtTdbGetCurrToolParam( MCH_TP.CORNRAD)
                Tool.dWidth = Tool.dDiameter
+               Tool.dPerformanceIndex = 1 / Tool.dLength
             end
+         -- drillbit
+         else
+            Tool.dPerformanceIndex = Tool.dDiameter / Tool.dLength
          end
 
          -- se tutti i dati necessari sono disponibili, inserisco utensile nella lista globale degli utensili disponibili
@@ -375,13 +382,13 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS)
    local dDeltaE = BeamData.OVM_MID
    for i = 1, #PARTS do
       -- dati del pezzo
-      local b3Part = EgtGetBBoxGlob( PARTS[i].id or GDB_ID.NULL, GDB_BB.EXACT)
-      if b3Part:isEmpty() or PARTS[i].b3Box:isEmpty() then break end
-      EgtOutLog( 'PartSez=' .. EgtNumToString( b3Part:getDimY(), 1) .. 'x' .. EgtNumToString( b3Part:getDimZ(), 1), 3)
+      local b3BoxExact = EgtGetBBoxGlob( PARTS[i].id or GDB_ID.NULL, GDB_BB.EXACT)
+      if b3BoxExact:isEmpty() or PARTS[i].b3PartOriginal:isEmpty() then break end
+      EgtOutLog( 'PartSez=' .. EgtNumToString( b3BoxExact:getDimY(), 1) .. 'x' .. EgtNumToString( b3BoxExact:getDimZ(), 1), 3)
       -- se sezione compatibile e lunghezza disponibile sufficiente
-      local dPartLen = PARTS[i].b3Box:getDimX()
-      local dPartWidth = PARTS[i].b3Box:getDimY()
-      local dPartHeight = PARTS[i].b3Box:getDimZ()
+      local dPartLen = PARTS[i].b3PartOriginal:getDimX()
+      local dPartWidth = PARTS[i].b3PartOriginal:getDimY()
+      local dPartHeight = PARTS[i].b3PartOriginal:getDimZ()
       local dNextLen = dLen - EgtIf( i == 1, dDeltaS, 0) - dPartLen - dDeltaE
       if (( abs( dPartWidth - dRawW) < 100 * GEO.EPS_SMALL  and  abs( dPartHeight - dRawH) < 100 * GEO.EPS_SMALL)  or
           ( abs( dPartHeight - dRawW) < 100 * GEO.EPS_SMALL  and  abs( dPartWidth - dRawH) < 100 * GEO.EPS_SMALL))  and
@@ -411,7 +418,7 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS)
             return false, sOut
          end
          -- aggiungo faccia per taglio iniziale al pezzo
-         BeamLib.AddPartStartFace( PARTS[i].id, PARTS[i].b3Box)
+         BeamLib.AddPartStartFace( PARTS[i].id, PARTS[i].b3PartOriginal)
          -- se sovramateriale di testa, lo notifico
          if dDeltaS > 0.09 then
             EgtSetInfo( PARTS[i].idRaw, 'HOVM', dDeltaS)
@@ -423,16 +430,16 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS)
             EgtSetInfo( PARTS[i].idRaw, 'TOVM', dDeltaE)
          end
          -- aggiungo faccia per taglio finale al pezzo
-         BeamLib.AddPartEndFace( PARTS[i].id, PARTS[i].b3Box)
+         BeamLib.AddPartEndFace( PARTS[i].id, PARTS[i].b3PartOriginal)
          -- inserisco il pezzo nel grezzo
          EgtDeselectPartObjs( PARTS[i].id)
-         local ptPos = b3Part:getMin() - PARTS[i].b3Box:getMin() + Vector3d( dDelta, ( dRawW - dPartWidth) / 2, ( dRawH - dPartHeight) / 2)
+         local ptPos = b3BoxExact:getMin() - PARTS[i].b3PartOriginal:getMin() + Vector3d( dDelta, ( dRawW - dPartWidth) / 2, ( dRawH - dPartHeight) / 2)
          EgtAddPartToRawPart( PARTS[i].id, ptPos, PARTS[i].idRaw)
          if abs( dPartWidth - dRawW) > 100 * GEO.EPS_SMALL then
             -- rotazione attorno a centro geometria complessiva del pezzo
             EgtRotatePartInRawPart( PARTS[i].id, X_AX(), 90)
             -- correggo per eccentricità solido rispetto a geometria complessiva del pezzo
-            local vtEccOri = PARTS[i].b3Box:getCenter() - b3Part:getCenter()
+            local vtEccOri = PARTS[i].b3PartOriginal:getCenter() - b3BoxExact:getCenter()
             local vtEccRot = Vector3d( vtEccOri)
             vtEccRot:rotate( X_AX(), 90)
             EgtMovePartInRawPart( PARTS[i].id, ( vtEccOri - vtEccRot))
@@ -450,9 +457,10 @@ function BeamExec.ProcessBeams( dRawW, dRawH, dRawL, dOvmHead, dOvmMid, PARTS)
          PARTS[i].dWidth = PARTS[i].b3Raw:getDimY()
          PARTS[i].dHeight = PARTS[i].b3Raw:getDimZ()
          PARTS[i].bSquareSection = abs( PARTS[i].dWidth - PARTS[i].dHeight) < 100 * GEO.EPS_SMALL
-         PARTS[i].b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
+         PARTS[i].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD)
          PARTS[i].nIndexInParts = i
          PARTS[i].CombinationList = GetAvailableCombinations( PARTS[i])
+         PARTS[i].SplittingPoints = BeamLib.GetPartSplittingPoints( PARTS[i])
       else
          local sOut = 'Error: part L(' .. EgtNumToString( dPartLen, 1) .. ') too big for raw part L(' .. EgtNumToString( dLen - 0.1, 1) .. ')'
          return false, sOut
@@ -581,6 +589,7 @@ end
 -------------------------------------------------------------------------------------------------------------
 local function CollectFeatures( Part)
    -- recupero le feature
+   local nProcCount = 0
    local vProc = {}
    local LayerId = {}
    LayerId[1] = BeamLib.GetAddGroup( Part.id)
@@ -612,12 +621,6 @@ local function CollectFeatures( Part)
                EgtOutLog( '------Feature ' .. Proc.idFeature .. '------')
                -- se esiste la geometria
                if Proc.b3Box and not Proc.b3Box:isEmpty() then
-                  -- TODO fare una funzione per recuperare i dati delle feature che non passano dal calcolo della topologia?
-                  -- 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
                   -- informazioni facce e topologia
                   Proc.AffectedFaces = BeamLib.GetAffectedFaces( Proc, Part)
                   -- calcolo topologia solo se necessario, altrimenti si sfruttano le informazioni della feature BTL
@@ -629,6 +632,7 @@ local function CollectFeatures( Part)
                   else
                      Proc.Topology.sFamily = 'FEATURE'
                      Proc.Topology.sName = 'FEATURE'
+                     Proc = FeatureLib.GetAdditionalInfo( Proc, Part)
                   end
                   -- se topologia feature riconosciuta, oppure da non calcolare perchè il riconoscimento topologico è basato sulla feature stessa
                   if Proc.Topology.sName ~= 'NOT_IMPLEMENTED' then
@@ -643,17 +647,23 @@ local function CollectFeatures( Part)
                      end
                      -- se ci sono strategie disponibili, aggiungo a lista delle feature da lavorare
                      if Proc.AvailableStrategies and #Proc.AvailableStrategies > 0 then
+                        nProcCount = nProcCount + 1
+                        Proc.nIndexInVProc = nProcCount
                         table.insert( vProc, Proc)
                      -- altrimenti errore (non ci sono strategie per lavorare la topologia riconosciuta)
                      else
                         EgtOutLog( ' Feature ' .. tostring( Proc.idFeature) .. ' : NO available strategies')
                      end
+                     -- calcolo riduzione lunghezza pinzabile testa/coda
+                     Proc.NotClampableLength = FeatureLib.CalculateFeatureNotClampableLengths( Proc, Part)
                   -- altrimenti errore (serviva riconoscimento topologico, ma non è stato possibile farlo)
                   else
                      EgtOutLog( ' Feature ' .. tostring( Proc.idFeature) .. ' : NO available strategies')
                   end
                else
                   Proc.nFlg = 0
+                  nProcCount = nProcCount + 1
+                  Proc.nIndexInVProc = nProcCount
                   table.insert( vProc, Proc)
                   EgtOutLog( ' Feature ' .. tostring( Proc.idFeature) .. ' is empty (no geometry)')
                end
@@ -874,7 +884,7 @@ local function CalculateStrategies( vProcSingleRot, Part)
 
                   Proc.AvailableStrategies[nIndexCurrentStrategy].Result = FeatureLib.CalculateCompositeRating( Proc.AvailableStrategies[nIndexCurrentStrategy].Result)
                   -- se scelta strategia in modalità base o standard, esco subito alla prima che trovo completa
-                  -- TODO serve paraemtro da Beam&Wall ( oppure da confirgurazione) !!!!!!!!
+                  -- TODO serve parametro da Beam&Wall ( oppure da confirgurazione) !!!!!!!!
                   if BEAM.GetFirstCompletedStrategy and Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sStatus == 'Complete' then
                      break
                   end
@@ -981,6 +991,7 @@ local function CalculateMachinings( vProc, Part)
          bAreAllApplyOk, _ = StrategyScript.Make( true, Proc, Part, Proc.ChosenStrategy.Parameters)
       end
    end
+
    return MACHININGS
 end
 
@@ -998,7 +1009,7 @@ local function PrintFeatures( vProc, Part)
 end
 
 -------------------------------------------------------------------------------------------------------------
-function BeamExec.GetProcessings( PROCESSINGS, PARTS)
+function BeamExec.GetProcessings( PARTS)
    -- recupero tutti i processing di tutti i pezzi in tutte le rotazioni
    -- TODO calcolo tempi da rimuovere o lasciare solo per debug
    -- if EgtGetDebugLevel() >= 3 then
@@ -1017,9 +1028,6 @@ function BeamExec.GetProcessings( PROCESSINGS, PARTS)
             -- recupero informazioni ausiliarie feature e dipendenze tra feature stesse
             -- TODO le dipendenze cambiano in base alla rotazione del pezzo? probabilmente no
             vProcRot[dRotIndex] = GetFeatureInfoAndDependency( vProcRot[dRotIndex], PARTS[nPart])
-
-            -- calcola le strategie applicabili ( presenti nella tabella vProcRot[dRotIndex].AvailableStrategies)
-            vProcRot[dRotIndex] = CalculateStrategies( vProcRot[dRotIndex], PARTS[nPart])
          else
             -- inserisco una tabella vuota
             table.insert( vProcRot, {})
@@ -1267,7 +1275,7 @@ local function GetBestResultFromCombinationsMatrix( ProcessingsOnPart, PartInfo)
 end
 
 -------------------------------------------------------------------------------------------------------------
-function BeamExec.ProcessMachinings( PROCESSINGS, PARTS)
+function BeamExec.ProcessMachinings( PARTS)
    -- ciclo sui pezzi
    local nTotErr = 0
    local Stats = {}
@@ -1302,6 +1310,9 @@ function BeamExec.ProcessMachinings( PROCESSINGS, PARTS)
       for nPart = 1, #PARTS do
          -- calcolo della migliore strategia per ogni rotazione del pezzo
          for dRotIndex = 1, 4 do
+            -- calcola le strategie applicabili
+            PROCESSINGS[nPart].Rotation[dRotIndex] = CalculateStrategies( PROCESSINGS[nPart].Rotation[dRotIndex], PARTS[nPart])
+            -- tra le calcolate, sceglie la migliore
             PROCESSINGS[nPart].Rotation[dRotIndex] = GetBestStrategy( PROCESSINGS[nPart].Rotation[dRotIndex])
          end
 
@@ -1326,11 +1337,45 @@ function BeamExec.ProcessMachinings( PROCESSINGS, PARTS)
 
          -- esegue le strategie migliori che ha precedentemente scelto e salva le lavorazioni nella lista globale
          MACHININGS = CalculateMachinings( vProc, PARTS[nPart])
+         MACHININGS = MachiningLib.PrepareMachiningsForSorting( PARTS[nPart])
 
-         -- TODO riordinare lavorazioni ottimizzando cambio utensile/spezzone ecc..., mantenendo dipendenze definite prima
-         -- ordino le lavorazioni
-         -- MACHININGS = OrderMachining( MACHININGS, PARTS[nPart])
+         --TODO - rimuovere o mettere in Log, serve solo per test
+         -- TEST
+         local MachiningPropertiesBeforeSorting = {}
+         for i =1, #MACHININGS do
+            MachiningPropertiesBeforeSorting[i] = {}
+            MachiningPropertiesBeforeSorting[i] = {
+               ptCenter = MACHININGS[i].Machining.ptCenter,
+               nStage = MACHININGS[i].Machining.nStage,
+               nPartSegment = MACHININGS[i].Machining.nPartSegment,
+               sToolFamily = TOOLS[ MACHININGS[i].Machining.nToolIndex].sFamily,
+               dToolPerformanceIndex = TOOLS[ MACHININGS[i].Machining.nToolIndex].dPerformanceIndex,
+               sToolName = TOOLS[ MACHININGS[i].Machining.nToolIndex].sName,
+               vtToolDirection = MACHININGS[i].Machining.vtToolDirection
+            }
+         end
+         -- fine TEST
 
+         -- TODO completare ordinamento. Mancano le dipendenze.
+         MACHININGS = BeamLib.StableSort( MACHININGS, MachiningLib.CompareMachinings)
+          
+         --TODO - rimuovere o mettere in Log, serve solo per test
+         -- TEST
+         local MachiningPropertiesAfterSorting = {}
+         for i =1, #MACHININGS do
+            MachiningPropertiesAfterSorting[i] = {}
+            MachiningPropertiesAfterSorting[i] = {
+               ptCenter = MACHININGS[i].Machining.ptCenter,
+               nStage = MACHININGS[i].Machining.nStage,
+               nPartSegment = MACHININGS[i].Machining.nPartSegment,
+               sToolFamily = TOOLS[ MACHININGS[i].Machining.nToolIndex].sFamily,
+               dToolPerformanceIndex = TOOLS[ MACHININGS[i].Machining.nToolIndex].dPerformanceIndex,
+               sToolName = TOOLS[ MACHININGS[i].Machining.nToolIndex].sName,
+               vtToolDirection = MACHININGS[i].Machining.vtToolDirection
+            }
+         end
+         -- fine TEST
+         
          -- aggiungo la fase, se non è la prima
          if nOrd == 1 then
             EgtSetCurrPhase( 1)

LuaLibs/BeamLib.lua

@@ -90,6 +90,48 @@ function BeamLib.AddPartEndFace( PartId, b3Solid)
    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()
@@ -193,22 +235,22 @@ end
 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.b3Solid:getMax():getZ() - 500 * GEO.EPS_SMALL 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.b3Solid:getMin():getZ() + 500 * GEO.EPS_SMALL then
+      if Proc.b3Box:getMin():getZ() < Part.b3Part:getMin():getZ() + 500 * GEO.EPS_SMALL then
          vtFacesAffected.bBottom = true
       end
-      if Proc.b3Box:getMin():getY() < Part.b3Solid:getMin():getY() + 500 * GEO.EPS_SMALL then
+      if Proc.b3Box:getMin():getY() < Part.b3Part:getMin():getY() + 500 * GEO.EPS_SMALL then
          vtFacesAffected.bFront = true
       end
-      if Proc.b3Box:getMax():getY() > Part.b3Solid:getMax():getY() - 500 * GEO.EPS_SMALL then
+      if Proc.b3Box:getMax():getY() > Part.b3Part:getMax():getY() - 500 * GEO.EPS_SMALL then
          vtFacesAffected.bBack = true
       end
-      if Proc.b3Box:getMin():getX() < Part.b3Solid:getMin():getX() + 500 * GEO.EPS_SMALL then
+      if Proc.b3Box:getMin():getX() < Part.b3Part:getMin():getX() + 500 * GEO.EPS_SMALL then
          vtFacesAffected.bLeft = true
       end
-      if Proc.b3Box:getMax():getX() > Part.b3Solid:getMax():getX() - 500 * GEO.EPS_SMALL then
+      if Proc.b3Box:getMax():getX() > Part.b3Part:getMax():getX() - 500 * GEO.EPS_SMALL then
          vtFacesAffected.bRight = true
       end
    end
@@ -319,6 +361,66 @@ function BeamLib.Is3EdgesApprox( Proc, idFace, nAddGrpId)
    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
@@ -473,5 +575,57 @@ function BeamLib.TableCopyDeep( OriginalTable)
    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

@@ -97,6 +97,42 @@ function FaceData.GetFacesByAdjacencyNumber( Proc)
    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---')
@@ -109,6 +145,10 @@ function FaceData.GetFacesInfo( Proc, Part)
       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)
 
@@ -120,14 +160,14 @@ function FaceData.GetFacesInfo( Proc, Part)
          -- 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.b3Solid, true, GDB_ID.ROOT)
+         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, vEdges = EgtSurfTmGetFacetOutlineInfo( Proc.id, i - 1, GDB_ID.ROOT)
+         local nFaceType, Edges = GetEdgesInfo( Proc, i - 1)
          Faces[i].bIsOkForMachining = nFaceType < 1
-         Faces[i].Edges = vEdges
+         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)
@@ -180,7 +220,7 @@ local function GetTunnelFaces( Proc, Part)
    end
 
    -- faccia centrale
-   local nMiddleTmId = EgtSurfTmPlaneInBBox( nAddGrpId, ptTunnelCenter, vtTunnelDirection, Part.b3Solid, GDB_ID.ROOT)
+   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)
@@ -242,10 +282,10 @@ local function GetBottomFaces( Proc)
    
    local ClosedEdgesSortedByGreatestLength = {}
    for i = 1, #BottomFaces[1].Edges do
-      if not BottomFaces[1].Edges[i].Open then
+      if not BottomFaces[1].Edges[i].bIsOpen then
          table.insert( ClosedEdgesSortedByGreatestLength, {})
          ClosedEdgesSortedByGreatestLength[#ClosedEdgesSortedByGreatestLength].nIndex = i
-         ClosedEdgesSortedByGreatestLength[#ClosedEdgesSortedByGreatestLength].dLength = BottomFaces[1].Edges[i].Len
+         ClosedEdgesSortedByGreatestLength[#ClosedEdgesSortedByGreatestLength].dLength = BottomFaces[1].Edges[i].dLength
       end
    end
    table.sort( ClosedEdgesSortedByGreatestLength, function (a, b) return a.dLength > b.dLength end)
@@ -262,14 +302,13 @@ local function GetBottomFaces( Proc)
       end
 
       local CurrentEdge = {}
-      CurrentEdge.idAdjacentFace = BottomFaces[1].Edges[i].Adj
-      CurrentEdge.vtToolDirection = Vector3d( BottomFaces[1].Edges[i].Norm)
-      CurrentEdge.dLength = BottomFaces[1].Edges[i].Len
-      CurrentEdge.dLengthOnX = CurrentEdge.dLength * CurrentEdge.vtToolDirection:getY()
-      CurrentEdge.dElevation = BottomFaces[1].Edges[i].Elev
-      CurrentEdge.bIsOpen = BottomFaces[1].Edges[i].Open
-      CurrentEdge.bIsStartOpen = BottomFaces[1].Edges[nPreviousEdgeIndex].Open
-      CurrentEdge.bIsEndOpen = BottomFaces[1].Edges[nNextEdgeIndex].Open
+      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
@@ -348,14 +387,13 @@ local function GetLongFaces( Proc, MainFaces)
          end
 
          local CurrentEdge = {}
-         CurrentEdge.idAdjacentFace = LongFaces[i].Edges[j].Adj
-         CurrentEdge.vtToolDirection = Vector3d( LongFaces[i].Edges[j].Norm)
-         CurrentEdge.dLength = LongFaces[i].Edges[j].Len
-         CurrentEdge.dLengthOnX = CurrentEdge.dLength * CurrentEdge.vtToolDirection:getY()
-         CurrentEdge.dElevation = LongFaces[i].Edges[j].Elev
-         CurrentEdge.bIsOpen = LongFaces[i].Edges[j].Open
-         CurrentEdge.bIsStartOpen = LongFaces[i].Edges[nPreviousEdgeIndex].Open
-         CurrentEdge.bIsEndOpen = LongFaces[i].Edges[nNextEdgeIndex].Open
+         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
@@ -369,10 +407,10 @@ local function GetLongFaces( Proc, MainFaces)
             if CurrentEdge.idAdjacentFace == BottomFace.id then
                LongFaces[i].MainEdges.BottomEdge = CurrentEdge
                LongFaces[i].MainEdges.BottomEdge.sType = 'Bottom'
-            elseif LongFaces[i].Edges[nNextEdgeIndex].Adj == BottomFace.id then
+            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].Adj == BottomFace.id then
+            elseif LongFaces[i].Edges[nPreviousEdgeIndex].idAdjacentFace == BottomFace.id then
                LongFaces[i].MainEdges.SideEdges[2] = CurrentEdge
                LongFaces[i].MainEdges.SideEdges[2].sType = 'Side'
             else
@@ -435,14 +473,13 @@ local function GetSideFaces( Proc, MainFaces)
          end
 
          local CurrentEdge = {}
-         CurrentEdge.idAdjacentFace = SideFaces[i].Edges[j].Adj
-         CurrentEdge.vtToolDirection = Vector3d( SideFaces[i].Edges[j].Norm)
-         CurrentEdge.dLength = SideFaces[i].Edges[j].Len
-         CurrentEdge.dLengthOnX = CurrentEdge.dLength * CurrentEdge.vtToolDirection:getY()
-         CurrentEdge.dElevation = SideFaces[i].Edges[j].Elev
-         CurrentEdge.bIsOpen = SideFaces[i].Edges[j].Open
-         CurrentEdge.bIsStartOpen = SideFaces[i].Edges[nPreviousEdgeIndex].Open
-         CurrentEdge.bIsEndOpen = SideFaces[i].Edges[nNextEdgeIndex].Open
+         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
@@ -454,10 +491,10 @@ local function GetSideFaces( Proc, MainFaces)
             if CurrentEdge.idAdjacentFace == BottomFace.id then
                SideFaces[i].MainEdges.BottomEdge = CurrentEdge
                SideFaces[i].MainEdges.BottomEdge.sType = 'Bottom'
-            elseif SideFaces[i].Edges[nNextEdgeIndex].Adj == BottomFace.id then
+            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].Adj == BottomFace.id then
+            elseif SideFaces[i].Edges[nPreviousEdgeIndex].idAdjacentFace == BottomFace.id then
                SideFaces[i].MainEdges.LongEdges[2] = CurrentEdge
                SideFaces[i].MainEdges.LongEdges[2].sType = 'Long'
             else
@@ -494,6 +531,7 @@ function FaceData.GetMainFaces( Proc, Part)
          Logs.WriteMainFacesLog( Proc, MainFaces)
       end
    else
+      MainFaces = nil
       EgtOutLog( '---MainFaces NOT NEEDED---')
    end
 

LuaLibs/FeatureLib.lua

@@ -22,7 +22,7 @@ function FeatureLib.NeedTopologyFeature( Proc)
       return true
    elseif ID.IsHeadCut( Proc) then
       return true
-   elseif ID.IsSplitCut( Proc) then
+   elseif ID.IsTailCut( Proc) then
       return true
    elseif ID.IsDoubleCut( Proc) then
       return true
@@ -98,14 +98,12 @@ 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)
+local function IsAnyDimensionLongAsPart( Proc, Part)
    local bResult = false
-   local nBoxSolidId = EgtGetFirstNameInGroup( Proc.idPart or GDB_ID.NULL, 'Box')
-   local b3Solid = EgtGetBBoxGlob( nBoxSolidId, GDB_BB.STANDARD)
 
-   if Proc.b3Box:getDimX() > b3Solid:getDimX() - 1000 * GEO.EPS_SMALL or
-      Proc.b3Box:getDimY() > b3Solid:getDimY() - 1000 * GEO.EPS_SMALL or
-      Proc.b3Box:getDimZ() > b3Solid:getDimZ() - 1000 * GEO.EPS_SMALL then
+   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
 
@@ -141,7 +139,7 @@ function FeatureLib.ClassifyTopology( Proc, Part)
 
    local bIsFeatureCuttingEntireSection = IsFeatureCuttingEntireSection( Proc.b3Box, Part)
    local bIsFeatureCuttingEntireLength = IsFeatureCuttingEntireLength( Proc.b3Box, Part)
-   local bIsAnyDimensionLongAsPart = IsAnyDimensionLongAsPart( Proc)
+   local bIsAnyDimensionLongAsPart = IsAnyDimensionLongAsPart( Proc, Part)
    local vAdj = Proc.AdjacencyMatrix
    local bAllAnglesConcave, bAllRightAngles = AreAllAnglesConcaveOrRight( vAdj)
    local vTriangularFaces = FaceData.GetTriangularFaces( Proc)
@@ -295,8 +293,8 @@ function FeatureLib.CalculateCompositeRating( StrategyResult)
 end
 
 -------------------------------------------------------------------------------------------------------------
-function FeatureLib.MachiningNeedsSplitting( dMachiningLengthOnX, Part, OptionalParameters)
-   local bMachiningNeedsSplitting
+function FeatureLib.IsMachiningLong( dMachiningLengthOnX, Part, OptionalParameters)
+   local bIsMachiningLong
 
    -- parametri opzionali
    if not OptionalParameters then
@@ -304,14 +302,15 @@ function FeatureLib.MachiningNeedsSplitting( dMachiningLengthOnX, Part, Optional
    end
    local dMaxSegmentLength = OptionalParameters.dMaxSegmentLength or BeamData.LONGCUT_MAXLEN
 
-   bMachiningNeedsSplitting = ( dMachiningLengthOnX > dMaxSegmentLength + 10 * GEO.EPS_SMALL)
-                              or ( dMachiningLengthOnX > 0.7 * Part.b3Solid:getDimX() + 10 * GEO.EPS_SMALL)
+   bIsMachiningLong = ( dMachiningLengthOnX > dMaxSegmentLength + 10 * GEO.EPS_SMALL)
+                      or ( dMachiningLengthOnX > 0.7 * Part.b3Part:getDimX() + 10 * GEO.EPS_SMALL)
 
-   return bMachiningNeedsSplitting
+   return bIsMachiningLong
 end
+
 -------------------------------------------------------------------------------------------------------------
 function FeatureLib.GetFeatureSplittingPoints( Proc, Part, OptionalParameters)
-   local vFeatureSplittingPoints = {}
+   local FeatureSplittingPoints = {}
    local bFeatureStartsOnEdgeLeft = false
    local bFeatureStartsOnEdgeRight = false
    local dSplitXLeft = Proc.b3Box:getMin():getX()
@@ -328,15 +327,15 @@ function FeatureLib.GetFeatureSplittingPoints( Proc, Part, OptionalParameters)
    local dToolOverlapBetweenSegments = OptionalParameters.dToolOverlapBetweenSegments or BeamData.MILL_OVERLAP
 
    -- verifica spezzatura necessaria
-   if not FeatureLib.MachiningNeedsSplitting( Proc.b3Box:getDimX(), Part) then
+   if not FeatureLib.IsMachiningLong( Proc.b3Box:getDimX(), Part) then
       return {}
    end
 
    -- verifica se necessari spezzoni differenti sugli estremi
-   if Proc.b3Box:getMin():getX() < Part.b3Solid:getMin():getX() + dMaxSegmentLengthOnEdges - 10 * GEO.EPS_SMALL then
+   if Proc.b3Box:getMin():getX() < Part.b3Part:getMin():getX() + dMaxSegmentLengthOnEdges - 10 * GEO.EPS_SMALL then
       bFeatureStartsOnEdgeLeft = true
    end
-   if Proc.b3Box:getMax():getX() > Part.b3Solid:getMax():getX() - dMaxSegmentLengthOnEdges + 10 * GEO.EPS_SMALL then
+   if Proc.b3Box:getMax():getX() > Part.b3Part:getMax():getX() - dMaxSegmentLengthOnEdges + 10 * GEO.EPS_SMALL then
       bFeatureStartsOnEdgeRight = true
    end
 
@@ -345,13 +344,13 @@ function FeatureLib.GetFeatureSplittingPoints( Proc, Part, OptionalParameters)
    if bFeatureStartsOnEdgeLeft then
       -- decido punto spezzatura verso la coda
       if Proc.b3Box:getDimX() > dMaxSegmentLengthOnEdges * 2 then
-         dSplitXLeft = max( Part.b3Solid:getMin():getX() + dMaxSegmentLengthOnEdges, Proc.b3Box:getMin():getX() + dMinSegmentLength)
+         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.b3Solid:getDimX() < BeamData.dMinRaw * 1.5 then
-            dSplitXLeft = Part.b3Solid:getMax():getX() - ( ( Part.dRestLength + Part.b3Solid:getDimX()) / 2)
+         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.b3Solid:getMax():getX() - dMaxSegmentLengthOnEdges)
+            dSplitXLeft = max( Proc.b3Box:getMin():getX() + ( BeamData.dMinRaw)/2 + 150, Part.b3Part:getMax():getX() - dMaxSegmentLengthOnEdges)
          end
       end
       dFeatureCentralLength = abs( dSplitXRight - dSplitXLeft)
@@ -361,7 +360,7 @@ function FeatureLib.GetFeatureSplittingPoints( Proc, Part, OptionalParameters)
    -- calcolo punto estremo destro
    local ptSplitXRight
    if bFeatureStartsOnEdgeRight then
-      dSplitXRight = min( ( Proc.b3Box:getMax():getX() - dMinSegmentLength), Part.b3Solid:getMax():getX() - dMaxSegmentLengthOnEdges)
+      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
@@ -373,7 +372,7 @@ function FeatureLib.GetFeatureSplittingPoints( Proc, Part, OptionalParameters)
 
    -- aggiungo eventuale punto estremo destro
    if bFeatureStartsOnEdgeRight then
-      table.insert( vFeatureSplittingPoints, ptSplitXRight)
+      table.insert( FeatureSplittingPoints, ptSplitXRight)
    end
 
    -- aggiungo punti centrali della feature
@@ -384,17 +383,141 @@ function FeatureLib.GetFeatureSplittingPoints( Proc, Part, OptionalParameters)
          local ptOn
          local dCurrentPointX = dSplitXRight - i * dSplitPartsLen
          ptOn = Point3d( dCurrentPointX, 0, 0)
-         table.insert( vFeatureSplittingPoints, ptOn)
+         table.insert( FeatureSplittingPoints, ptOn)
       end
    end
 
    -- aggiungo eventuale punto estemo sinistro
    if bFeatureStartsOnEdgeLeft then
-      table.insert( vFeatureSplittingPoints, ptSplitXLeft)
+      table.insert( FeatureSplittingPoints, ptSplitXLeft)
    end
 
-   return vFeatureSplittingPoints
+   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

@@ -13,8 +13,8 @@ function Identity.IsHeadCut( Proc)
    return ( Proc.nGrp == 1  and  Proc.nPrc == 340)
 end
 ---------------------------------------------------------------------
--- Feature : Split Cut
-function Identity.IsSplitCut( Proc)
+-- Feature : Tail Cut
+function Identity.IsTailCut( Proc)
    return ( Proc.nGrp == 2  and  Proc.nPrc == 350)
 end
 

LuaLibs/MachiningLib.lua

@@ -99,15 +99,17 @@ function MachiningLib.GetMachiningSteps( dMachiningDepth, dStep)
    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, vSplittingPoints, Part )
+function MachiningLib.GetSplitMachinings( Machinings, SplittingPoints, Part )
    for i = #Machinings, 1, -1 do
-      local nParts = #vSplittingPoints + 1
+      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
@@ -116,16 +118,17 @@ function MachiningLib.GetSplitMachinings( Machinings, vSplittingPoints, Part )
       end
       local dOriginalStartAddLength = Machinings[i].LeadIn.dStartAddLength
       local dOriginalEndAddLength = Machinings[i].LeadOut.dEndAddLength
-      if FeatureLib.MachiningNeedsSplitting( Machinings[i].dLengthOnX, Part) then
+      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 vSplittingPoints[j - 1]:getX() > dEdgeMinX + 10 * GEO.EPS_SMALL)
-                                   and ( j == nParts or vSplittingPoints[j]:getX() < dEdgeMinX + 10 * GEO.EPS_SMALL))
+                                   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 ( vSplittingPoints[j]:getX() > dEdgeMinX + 10 * GEO.EPS_SMALL and vSplittingPoints[j]:getX() < dEdgeMaxX - 10 * GEO.EPS_SMALL))
+            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
@@ -137,12 +140,15 @@ function MachiningLib.GetSplitMachinings( Machinings, vSplittingPoints, Part )
                   dStartAddLength, dEndAddLength = dEndAddLength, dStartAddLength
                end
                if j == 1 then
-                  dEndAddLength = - ( vSplittingPoints[j]:getX() - dEdgeMinX) + BeamData.MILL_OVERLAP
+                  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 - vSplittingPoints[j - 1]:getX()) + BeamData.MILL_OVERLAP
+                  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 - vSplittingPoints[j - 1]:getX()) + BeamData.MILL_OVERLAP
-                  dEndAddLength = - ( vSplittingPoints[j]:getX() - dEdgeMinX) + BeamData.MILL_OVERLAP
+                  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
@@ -152,27 +158,37 @@ function MachiningLib.GetSplitMachinings( Machinings, vSplittingPoints, Part )
                Machinings[nCurrentMachiningIndex].LeadOut.dEndAddLength = dEndAddLength
             end
             if not bIsLastSegment then
-               Machinings[nCurrentMachiningIndex].bMoveAfterSplitcut = false
+               Machinings[nCurrentMachiningIndex].sStage = ''
+            else
+               Machinings[nCurrentMachiningIndex].sStage = sOriginalStage
             end
-            Machinings[nCurrentMachiningIndex].nSegment = j
+            Machinings[nCurrentMachiningIndex].nFeatureSegment = j
          end
       -- anche le lavorazioni non splittate necessitano del segmento assegnato
       else
-         local dRightAddLength = dOriginalStartAddLength
-         local dLeftAddLength = dOriginalEndAddLength
-         if MachiningLib.StartsLeftSide( Machinings[i]) then
-            dRightAddLength, dLeftAddLength = dLeftAddLength, dRightAddLength
+         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 = vSplittingPoints[j - 1]:getX()
-            elseif j ~= nParts then
-               dNextSplitX = vSplittingPoints[j]:getX()
+               dPreviousSplitX = SplittingPoints[j - 1]:getX()
             end
-            if ( dEdgeMinX - dLeftAddLength) > dNextSplitX - 10 * GEO.EPS_SMALL and ( dEdgeMaxX + dRightAddLength) < dPreviousSplitX + 10 * GEO.EPS_SMALL then
-               Machinings[i].nSegment = j
+            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
@@ -254,7 +270,7 @@ function MachiningLib.FindMill( Proc, ToolSearchParameters)
                -- 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].dLength / TOOLS[i].dMaxMaterial) / TOOLS[i].dDiameter < ( TOOLS[nBestToolIndex].dLength / TOOLS[nBestToolIndex].dMaxMaterial) / TOOLS[nBestToolIndex].dDiameter then
+                  if TOOLS[i].dPerformanceIndex > TOOLS[nBestToolIndex].dPerformanceIndex then
                      nBestToolIndex = i
                      dBestToolResidualDepth = dCurrentResidualDepth
                   end
@@ -310,6 +326,8 @@ function MachiningLib.FindBlade( Proc, ToolSearchParameters)
             bIsToolCompatible = TOOLS[i].SetupInfo.bIsTopHead
          elseif ToolSearchParameters.bAllowBottomHead and not ToolSearchParameters.bAllowTopHead then
             bIsToolCompatible = TOOLS[i].SetupInfo.bIsBottomHead
+         else
+            bIsToolCompatible = true
          end
       end
 
@@ -344,16 +362,16 @@ function MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
 
    -- parametri obbligatori
    if type( ToolSearchParameters.vtToolDirection) ~= 'table' then
-      error( 'FindBlade : missing tool direction')
+      error( 'FindChainSaw : missing tool direction')
    end
    if type( ToolSearchParameters.bAllowTopHead) ~= 'boolean' then
-      error( 'FindBlade : missing top head info')
+      error( 'FindChainSaw : missing top head info')
    end
    if type( ToolSearchParameters.bAllowBottomHead) ~= 'boolean' then
-      error( 'FindBlade : missing bottom head info')
+      error( 'FindChainSaw : missing bottom head info')
    end
    if not ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
-      error( 'FindBlade : wrong head info')
+      error( 'FindChainSaw : wrong head info')
    end
 
    -- parametri opzionali
@@ -391,7 +409,7 @@ function MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
             -- se entrambi completi
             if dBestToolResidualDepth <= 0 and dCurrentResidualDepth <= 0 then
                -- scelgo utensile con rapporto lunghezza / diametro minore
-               if ( TOOLS[i].dLength / pow( TOOLS[i].dDiameter, 1.5)) < ( TOOLS[nBestToolIndex].dLength / pow( TOOLS[nBestToolIndex].dDiameter, 1.5)) then
+               if TOOLS[i].dPerformanceIndex > TOOLS[nBestToolIndex].dPerformanceIndex then
                   nBestToolIndex = i
                   dBestToolResidualDepth = dCurrentResidualDepth
                end
@@ -642,7 +660,7 @@ function MachiningLib.AddOperations( vProc, Part, sRotation)
 
                -- 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.bAddNewPhase then
+               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
@@ -711,5 +729,221 @@ function MachiningLib.GetToolMRR( Parameters)
    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

@@ -13,7 +13,7 @@ EgtEnableDebug( true)
 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 .. '\\Strategies\\Core\\?.lua')
+EgtAddToPackagePath( BEAM.BASEDIR .. '\\StrategyLibs\\?.lua')
 
 -- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
 local sMachDir = EgtGetCurrMachineDir()
@@ -42,12 +42,13 @@ _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['SPLITCUT\\SPLITCUT'] = nil
-_G.package.loaded['SPLITCUT\\SPLITCUTConfig'] = nil
 _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.
@@ -64,7 +65,7 @@ for i = 1, 9999 do
       _G.package.loaded[sLibraryConfigToReload] = nil
    end
 end
-local vtCoreStrategiesNames = EgtFindAllFiles( BEAM.BASEDIR .. '\\Strategies\\Core\\*.lua')
+local vtCoreStrategiesNames = EgtFindAllFiles( BEAM.BASEDIR .. '\\StrategyLibs\\*.lua')
 for i = 1, #vtCoreStrategiesNames do
    local sCurrentName = EgtSplitString( vtCoreStrategiesNames[i], '.')[1]
    if _G.package.loaded[sCurrentName] then
@@ -73,14 +74,13 @@ for i = 1, #vtCoreStrategiesNames do
 end
 
 
-local BeamExec = require( 'BeamExec')
-
 -- Variabili globali
 PARTS = {}          -- tabella contenente tutte le informazioni di ogni pezzo
-PROCESSINGS = {}    -- tabella contenente tutte le informazioni di ogni feature, processate per ogni rotazione
 
 -- Carico i dati globali
 local BeamData = require( 'BeamData')
+-- carico librerie
+local BeamExec = require( 'BeamExec')
 
 -- Variabili di modulo
 local dRawW
@@ -129,15 +129,15 @@ local function MyProcessInputData()
          EgtOutBox( 'Box non definito per la trave ' .. PARTS[i].sName, 'Lavora Travi', 'ERROR')
          return false
       else
-         PARTS[i].b3Box = b3Solid
+         PARTS[i].b3PartOriginal = b3Solid
       end
    end
-   dRawW = PARTS[1].b3Box:getDimY()
-   dRawH = PARTS[1].b3Box:getDimZ()
+   dRawW = PARTS[1].b3PartOriginal:getDimY()
+   dRawH = PARTS[1].b3PartOriginal:getDimZ()
    local vBeamErr = {}
    for i = 2, #PARTS do
-      local dDimW = PARTS[i].b3Box:getDimY()
-      local dDimH = PARTS[i].b3Box:getDimZ()
+      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)
@@ -184,9 +184,9 @@ local function MyProcessBeams()
    -- Lunghezza totale delle travi
    local dTotLen = 0
    for i = 1, #PARTS - 1 do
-      dTotLen = dTotLen + PARTS[i].b3Box:getDimX()
+      dTotLen = dTotLen + PARTS[i].b3PartOriginal:getDimX()
    end
-   dTotLen = dTotLen + max( PARTS[#PARTS].b3Box:getDimX(), BeamData.dMinRaw)
+   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)
 
@@ -275,10 +275,10 @@ local function MyProcessBeams()
    local bOrd = ( vsVal[5] == 'true')
    if bOrd then
       table.sort( PARTS, function( B1, B2)
-                           if abs( B1.b3Box:getDimX() - B2.b3Box:getDimX()) < 1 then
+                           if abs( B1.b3PartOriginal:getDimX() - B2.b3PartOriginal:getDimX()) < 1 then
                               return B1.nInd < B2.nInd
                            else
-                              return B1.b3Box:getDimX() < B2.b3Box:getDimX()
+                              return B1.b3PartOriginal:getDimX() < B2.b3PartOriginal:getDimX()
                            end
                         end)
    end
@@ -306,8 +306,8 @@ end
 --    *** Inserimento delle lavorazioni nelle travi ***
 -------------------------------------------------------------------------------------------------------------
 local function MyProcessFeatures()
-   local PROCESSINGS = BeamExec.GetProcessings( PROCESSINGS, PARTS)
-   local bOk, Stats = BeamExec.ProcessMachinings( PROCESSINGS, PARTS)
+   BeamExec.GetProcessings( PARTS)
+   local bOk, Stats = BeamExec.ProcessMachinings( PARTS)
    local nErrCnt = 0
    local nWarnCnt = 0
    local sOutput = ''

Strategies/Standard/HEADCUT/HEADCUT.lua

@@ -45,14 +45,8 @@ local function CalculateLeadInOut( Machining, EdgeToMachine)
    LeadOut.nType = MCH_MILL_LI.LINEAR
    LeadIn.dTangentDistance = 0
    LeadOut.dTangentDistance = 0
-   -- elevazione sempre in negativo
-   if EdgeToMachine.Elev < 10 * GEO.EPS_SMALL then
-      LeadIn.dPerpDistance = BeamData.CUT_SIC - EdgeToMachine.Elev
-      LeadOut.dPerpDistance = BeamData.CUT_SIC - EdgeToMachine.Elev
-   else
-      LeadIn.dPerpDistance = BeamData.CUT_SIC
-      LeadOut.dPerpDistance = BeamData.CUT_SIC
-   end
+   LeadIn.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
+   LeadOut.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
    LeadIn.dElevation = 0
    LeadOut.dElevation = 0
    LeadIn.dCompLength = 0
@@ -72,7 +66,7 @@ end
 local function GetEdgeToMachine( Proc, vtEdge)
    local Edge
    for i = 1, #Proc.Faces[1].Edges do
-      if AreSameVectorApprox( Proc.Faces[1].Edges[i].Norm, vtEdge) then
+      if AreSameVectorApprox( Proc.Faces[1].Edges[i].vtN, vtEdge) then
          Edge = Proc.Faces[1].Edges[i]
       end
    end
@@ -278,7 +272,8 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
          local EdgeToMachine = GetEdgeToMachine( Proc, -Y_AX())
          -- approccio e retrazione
          OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
          MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
    ----------------------------------------------------------------------------------
       elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeSideDouble' then
@@ -294,7 +289,8 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
          local EdgeToMachine = GetEdgeToMachine( Proc, -Y_AX())
          -- approccio e retrazione
          OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
          MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
    
          -- Taglio lato dietro
@@ -311,7 +307,8 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
          EdgeToMachine = GetEdgeToMachine( Proc, Y_AX())
          -- approccio e retrazione
          OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
          MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
    ----------------------------------------------------------------------------------
       elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeHorizontalSingle' then
@@ -326,7 +323,8 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
          local EdgeToMachine = GetEdgeToMachine( Proc, Z_AX())
          -- approccio e retrazione
          OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
          MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
    ----------------------------------------------------------------------------------
       elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeHorizontalDouble' then
@@ -343,7 +341,8 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
          local EdgeToMachine = GetEdgeToMachine( Proc, Z_AX())
          -- approccio e retrazione
          OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
          MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
    
          -- Taglio lato dietro
@@ -360,7 +359,8 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
          EdgeToMachine = GetEdgeToMachine( Proc, -Z_AX())
          -- approccio e retrazione
          OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
+         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+         Splitting.sStage = 'Head'
          MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
    ----------------------------------------------------------------------------------
       elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawHorizontal' then

Strategies/Standard/SPLITCUT/SPLITCUT.lua

@@ -1,425 +0,0 @@
--- Strategia: SPLITCUT
--- Descrizione
--- Taglio di separazione
--- Feature: SplitCut
-
--- 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 SPLITCUT = {}
-local Strategy = {}
-
--------------------------------------------------------------------------------------------------------------
-local function LoadStrategyParameters( CustomParameters)
-   local StrategyLib = {}
-   StrategyLib.Config = require( 'SPLITCUT\\SPLITCUTConfig')
-   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
-   -- elevazione sempre in negativo
-   if EdgeToMachine.Elev < 10 * GEO.EPS_SMALL then
-      LeadIn.dPerpDistance = BeamData.CUT_SIC - EdgeToMachine.Elev
-      LeadOut.dPerpDistance = BeamData.CUT_SIC - EdgeToMachine.Elev
-   else
-      LeadIn.dPerpDistance = BeamData.CUT_SIC
-      LeadOut.dPerpDistance = BeamData.CUT_SIC
-   end
-   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].Norm, 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 SPLITCUT.Make( bAddMachining, Proc, Part, CustomParameters)
-   Strategy = LoadStrategyParameters( CustomParameters)
-   local bAreAllMachiningsAdded = true
-   local Splitting = {}
-   local AuxiliaryData = {}
-
-   Strategy.sSplitStrategy = 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.sSplitStrategy.sTypeMachining == 'BladeSideSingle' then
-         OptionalParameters = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_BACK
-         OptionalParameters.sDepth = 0
-
-         -- TODO gestire lavorazione a cubetti
-
-         if Strategy.bSplit then
-            OptionalParameters.sUserNotes = 'Split;'
-         else
-            OptionalParameters.sUserNotes = 'Cut;'
-         end
-         AuxiliaryData.bAddNewPhase = true
-
-         local EdgeToMachine = GetEdgeToMachine( Proc, -Y_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
-         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
-   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeSideDouble' then
-         OptionalParameters = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
-         -- Taglio lato frontale
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_BACK
-         OptionalParameters.sDepth = 0
-         OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
-
-         -- TODO gestire lavorazione a cubetti
-
-         if Strategy.bSplit then
-            OptionalParameters.sUserNotes = 'PreSplit;'
-         else
-            OptionalParameters.sUserNotes = 'PreCut;'
-         end
-
-         local EdgeToMachine = GetEdgeToMachine( Proc, -Y_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
-         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
-   
-         -- Taglio lato dietro
-         OptionalParameters = {}
-         Splitting = {}
-         AuxiliaryData = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_FRONT
-         OptionalParameters.sDepth = 0
-         OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
-
-         -- TODO gestire lavorazione a cubetti
-
-         if Strategy.bSplit then
-            OptionalParameters.sUserNotes = 'Split;'
-         else
-            OptionalParameters.sUserNotes = 'Cut;'
-         end
-         AuxiliaryData.bAddNewPhase = true
-
-         EdgeToMachine = GetEdgeToMachine( Proc, Y_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
-         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
-   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeHorizontalSingle' then
-         OptionalParameters = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
-         OptionalParameters.sDepth = 0
-         OptionalParameters.dRadialOffset = -BeamData.CUT_EXTRA
-
-         -- TODO gestire lavorazione a cubetti
-
-         if Strategy.bSplit then
-            OptionalParameters.sUserNotes = 'Split;'
-         else
-            OptionalParameters.sUserNotes = 'Cut;'
-         end
-         AuxiliaryData.bAddNewPhase = true
-
-         local EdgeToMachine = GetEdgeToMachine( Proc, Z_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
-         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
-   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeHorizontalDouble' then
-         OptionalParameters = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
-         -- Taglio lato frontale
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
-         OptionalParameters.sDepth = 0
-         local dExtraMaxMat = ( Strategy.sSplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + Strategy.sSplitStrategy[2].ToolInfo.dMaxMatBladeFromDown - Part.dHeight - BeamData.CUT_EXTRA) / 2
-         OptionalParameters.dRadialOffset = Part.dHeight - Strategy.sSplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + dExtraMaxMat
-
-         -- TODO gestire lavorazione a cubetti
-
-         if Strategy.bSplit then
-            OptionalParameters.sUserNotes = 'PreSplit;'
-         else
-            OptionalParameters.sUserNotes = 'PreCut;'
-         end
-
-         local EdgeToMachine = GetEdgeToMachine( Proc, Z_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
-         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
-   
-         -- Taglio lato dietro
-         OptionalParameters = {}
-         Splitting = {}
-         AuxiliaryData = {}
-         OptionalParameters.nToolIndex = Strategy.sSplitStrategy[2].ToolInfo.nToolIndex
-         OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_TOP
-         OptionalParameters.sDepth = 0
-         OptionalParameters.dRadialOffset = Part.dHeight - Strategy.sSplitStrategy[2].ToolInfo.dMaxMatBladeFromDown + dExtraMaxMat
-
-         -- TODO gestire lavorazione a cubetti
-
-         if Strategy.bSplit then
-            OptionalParameters.sUserNotes = 'Split;'
-         else
-            OptionalParameters.sUserNotes = 'Cut;'
-         end
-         AuxiliaryData.bAddNewPhase = true
-
-         EdgeToMachine = GetEdgeToMachine( Proc, -Z_AX())
-         -- approccio e retrazione
-         OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
-         Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
-         MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
-   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawHorizontal' then
-         ; -- TODO
-   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawSideSingle' then
-         ; -- TODO
-   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawSideDouble' then
-         ; -- TODO
-   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawPlusBlade' then
-         ; -- TODO
-   ----------------------------------------------------------------------------------
-      elseif Strategy.sSplitStrategy.sTypeMachining == 'Mill' then
-         ; -- TODO
-   ----------------------------------------------------------------------------------
-      end
-
-      return bAreAllMachiningsAdded, Strategy.Result
-   else
-      return nil, Strategy.Result
-   end
-end
-
--------------------------------------------------------------------------------------------------------------
-
- return SPLITCUT

Strategies/Standard/STR0002/STR0002.lua

@@ -1,16 +1,15 @@
 -- Strategia: STR0002
 -- Descrizione 
 -- Svuotatura tasca
--- Feature tipo LapJpint
+-- Feature tipo LapJoint
 
 -------------------------------------------------------------------------------------------------------------
 -------------------------------------------------------------------------------------------------------------
 -- TODO
--- 1 - Controllare lavorazioni in caso di feature lunga spezzata
--- 2 - Inserire antischeggia (fresa o lama)
--- 3 - Modalità svuotatura con fresa grande e spigoli con fresa piccola
--- 4 - Smusso a V
--- 5 - Finitura con motosega (se la fresa non completa)
+-- 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)
 -------------------------------------------------------------------------------------------------------------
 -------------------------------------------------------------------------------------------------------------
 
@@ -360,29 +359,29 @@ local function GetSplitSurfaces( Proc, Part)
    end
 
    -- recupero punti di spezzatura - da destra a sinistra
-   local vFeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
+   local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
 
-   if #vFeatureSplittingPoints == 0 then
+   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, #vFeatureSplittingPoints do
+      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 = vFeatureSplittingPoints[i] + Vector3d( -BeamData.MILL_OVERLAP / 2, 0, 0)
+            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 = vFeatureSplittingPoints[i] + Vector3d( -BeamData.MILL_OVERLAP / 2, 0, 0)
+            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 = vFeatureSplittingPoints[i - 1] + Vector3d( BeamData.MILL_OVERLAP / 2, 0, 0)
+            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
@@ -392,7 +391,7 @@ local function GetSplitSurfaces( Proc, Part)
       -- 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 = vFeatureSplittingPoints[#vFeatureSplittingPoints] + Vector3d( BeamData.MILL_OVERLAP / 2, 0, 0)
+      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)
@@ -460,13 +459,30 @@ function STR0002.Make( bAddMachining, Proc, Part, CustomParameters)
                -- 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 settare parametro per indicare qual è lo spezzone che deve essere fatto dopo il taglio di separazione
+                  -- 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])
-                     vtNSplitFace =  EgtSurfTmFacetNormVersor( nIdTm, k - 1, GDB_ID.ROOT)
+                     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)

Strategies/Standard/STR0003/STR0003.lua

@@ -3,6 +3,16 @@
 -- 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')
@@ -62,9 +72,9 @@ end
 
 -- TODO si può unificare con eguale funzione in STR0004
 local function SortMachiningsBySegment( MachiningA, MachiningB)
-   if MachiningA.nSegment > MachiningB.nSegment then
+   if MachiningA.nFeatureSegment > MachiningB.nFeatureSegment then
       return false
-   elseif MachiningB.nSegment > MachiningA.nSegment then
+   elseif MachiningB.nFeatureSegment > MachiningA.nFeatureSegment then
       return true
    else
       if TOOLS[ MachiningA.nToolIndex].sFamily == 'SAWBLADE' and TOOLS[ MachiningB.nToolIndex].sFamily == 'MORTISE' then
@@ -88,9 +98,9 @@ local function SortMachiningsByTool( MachiningA, MachiningB)
    elseif TOOLS[ MachiningA.nToolIndex].sFamily == 'MORTISE' and TOOLS[ MachiningB.nToolIndex].sFamily == 'SAWBLADE' then
       return false
    else
-      if MachiningA.nSegment > MachiningB.nSegment then
+      if MachiningA.nFeatureSegment > MachiningB.nFeatureSegment then
          return false
-      elseif MachiningB.nSegment > MachiningA.nSegment then
+      elseif MachiningB.nFeatureSegment > MachiningA.nFeatureSegment then
          return true
       else
          if MachiningA.sEdgeType == 'Side' and MachiningB.sEdgeType ~= 'Side' then
@@ -233,7 +243,6 @@ end
 
 
 function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
-   -- TODO da implementare gestione feature lunghe e spezzatura
    -- carico parametri da default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
    local StrategyLib = {}
    StrategyLib.Config = require( 'STR0003\\STR0003Config')
@@ -268,10 +277,26 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
       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}
+   local OptionalParameters = { bForceLongcutBlade = Strategy.Parameters.bForceLongcutBlade, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
    if Proc.Topology.sFamily == 'Tunnel' then
+      OptionalParameters.bOppositeToolDirection = true
       Cutting = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
    else
       Cutting = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
@@ -279,6 +304,7 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
    Blade.AddResult( Cutting)
    -- lato opposto del tunnel
    if Proc.Topology.sFamily == 'Tunnel' then
+      OptionalParameters.bOppositeToolDirection = true
       Cutting = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
       Blade.AddResult( Cutting)
    else
@@ -286,11 +312,13 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
       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 = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
             Blade.AddResult( Cutting)
          end
          -- eventuale lavorazione di lama - lato della tasca in cui finisce la lavorazione
          if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsEndOpen then
+            OptionalParameters.bOppositeToolDirection = true
             Cutting = SlotByBlade.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
             Blade.AddResult( Cutting)
          end
@@ -303,11 +331,11 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
    -- lama - lavorazioni raggruppate in unica lista
    Blade.Result.Sorted = MergeResults( Blade.Result)
    -- lama - aggiunta eventuali lavorazioni splittate
-   local vFeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
-   if #vFeatureSplittingPoints > 0 then
-      Blade.Result.Sorted = MachiningLib.GetSplitMachinings( Blade.Result.Sorted, vFeatureSplittingPoints, Part)
+   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
@@ -354,18 +382,18 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
          ( 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}
+            local OptionalParameters = { sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Bottom[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
             Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
             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}
+            local OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result.Bottom[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
             Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
             Chainsaw.AddResult( Mortising)
          end
       -- si lavora tutto il fondo
       else
-         local OptionalParameters = { dMaxElev = Blade.Result.Bottom[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail}
+         local OptionalParameters = { dMaxElev = Blade.Result.Bottom[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
          Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
          Chainsaw.AddResult( Mortising)
       end
@@ -374,10 +402,10 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
          -- 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}
+               local OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result.Side[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
             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}
+               local OptionalParameters = { sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Side[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
             end
          -- si lavora tutto il lato
@@ -389,10 +417,10 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
                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}
+               local OptionalParameters = { dMaxElev = dBladeResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
             elseif Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsEndOpen then
-               local OptionalParameters = { dMaxElev = dBladeResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail}
+               local OptionalParameters = { dMaxElev = dBladeResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
             end
          end
@@ -401,7 +429,7 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
    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}
+         local OptionalParameters = { dMaxElev = Blade.Result.Bottom[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
          Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge, OptionalParameters)
          Chainsaw.AddResult( Mortising)
          -- ancora materiale residuo - si lavorano i lati
@@ -410,16 +438,16 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
             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}
+               local OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result.Side[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
                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}
+                  local OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'End', dLengthToMachine = Blade.Result.Side[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                   Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
                   Chainsaw.AddResult( Mortising)
                   OptionalParameters = {}
-                  OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Side[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail}
+                  OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Side[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                   Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
                   Chainsaw.AddResult( Mortising)
                   -- lavorando dai due lati non c'è materiale residuo - si può eliminare la lavorazione del fondo
@@ -429,17 +457,17 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
                end
             -- si lavora tutto il lato
             else
-               local OptionalParameters = { dMaxElev = Blade.Result.Side[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail}
+               local OptionalParameters = { dMaxElev = Blade.Result.Side[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
                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}
+                  local OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Side[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                   Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
                   Chainsaw.AddResult( Mortising)
                   OptionalParameters = {}
-                  OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Side[2].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail}
+                  OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Side[2].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
                   Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
                   Chainsaw.AddResult( Mortising)
                   -- lavorando dai due lati non c'è materiale residuo - si può disabilitare la lavorazione del fondo
@@ -455,44 +483,44 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
       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}
+         local OptionalParameters = { sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Opposite[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
          Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
          Chainsaw.AddResult( Mortising)
          OptionalParameters = {}
-         OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result.Opposite[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail}
+         OptionalParameters = { sSideToMachine = 'End', dLengthToMachine = Blade.Result.Opposite[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
          Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
          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}
+            local OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Opposite[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
             Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
             Chainsaw.AddResult( Mortising)
             OptionalParameters = {}
-            OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'End', dLengthToMachine = Blade.Result.Opposite[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail}
+            OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'End', dLengthToMachine = Blade.Result.Opposite[1].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
             Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
             Chainsaw.AddResult( Mortising)
             OptionalParameters = {}
-            OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Opposite[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail}
+            OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'Start', dLengthToMachine = Blade.Result.Opposite[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
             Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
             Chainsaw.AddResult( Mortising)
             OptionalParameters = {}
-            OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'End', dLengthToMachine = Blade.Result.Opposite[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail}
+            OptionalParameters = { bStopAtHalfElevation = true, sSideToMachine = 'End', dLengthToMachine = Blade.Result.Opposite[2].dBladeMarkLength, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
             Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
             Chainsaw.AddResult( Mortising)
          end
       else
-         local OptionalParameters = { dMaxElev = Blade.Result.Opposite[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail}
+         local OptionalParameters = { dMaxElev = Blade.Result.Opposite[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
          Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
          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}
-            SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
+            local OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Opposite[1].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
+            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
             Chainsaw.AddResult( Mortising)
             OptionalParameters = {}
-            OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Opposite[2].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail}
-            SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
+            OptionalParameters = { bStopAtHalfElevation = true, dMaxElev = Blade.Result.Opposite[2].dResidualDepth + BeamData.CUT_EXTRA, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
+            Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
             Chainsaw.AddResult( Mortising)
          end
       end
@@ -500,8 +528,8 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
    -- sega a catena - lavorazioni raggruppate in unica lista
    Chainsaw.Result.Sorted = MergeResults( Chainsaw.Result)
    -- sega a catena - aggiunta eventuali lavorazioni splittate
-   if #vFeatureSplittingPoints > 0 then
-      Chainsaw.Result.Sorted = MachiningLib.GetSplitMachinings( Chainsaw.Result.Sorted, vFeatureSplittingPoints, Part)
+   if bIsSplitFeature then
+      Chainsaw.Result.Sorted = MachiningLib.GetSplitMachinings( Chainsaw.Result.Sorted, FeatureSplittingPoints, Part)
    end
 
    -- tutte le lavorazioni di tutti gli utensili in unica lista

Strategies/Standard/STR0004/STR0004.lua

@@ -3,6 +3,16 @@
 -- 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')
@@ -57,10 +67,11 @@ local function GetCompletionPercentage( Proc, Result)
 end
 
 
+-- TODO si può unificare con Sorting generale
 local function SortMachiningsBySegment( MachiningA, MachiningB)
-   if MachiningA.nSegment > MachiningB.nSegment then
+   if MachiningA.nFeatureSegment > MachiningB.nFeatureSegment then
       return false
-   elseif MachiningB.nSegment > MachiningA.nSegment then
+   elseif MachiningB.nFeatureSegment > MachiningA.nFeatureSegment then
       return true
    else
       if MachiningA.sEdgeType == 'Side' and MachiningB.sEdgeType ~= 'Side' then
@@ -121,7 +132,6 @@ end
 
 
 function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
-   -- TODO da implementare gestione feature lunghe e spezzatura
    -- carico parametri da default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
    local StrategyLib = {}
    StrategyLib.Config = require( 'STR0004\\STR0004Config')
@@ -149,48 +159,63 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
       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 = {}
-   OptionalParameters = { dExtendAfterTail = dExtendAfterTail}
+   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
-      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail}
       Mortising = SlotByChainSaw.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
-            local OptionalParameters = { dExtendAfterTail = dExtendAfterTail}
+            OptionalParameters.bOppositeToolDirection = true
             Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
          elseif Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.bIsEndOpen then
-            local OptionalParameters = { dExtendAfterTail = dExtendAfterTail}
+            OptionalParameters.bOppositeToolDirection = true
             Mortising = SlotByChainSaw.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}
+      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bIsSplitFeature = bIsSplitFeature}
       Mortising = SlotByChainSaw.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}
+         local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
          Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
          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}
+            local OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
             Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1], OptionalParameters)
             Chainsaw.AddResult( Mortising)
             OptionalParameters = {}
-            OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail}
+            OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
             Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2], OptionalParameters)
             Chainsaw.AddResult( Mortising)
             -- lavorando dai due lati non c'è materiale residuo - si può disabilitare la lavorazione del fondo
@@ -200,16 +225,16 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
          end
       end
    elseif Proc.Topology.sName == 'Tunnel-4-Through' then
-      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail}
+      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
       Mortising = SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
       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}
+         local OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
          SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1], OptionalParameters)
          Chainsaw.AddResult( Mortising)
          OptionalParameters = {}
-         OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail}
+         OptionalParameters = { bStopAtHalfElevation = true, dExtendAfterTail = dExtendAfterTail, dPocketHeight = dPocketHeight, bOppositeToolDirection = true, bIsSplitFeature = bIsSplitFeature}
          SlotByChainSaw.Make( Proc, Part, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2], OptionalParameters)
          Chainsaw.AddResult( Mortising)
       end
@@ -234,9 +259,8 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
    end
 
    -- aggiunta eventuali lavorazioni splittate
-   local vFeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
-   if #vFeatureSplittingPoints > 0 then
-      Chainsaw.Result.Sorted = MachiningLib.GetSplitMachinings( Chainsaw.Result.Sorted, vFeatureSplittingPoints, Part)
+   if bIsSplitFeature then
+      Chainsaw.Result.Sorted = MachiningLib.GetSplitMachinings( Chainsaw.Result.Sorted, FeatureSplittingPoints, Part)
    end
 
    -- ordinamento

Strategies/Standard/STR0005/STR0005.lua

@@ -0,0 +1,241 @@
+-- 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 SlotByBlade = require( 'SLOTBYBLADE')
+
+-- 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 = {}
+
+   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 MRRParametersBlade = {}
+
+   if bFeatureHindersClamping or bLeaveWasteAttached then
+      -- TODO Lavorazione con codolo
+            -- attenzione perchè se l'inclinazione della faccia la fa finire oltre lo spigolo questo riduce il massimo calcolare (come calcolare????)
+      -- 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)
+      
+      -- 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
+
+      -- ricerca utensile
+      local ToolSearchParameters = {}
+      ToolSearchParameters.dElevation = dDepthToMachine
+      ToolSearchParameters.vtToolDirection = EdgesSorted[1].vtN
+      ToolSearchParameters.bAllowTopHead = true
+      ToolSearchParameters.bAllowBottomHead = true
+      ToolSearchParameters.bForceLongcutBlade = Strategy.Parameters.bForceLongcutBlade
+      local ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
+      Cutting.nToolIndex = ToolInfo.nToolIndex
+      Cutting.nType = MCH_OY.MILLING
+      if not TOOLS[Cutting.nToolIndex].sName then
+         Cutting.sMessage = 'Blade not found'
+         Cutting.bIsApplicable = false
+         EgtOutLog( Cutting.sMessage)
+         return Cutting, EdgesSorted[1].dElevation
+      end
+
+      -- parametri per il calcolo della velocità di asportazione
+      MRRParametersBlade = {
+                            dStep = min( TOOLS[Cutting.nToolIndex].dStep, EdgesSorted[1].dElevation),
+                            dSideStep = TOOLS[Cutting.nToolIndex].dThickness,
+                            dFeed = TOOLS[Cutting.nToolIndex].Feeds.dFeed
+                           }
+      
+      -- eventuali punti di spezzatura
+      local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
+      local bIsSplitFeature = false
+      if #FeatureSplittingPoints > 0 then
+         bIsSplitFeature = true
+      end
+
+      -- primo lato
+      local OptionalParameters = { dDepthToMachine = dDepthToMachine, nToolIndex = Cutting.nToolIndex, bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail}
+      Cutting = SlotByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[1], OptionalParameters)
+      Blade.AddResult( Cutting)
+      -- secondo lato
+      Cutting = SlotByBlade.Make( Proc, Part, Proc.Faces[1], EdgesSorted[2], OptionalParameters)
+      Blade.AddResult( Cutting)
+
+      -- 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)
+
+      -- 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
+   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')
+   local dMRRBlade = MachiningLib.GetToolMRR( MRRParametersBlade)
+   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

@@ -1,12 +1,13 @@
--- Parametri configurabili da cliente per strategia: SPLITCUT
+-- Parametri configurabili da cliente per strategia: TAILCUT
 
-local SPLITCUTData = {
-   sStrategyId = 'SPLITCUT',
+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 SPLITCUTData
+return TAILCUTData

Strategies/Strategies.ini

@@ -3,11 +3,13 @@
 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,
+10,1,Feature,STR0005
 ;Feature : Longitudinal Cut
 10,0,Feature,
 ;Feature : Double Cut
@@ -139,8 +141,8 @@ STR0003 = Topologia tipo LapJoint. Lama + motosega
 252,0,Feature,
 ; Feature : HEADCUT
 340,0,Feature,HEADCUT
-; Feature : SPLITCUT
-350,0,Feature,SPLITCUT
+; Feature : TAILCUT
+350,0,Feature,TAILCUT
 ; Feature : Variant
 900,0,Feature,
 ; Feature Decor

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

@@ -23,13 +23,8 @@ local function CalculateLeadInOut( EdgeToMachine)
    LeadIn.dTangentDistance = 0
    LeadOut.dTangentDistance = 0
    -- elevazione sempre in negativo
-   if EdgeToMachine.Elev < 10 * GEO.EPS_SMALL then
-      LeadIn.dPerpDistance = BeamData.CUT_SIC - EdgeToMachine.Elev
-      LeadOut.dPerpDistance = BeamData.CUT_SIC - EdgeToMachine.Elev
-   else
-      LeadIn.dPerpDistance = BeamData.CUT_SIC
-      LeadOut.dPerpDistance = BeamData.CUT_SIC
-   end
+   LeadIn.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
+   LeadOut.dPerpDistance = BeamData.CUT_SIC + EdgeToMachine.dElevation
    LeadIn.dElevation = 0
    LeadOut.dElevation = 0
    LeadIn.dCompLength = 0
@@ -67,16 +62,19 @@ end
 function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalParameters)
    local Cutting = {}
 
-   local vtMachiningDirection = EdgeToMachine.Norm
-   local vtN = Proc.Faces[FaceToMachine+1].vtN
+   local vtMachiningDirection = EdgeToMachine.vtN
+   local vtN = Proc.Faces[FaceToMachine.id+1].vtN
    Cutting.sDepth = OptionalParameters.sDepth or 0
+   Cutting.dLongitudinalOffset = OptionalParameters.dLongitudinalOffset or 0
    Cutting.dRadialOffset = OptionalParameters.dRadialOffset or 0
 
    Cutting.nType = MCH_MY.MILLING
    Cutting.nToolIndex = OptionalParameters.nToolIndex
-   Cutting.Geometry = {{ Proc.id, FaceToMachine}}
+   Cutting.Geometry = {{ Proc.id, FaceToMachine.id}}
    Cutting.id = Proc.id
+   Cutting.vtToolDirection = vtMachiningDirection
 
+   -- TODO se l'utensile non arriva dai parametri opzionali va cercato!!
 
    -- ===== calcolo LeadIn/out =====
    if OptionalParameters.LeadIn and OptionalParameters.LeadOut then

StrategyLibs/SLOTBYBLADE.lua

@@ -31,7 +31,7 @@ local function CalculateLeadInOut( Machining, EdgeToMachine)
    LeadOut.nType = MCH_MILL_LI.LINEAR
    LeadIn.dTangentDistance = 0
    LeadOut.dTangentDistance = 0
-   if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
+   if AreSameVectorApprox( Machining.vtToolDirection, EdgeToMachine.vtN) then
       LeadIn.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC
       LeadOut.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC
    else
@@ -90,10 +90,10 @@ function SLOTBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
    Cutting.dDepthToMachine = 0
    Cutting.sMessage = ''
    Cutting.idProc = Proc.id
-   Cutting.dResidualDepth = abs( EdgeToMachine.dElevation)
+   Cutting.dResidualDepth = EdgeToMachine.dElevation
    Cutting.dBladeMarkLength = 0
    Cutting.sEdgeType = EdgeToMachine.sType
-   Cutting. nSegment = 1
+   Cutting.nFeatureSegment = 1
 
    -- parametri opzionali
    if not OptionalParameters then
@@ -101,29 +101,30 @@ function SLOTBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
    end
    local bForceLongcutBlade = OptionalParameters.bForceLongcutBlade or false
    local dExtendAfterTail = OptionalParameters.dExtendAfterTail or 10000
+   local dPocketHeight = OptionalParameters.dPocketHeight or 0
+   local dDepthToMachine = min( OptionalParameters.dDepthToMachine or EdgeToMachine.dElevation, EdgeToMachine.dElevation)
+   local bIsSplitFeature = OptionalParameters.bIsSplitFeature or false
+   local bOppositeToolDirection = OptionalParameters.bOppositeToolDirection or false
 
    -- lunghezze e punti caratteristici della lavorazione e del lato lavorato
    Cutting.dLengthToMachine = EdgeToMachine.dLength
-   Cutting.dLengthOnX = abs( EdgeToMachine.dLength * EdgeToMachine.vtToolDirection:getY())
    Cutting.dEdgeLength = EdgeToMachine.dLength
-   Cutting.ptEdge1, _, Cutting.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -EdgeToMachine.vtToolDirection, GDB_ID.ROOT)
-   Cutting.vtEdgeDirection = EdgeToMachine.vtToolDirection ^ FaceToMachine.vtN
-
-   local dPocketHeight = 0
-   if Proc.Topology.sFamily == 'Tunnel' then
-      dPocketHeight = Proc.MainFaces.SideFaces[1].MainEdges.OppositeEdges[1].dLength
+   if bOppositeToolDirection then
+      Cutting.vtToolDirection = -EdgeToMachine.vtN
    else
-      if FaceToMachine.sType == 'Long' then
-         dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
-      elseif FaceToMachine.sType == 'Side' then
-         dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.LongEdges[1].dLength
-      end
+      Cutting.vtToolDirection = EdgeToMachine.vtN
    end
+   Cutting.vtEdgeDirection = EdgeToMachine.vtN ^ FaceToMachine.vtN
+   -- TODO conviene spostare questi calcoli nel FaceData?
+   Cutting.ptEdge1, _, Cutting.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -Cutting.vtToolDirection, GDB_ID.ROOT)
+   local b3BoxEdge = BBox3d( Cutting.ptEdge1, Cutting.ptEdge2)
+   Cutting.dLengthOnX = b3BoxEdge:getDimX()
+   --
 
    -- ricerca utensile
    local ToolSearchParameters = {}
-   ToolSearchParameters.dElevation = abs( EdgeToMachine.dElevation)
-   ToolSearchParameters.vtToolDirection = EdgeToMachine.vtToolDirection
+   ToolSearchParameters.dElevation = EdgeToMachine.dElevation
+   ToolSearchParameters.vtToolDirection = Cutting.vtToolDirection
    ToolSearchParameters.bAllowTopHead = true
    ToolSearchParameters.bAllowBottomHead = false
    ToolSearchParameters.bForceLongcutBlade = bForceLongcutBlade
@@ -139,13 +140,13 @@ function SLOTBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
 
    -- verifica dimensioni tasca compatibili
    -- se tasca meno spessa della lama la strategia non è applicabile
-   if TOOLS[Cutting.nToolIndex].dThickness > dPocketHeight + 10 * GEO.EPS_SMALL then
+   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.SideFaces) > 1 then
+   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'
@@ -169,7 +170,7 @@ function SLOTBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       Cutting.nWorkside = MCH_MILL_WS.LEFT
       Cutting.bInvert = false
    end
-   if EdgeToMachine.dElevation < -10 * GEO.EPS_SMALL then
+   if bOppositeToolDirection then
       Cutting.bInvert = not Cutting.bInvert
    end
    -- TODO gestire lama da sotto e lama downUp
@@ -180,22 +181,22 @@ function SLOTBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       Cutting.bToolInvert = false
    end
    -- profondità da lavorare e offset radiale
-   if TOOLS[Cutting.nToolIndex].dMaxDepth > abs( EdgeToMachine.dElevation) - 10 * GEO.EPS_SMALL then
+   if TOOLS[Cutting.nToolIndex].dMaxDepth > dDepthToMachine - 10 * GEO.EPS_SMALL then
       -- TODO la depth dovrebbe essere quella del machining
-      Cutting.dDepthToMachine = abs( EdgeToMachine.dElevation)
+      Cutting.dDepthToMachine = dDepthToMachine
       Cutting.dResidualDepth = 0
-      if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
-         Cutting.dRadialOffset = 0
+      if bOppositeToolDirection then
+         Cutting.dRadialOffset = -dDepthToMachine
       else
-         Cutting.dRadialOffset = EdgeToMachine.dElevation
+         Cutting.dRadialOffset = EdgeToMachine.dElevation - dDepthToMachine
       end
    else
       Cutting.dDepthToMachine = TOOLS[Cutting.nToolIndex].dMaxDepth - 1
-      Cutting.dResidualDepth = abs( EdgeToMachine.dElevation) - Cutting.dDepthToMachine
-      if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
-         Cutting.dRadialOffset = EdgeToMachine.dElevation - Cutting.dDepthToMachine
-      else
+      Cutting.dResidualDepth = EdgeToMachine.dElevation - Cutting.dDepthToMachine
+      if bOppositeToolDirection then
          Cutting.dRadialOffset = -Cutting.dDepthToMachine
+      else
+         Cutting.dRadialOffset = EdgeToMachine.dElevation - Cutting.dDepthToMachine
       end
    end
    -- completamento
@@ -214,13 +215,13 @@ function SLOTBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
    -- overlap
    Cutting.dOverlap = 0
    -- faceuse
-   if EdgeToMachine.dElevation > - 10 * GEO.EPS_SMALL then
-      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( EdgeToMachine.vtToolDirection)
+   if bOppositeToolDirection then
+      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( -Cutting.vtToolDirection)
    else
-      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( -EdgeToMachine.vtToolDirection)
+      Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( Cutting.vtToolDirection)
    end
    -- SCC
-   Cutting.nSCC = GetSCC( EdgeToMachine.vtToolDirection)
+   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
@@ -242,28 +243,33 @@ function SLOTBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       Cutting.dBladeMarkLength = abs( Cutting.LeadOut.dEndAddLength)
    end
    -- geometria
-   Cutting.Geometry = {{Proc.id, FaceToMachine.id}}
+   Cutting.Geometry = {{Cutting.idProc, FaceToMachine.id}}
    -- nome operazione
    Cutting.sOperationName = 'Cut_' .. ( EgtGetName( Cutting.idProc) or tostring( Cutting.idProc)) .. '_' .. tostring( FaceToMachine.id + 1)
 
    -- se lavorazione aperta sulla coda, eventuali aggiustamenti
    -- TODO valutare se fare funzione a parte
-   if Proc.AffectedFaces.bLeft then
+   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.vtToolDirection, Y_AX()) then
-         if MachiningLib.CanMoveAfterSplitcut( Cutting.dLengthOnX, Part) then
-            Cutting.bMoveAfterSplitcut = true
+      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( Cutting.dLengthOnX, Part) then
-            Cutting.bMoveAfterSplitcut = true
+         if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
+            Cutting.sStage = 'AfterTail'
          else
             if bStartLeft then
                Cutting.LeadIn.dStartAddLength = - dAddLengthToReduce + dExtendAfterTail

StrategyLibs/SLOTBYCHAINSAW.lua

@@ -52,11 +52,11 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
    local Mortising = {}
    Mortising.bIsApplicable = true
    Mortising.dDepthToMachine = 0
-   Mortising.dResidualDepth = abs( EdgeToMachine.dElevation)
+   Mortising.dResidualDepth = EdgeToMachine.dElevation
    Mortising.sMessage = ''
    Mortising.idProc = Proc.id
    Mortising.sEdgeType = EdgeToMachine.sType
-   Mortising.nSegment = 1
+   Mortising.nFeatureSegment = 1
 
    -- parametri opzionali
    if not OptionalParameters then
@@ -65,28 +65,26 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
    local bUseZigZagMortising = OptionalParameters.bUseZigZagMortising or false
    local sSideToMachine = OptionalParameters.sSideToMachine or ''
    local dLengthToMachine = OptionalParameters.dLengthToMachine or EdgeToMachine.dLength
-   local dCustomMaxElev = OptionalParameters.dMaxElev or abs( EdgeToMachine.dElevation)
+   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
 
    -- lunghezze e punti caratteristici della lavorazione e del lato lavorato
    Mortising.dLengthToMachine = dLengthToMachine
-   Mortising.dLengthOnX = abs( dLengthToMachine * EdgeToMachine.vtToolDirection:getY())
+   -- 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
-   Mortising.ptEdge1, _, Mortising.ptEdge2 = EgtSurfTmFacetOppositeSide( Proc.id, FaceToMachine.id, -EdgeToMachine.vtToolDirection, GDB_ID.ROOT)
-   Mortising.vtEdgeDirection = EdgeToMachine.vtToolDirection ^ FaceToMachine.vtN
-
-   -- altezza tasca, in base alla topologia
-   local dPocketHeight = 0
-   if Proc.Topology.sFamily == 'Tunnel' then
-      dPocketHeight = Proc.MainFaces.SideFaces[1].MainEdges.OppositeEdges[1].dLength
+   if bOppositeToolDirection then
+      Mortising.vtToolDirection = -EdgeToMachine.vtN
    else
-      if FaceToMachine.sType == 'Long' then
-         dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
-      elseif FaceToMachine.sType == 'Side' then
-         dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.LongEdges[1].dLength
-      end
+      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
@@ -95,17 +93,17 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
          ( EdgeToMachine.sType == 'Opposite' and Proc.Topology.sFamily == 'Tunnel') then
             
          bExtendWithCornerRadius = true
-         Mortising.dDepthToMachine = abs( EdgeToMachine.dElevation) + BeamData.CUT_EXTRA
+         Mortising.dDepthToMachine = EdgeToMachine.dElevation + BeamData.CUT_EXTRA
       else
-         Mortising.dDepthToMachine = abs( EdgeToMachine.dElevation)
+         Mortising.dDepthToMachine = EdgeToMachine.dElevation
       end
    else
       bExtendWithCornerRadius = true
-      Mortising.dDepthToMachine = abs( EdgeToMachine.dElevation) / 2 + BeamData.CUT_EXTRA_MIN
+      Mortising.dDepthToMachine = EdgeToMachine.dElevation / 2 + BeamData.CUT_EXTRA_MIN
    end
    local ToolSearchParameters = {}
    local ToolInfo = {}
-   ToolSearchParameters.vtToolDirection = EdgeToMachine.vtToolDirection
+   ToolSearchParameters.vtToolDirection = Mortising.vtToolDirection
    ToolSearchParameters.bAllowTopHead = true
    ToolSearchParameters.bAllowBottomHead = true
    ToolSearchParameters.dElevation = Mortising.dDepthToMachine
@@ -122,13 +120,13 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
 
    -- verifica dimensioni tasca compatibili
    -- se tasca meno spessa della sega a catena la strategia non è applicabile
-   if TOOLS[Mortising.nToolIndex].dThickness > dPocketHeight + 10 * GEO.EPS_SMALL then
+   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.SideFaces) > 1 then
+   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'
@@ -147,12 +145,12 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
    Mortising.bIsEndClosed = not EdgeToMachine.bIsEndOpen
    -- lato di lavoro e inversioni
    Mortising.bInvert = false
-   if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
-      Mortising.nWorkside = MCH_MILL_WS.RIGHT
-      Mortising.bToolInvert = false
-   else
+   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
@@ -160,19 +158,19 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
    end
    if TOOLS[Mortising.nToolIndex].dMaxMaterial > Mortising.dDepthToMachine - 10 * GEO.EPS_SMALL then
       Mortising.dResidualDepth = 0
-      if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
-         Mortising.dLongitudinalOffset = 0
-      else
-         Mortising.dLongitudinalOffset = abs( EdgeToMachine.dElevation) - Mortising.dDepthToMachine
-      end
-   else
-      Mortising.dDepthToMachine = TOOLS[Mortising.nToolIndex].dMaxMaterial - 1
-      Mortising.dResidualDepth = abs( EdgeToMachine.dElevation) - Mortising.dDepthToMachine
-      if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
+      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
@@ -185,7 +183,7 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
    -- offset radiale
    Mortising.dRadialOffset = 0
    -- distanza di sicurezza
-   Mortising.dStartSafetyLength = max( EdgeToMachine.dElevation, 10)
+   Mortising.dStartSafetyLength = max( EdgeToMachine.dElevation, ( TOOLS[Mortising.nToolIndex].SetupInfo.dZSafeDelta or 60) + EgtMdbGetGeneralParam( MCH_GP.SAFEZ))
    -- overlap
    Mortising.dOverlap = 0
    -- step
@@ -197,21 +195,21 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
    end
    Mortising.Steps.dStep = TOOLS[Mortising.nToolIndex].dStep
    -- faceuse
-   if EdgeToMachine.dElevation > - 10 * GEO.EPS_SMALL then
-      Mortising.nFaceuse = BeamLib.GetNearestParalOpposite( EdgeToMachine.vtToolDirection)
+   if bOppositeToolDirection then
+      Mortising.nFaceuse = BeamLib.GetNearestParalOpposite( -Mortising.vtToolDirection)
    else
-      Mortising.nFaceuse = BeamLib.GetNearestParalOpposite( -EdgeToMachine.vtToolDirection)
+      Mortising.nFaceuse = BeamLib.GetNearestParalOpposite( Mortising.vtToolDirection)
    end
    -- SCC
    Mortising.SCC = MCH_SCC.NONE
    -- asse bloccato e angoli suggeriti
-   local vtRes = FaceToMachine.vtN ^ EdgeToMachine.vtToolDirection
+   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.vtToolDirection, 1)
-   elseif EdgeToMachine.vtToolDirection:getZ() < 10 * GEO.EPS_SMALL then
+      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.vtToolDirection, 2)
+      Mortising.sSuggestedAngles = BeamLib.GetChainSawInitAngs( FaceToMachine.vtN, EdgeToMachine.vtN, 2)
    end
    -- approccio e retrazione
    Mortising.LeadIn, Mortising.LeadOut = CalculateLeadInOut( Mortising, EdgeToMachine, sSideToMachine, dLengthToMachine)
@@ -224,21 +222,26 @@ function SLOTBYCHAINSAW.Make( Proc, Part, FaceToMachine, EdgeToMachine, Optional
 
    -- se lavorazione aperta sulla coda, eventuali aggiustamenti
    -- TODO valutare se fare funzione a parte
-   if Proc.AffectedFaces.bLeft then
+   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.vtToolDirection, Y_AX()) then
-         if MachiningLib.CanMoveAfterSplitcut( Mortising.dLengthOnX, Part) then
-            Mortising.bMoveAfterSplitcut = true
+      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( Mortising.dLengthOnX, Part) then
-            Mortising.bMoveAfterSplitcut = true
+         if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
+            Mortising.sStage = 'AfterTail'
          else
             if bStartLeft then
                Mortising.LeadIn.dStartAddLength = - TOOLS[Mortising.nToolIndex].dDiameter / 2 + dExtendAfterTail

StrategyLibs/SPLITCUT.lua

@@ -0,0 +1,361 @@
+-- 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.nFaceuse = MCH_MILL_FU.ORTHO_BACK
+      OptionalParameters.sDepth = 0
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Split;', 'Cut;')
+
+      Machining.AuxiliaryData.bIsSplitOrCut = true
+
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Y_AX())
+      -- approccio e retrazione
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+
+  ----------------------------------------------------------------------------------
+   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.nFaceuse = MCH_MILL_FU.ORTHO_BACK
+      OptionalParameters.sDepth = 0
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
+      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Presplit;', 'Precut;')
+
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Y_AX())
+      -- approccio e retrazione
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+
+      -- Taglio lato dietro
+      Machining = {}
+      Machining.Splitting = {}
+      Machining.AuxiliaryData = {}
+      OptionalParameters = {}
+      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_FRONT
+      OptionalParameters.sDepth = 0
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
+      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Split;', 'Cut;')
+
+      Machining.AuxiliaryData.bIsSplitOrCut = true
+
+      EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, Y_AX())
+      -- approccio e retrazione
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+  ----------------------------------------------------------------------------------
+   elseif Strategy.SplitStrategy.sTypeMachining == 'BladeHorizontalSingle' then
+      local Machining = {}
+      Machining.Splitting = {}
+      Machining.AuxiliaryData = {}
+      local OptionalParameters = {}
+      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
+      OptionalParameters.sDepth = 0
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      OptionalParameters.dRadialOffset = -BeamData.CUT_EXTRA
+      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Split;', 'Cut;')
+
+      Machining.AuxiliaryData.bIsSplitOrCut = true
+
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, Z_AX())
+      -- approccio e retrazione
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+  ----------------------------------------------------------------------------------
+   elseif Strategy.SplitStrategy.sTypeMachining == 'BladeHorizontalDouble' then
+      local Machining = {}
+      Machining.Splitting = {}
+      Machining.AuxiliaryData = {}
+      local OptionalParameters = {}
+      OptionalParameters.nToolIndex = Strategy.SplitStrategy[1].ToolInfo.nToolIndex
+      -- Taglio lato frontale
+      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
+      OptionalParameters.sDepth = 0
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      local dExtraMaxMat = ( Strategy.SplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + Strategy.SplitStrategy[2].ToolInfo.dMaxMatBladeFromDown - Part.dHeight - BeamData.CUT_EXTRA) / 2
+      OptionalParameters.dRadialOffset = Part.dHeight - Strategy.SplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + dExtraMaxMat
+      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Presplit;', 'Precut;')
+
+
+      local EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, Z_AX())
+      -- approccio e retrazione
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+
+      -- Taglio lato dietro
+      Machining = {}
+      Machining.Splitting = {}
+      Machining.AuxiliaryData = {}
+      OptionalParameters = {}
+      OptionalParameters.nToolIndex = Strategy.SplitStrategy[2].ToolInfo.nToolIndex
+      OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_TOP
+      OptionalParameters.sDepth = 0
+      OptionalParameters.dLongitudinalOffset = Strategy.dOffset or 0
+      OptionalParameters.dRadialOffset = Part.dHeight - Strategy.SplitStrategy[2].ToolInfo.dMaxMatBladeFromDown + dExtraMaxMat
+      OptionalParameters.sUserNotes = EgtIf( Strategy.bSplit, 'Split;', 'Cut;')
+
+      Machining.AuxiliaryData.bIsSplitOrCut = true
+
+      EdgeToMachine = SPLITCUT.GetEdgeToMachine( Proc, -Z_AX())
+      -- approccio e retrazione
+      OptionalParameters.LeadIn, OptionalParameters.LeadOut = SPLITCUT.CalculateLeadInOut( EdgeToMachine)
+      Machining.Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParameters)
+      table.insert( Machinings, Machining)
+  ----------------------------------------------------------------------------------
+   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