- in BeamExec si pulisce il tempgroup dopo ogni chiamata della Make di una strategia (evita problemi di memoria)

- in BeamLib aggiunte funzioni ReverseTablePortionInPlace e RotateTableFromIndexInPlace

LuaLibs/BeamExec.lua

@@ -822,7 +822,33 @@ local function AreDrillingsMirrored( Proc, ProcMirror, Part)
 end
 
 -------------------------------------------------------------------------------------------------------------
-local function GetFeatureInfoAndDependency( vProcSingleRot, Part, bIsFlipRot)
+local function GetHeadTailInfoForNesting( HeadProc, TailProc, Part)
+   -- per nesting, si settano come info gli offset X degli estremi dei tagli
+   local HeadcutInfo = {}
+   local PtSortedHead = BeamLib.GetSortedVertices( HeadProc)
+   if PtSortedHead then
+      HeadcutInfo.OffsetX = {}
+      for i = 1, #PtSortedHead do
+         table.insert( HeadcutInfo.OffsetX, Part.b3Part:getMax():getX() - PtSortedHead[i]:getX())
+      end
+   end
+   local TailcutInfo = {}
+   local PtSortedTail = BeamLib.GetSortedVertices( TailProc)
+   if PtSortedTail then
+      TailcutInfo.OffsetX = {}
+      for i = 1, #PtSortedTail do
+         table.insert( TailcutInfo.OffsetX, Part.b3Part:getMin():getX() - PtSortedTail[i]:getX())
+      end
+   end
+   -- per nesting, si settano come info le normali delle facce di taglio
+   HeadcutInfo.vtN = Vector3d( HeadProc.Faces[1].vtN)
+   TailcutInfo.vtN = Vector3d( TailProc.Faces[1].vtN)
+
+   return HeadcutInfo, TailcutInfo
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetFeatureInfoAndDependency( vProcSingleRot, Part)
    -- gruppo per geometrie temporanee
    local idTempGroup = BeamLib.GetTempGroup()
 
@@ -966,10 +992,6 @@ local function GetFeatureInfoAndDependency( vProcSingleRot, Part, bIsFlipRot)
       end
    end
 
-   if not Part.GeneralParameters.GEN_bGetAlternativesNesting2D then
-      return vProcSingleRot
-   end
-
    -- si tiene via il riferimento alla Proc Head/Tail originale in caso si dovesse rimpiazzare
    HeadProcOriginal.bIsOriginalHeadcut = true
    TailProcOriginal.bIsOriginalTailcut = true
@@ -984,36 +1006,22 @@ local function GetFeatureInfoAndDependency( vProcSingleRot, Part, bIsFlipRot)
       TailProc.TailProcOriginal = TailProcOriginal
    end
 
+   if not Part.GeneralParameters.GEN_bGetAlternativesNesting2D then
+      return vProcSingleRot
+   end
+
    HeadProc.Topology = {}
    TailProc.Topology = {}
+   HeadProc.Topology.bIsThrough = true
    HeadProc.Topology.sFamily = 'HeadCut'
    HeadProc.Topology.sName = 'HeadCut'
+   TailProc.Topology.bIsThrough = true
    TailProc.Topology.sFamily = 'TailCut'
    TailProc.Topology.sName = 'TailCut'
    HeadProc.AvailableStrategies = GetStrategies( HeadProc, Part.sAISetupConfig)
    TailProc.AvailableStrategies = GetStrategies( TailProc, Part.sAISetupConfig)
-   -- per nesting, si settano come info gli offset X degli estremi dei tagli
-   local HeadcutInfo = {}
-   local PtSortedHead = BeamLib.GetSortedVertices( HeadProc)
-   if PtSortedHead then
-      HeadcutInfo.OffsetX = {}
-      for i = 1, #PtSortedHead do
-         table.insert( HeadcutInfo.OffsetX, Part.b3Part:getMax():getX() - PtSortedHead[i]:getX())
-      end
-   end
-   local TailcutInfo = {}
-   local PtSortedTail = BeamLib.GetSortedVertices( TailProc)
-   if PtSortedTail then
-      TailcutInfo.OffsetX = {}
-      for i = 1, #PtSortedTail do
-         table.insert( TailcutInfo.OffsetX, Part.b3Part:getMin():getX() - PtSortedTail[i]:getX())
-      end
-   end
-   -- per nesting, si settano come info le normali delle facce di taglio
-   HeadcutInfo.vtN = HeadProc.Faces[1].vtN
-   TailcutInfo.vtN = TailProc.Faces[1].vtN
 
-   return vProcSingleRot, HeadcutInfo, TailcutInfo
+   return vProcSingleRot
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -1131,64 +1139,109 @@ end
 -------------------------------------------------------------------------------------------------------------
 -- funzione che processa tutte le feature del pezzo
 local function CalculateStrategies( vProcSingleRot, Part)
-   -- per ogni feature
+   local nCounter = 0
-   for i = 1, #vProcSingleRot do
+   repeat
-      -- processo tutte le feature attive
+      nCounter = nCounter + 1
-      local Proc = vProcSingleRot[i]
+      local bToReprocess = false
-      if Proc.nFlg ~= 0 then
+      -- per ogni feature
-         -- controllo se ci sono strategie disponibili
+      for i = 1, #vProcSingleRot do
-         if Proc.AvailableStrategies and #Proc.AvailableStrategies > 0 then
+         -- processo tutte le feature attive
-            -- se le strategie disponibili sono le basic, non si possono customizzare valori di default da interfaccia
+         local Proc = vProcSingleRot[i]
-            -- si leggono allora eventuali parametri di default scritti come info sulla feature
+         if Proc.nFlg ~= 0 then
-            if Proc.AvailableStrategies.bIsBasicStrategy then
+            -- controllo se ci sono strategie disponibili
-               -- si recuperano eventuali parametri custom
+            if Proc.AvailableStrategies and #Proc.AvailableStrategies > 0 then
-               for j = 1, #Proc.AvailableStrategies do
+               -- se le strategie disponibili sono le basic, non si possono customizzare valori di default da interfaccia
-                  -- essendo una strategia basic, la lista dei parametri custom dovrebbe essere sempre vuota. Si leggono ora
+               -- si leggono allora eventuali parametri di default scritti come info sulla feature
-                  if not Proc.AvailableStrategies[j].ParameterList then
+               if Proc.AvailableStrategies.bIsBasicStrategy then
-                     Proc.AvailableStrategies[j].ParameterList = BCS.GetParametersFromBasicCustomerStrategies( Proc, Proc.AvailableStrategies[j].sStrategyId)
+                  -- si recuperano eventuali parametri custom
+                  for j = 1, #Proc.AvailableStrategies do
+                     -- essendo una strategia basic, la lista dei parametri custom dovrebbe essere sempre vuota. Si leggono ora
+                     if not Proc.AvailableStrategies[j].ParameterList then
+                        Proc.AvailableStrategies[j].ParameterList = BCS.GetParametersFromBasicCustomerStrategies( Proc, Proc.AvailableStrategies[j].sStrategyId)
+                     end
+                  end
+                  -- si riprocessano le strategie dopo che sono stati letti i parametri
+                  Proc.AvailableStrategies = BCS.UpdateStrategies( Proc.AvailableStrategies)
+               end
+
+               -- ciclo tutte le strategie della feature
+               for nIndexCurrentStrategy = 1, #Proc.AvailableStrategies do
+                  -- eseguo file config con i parametri di default
+                  local CurrentStrategy = {}
+                  CurrentStrategy = RunStrategyLibraries( Proc.AvailableStrategies[nIndexCurrentStrategy].sStrategyId)
+                  -- controllo che le librerie siano state effettivamente caricate
+                  if CurrentStrategy.Config and CurrentStrategy.Script then
+                     -- eseguo la strategia solo come calcolo fattibilità e voto. Non si applicano le lavorazioni. Si passa la Proc e i parametri personalizzati
+                     _, Proc.AvailableStrategies[nIndexCurrentStrategy].Result = CurrentStrategy.Script.Make( false, Proc, Part, Proc.AvailableStrategies[nIndexCurrentStrategy])
+
+                     -- pulizia eventuali geometrie aggiutive create dalla strategia
+                     EgtEmptyGroup( Part.idTempGroup)
+
+                     -- se taglio di testa o coda sostitutivo non applicabile si ripristina l'originale
+                     if Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sStatus ~= 'Completed' then
+                        if ID.IsHeadCut( Proc) and not Proc.bIsOriginalHeadcut then
+                           -- si riabilita taglio di testa originale
+                           Proc.HeadProcOriginal.nFlg = 1
+                           Proc.HeadProcOriginal.nIndexMasterProc = nil
+                           -- il taglio attuale va riportato alla sua topologia originale
+                           Proc.Topology = FeatureLib.ClassifyTopology( Proc, Part)
+                           Proc.AvailableStrategies = GetStrategies( Proc, Part.sAISetupConfig)
+                           for j = #Proc.SlaveProcIndexes, 1, -1 do
+                              if Proc.SlaveProcIndexes[j] == Proc.HeadProcOriginal.nIndexInVProc then
+                                 table.remove( Proc.SlaveProcIndexes, j)
+                              end
+                           end
+                           bToReprocess = true
+                           break
+                        elseif ID.IsTailCut( Proc) and not Proc.bIsOriginalTailcut then
+                           -- si riabilita il taglio di coda originale
+                           Proc.TailProcOriginal.nFlg = 1
+                           Proc.TailProcOriginal.nIndexMasterProc = nil
+                           -- il taglio attuale va riportato alla sua topologia originale
+                           Proc.Topology = FeatureLib.ClassifyTopology( Proc, Part)
+                           Proc.AvailableStrategies = GetStrategies( Proc, Part.sAISetupConfig)
+                           for j = #Proc.SlaveProcIndexes, 1, -1 do
+                              if Proc.SlaveProcIndexes[j] == Proc.TailProcOriginal.nIndexInVProc then
+                                 table.remove( Proc.SlaveProcIndexes, j)
+                              end
+                           end
+                           bToReprocess = true
+                           break
+                        end
+                     end
+
+                     -- TODO da capire se dare un tempo molto alto oppure se dare errore perchè non deve mai capitare. Per ora si setta tempo alto
+                     -- se tempo non calcolato, si setta un tempo molto alto, 99 minuti
+                     if not Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine or Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine == 0 then
+                        Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine = 99
+                     end
+                     
+                     if not Proc.AvailableStrategies.dAllStrategiesTotalTime then
+                        Proc.AvailableStrategies.dAllStrategiesTotalTime = 0
+                     end
+                     Proc.AvailableStrategies.dAllStrategiesTotalTime = Proc.AvailableStrategies.dAllStrategiesTotalTime + Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine
+                     -- se scelta strategia in modalità base o standard, esco subito alla prima che trovo completa
+                     if Part.GeneralParameters.GEN_sMachiningStrategy == 'FIRST_IN_LIST' and Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sStatus == 'Completed' then
+                        break
+                     end
+
+                  -- se non trovo i file della strategia (Script e Config), scrivo che non è più disponibile
+                  else
+                     Proc.AvailableStrategies[nIndexCurrentStrategy].Result = {}
+                     Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sInfo = 'Strategy not found'
+                     Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sStatus = 'Not-Applicable'
                   end
                end
-               -- si riprocessano le strategie dopo che sono stati letti i parametri
+               if bToReprocess then
-               Proc.AvailableStrategies = BCS.UpdateStrategies( Proc.AvailableStrategies)
+                  break
-            end
-
-            -- ciclo tutte le strategie della feature
-            for nIndexCurrentStrategy = 1, #Proc.AvailableStrategies do
-               -- eseguo file config con i parametri di default
-               local CurrentStrategy = {}
-               CurrentStrategy = RunStrategyLibraries( Proc.AvailableStrategies[nIndexCurrentStrategy].sStrategyId)
-               -- controllo che le librerie siano state effettivamente caricate
-               if CurrentStrategy.Config and CurrentStrategy.Script then
-                  -- eseguo la strategia solo come calcolo fattibilità e voto. Non si applicano le lavorazioni. Si passa la Proc e i parametri personalizzati
-                  _, Proc.AvailableStrategies[nIndexCurrentStrategy].Result = CurrentStrategy.Script.Make( false, Proc, Part, Proc.AvailableStrategies[nIndexCurrentStrategy])
-
-                  -- TODO da capire se dare un tempo molto alto oppure se dare errore perchè non deve mai capitare. Per ora si setta tempo alto
-                  -- se tempo non calcolato, si setta un tempo molto alto, 99 minuti
-                  if not Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine or Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine == 0 then
-                     Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine = 99
-                  end
-                  
-                  if not Proc.AvailableStrategies.dAllStrategiesTotalTime then
-                     Proc.AvailableStrategies.dAllStrategiesTotalTime = 0
-                  end
-                  Proc.AvailableStrategies.dAllStrategiesTotalTime = Proc.AvailableStrategies.dAllStrategiesTotalTime + Proc.AvailableStrategies[nIndexCurrentStrategy].Result.dTimeToMachine
-                  -- se scelta strategia in modalità base o standard, esco subito alla prima che trovo completa
-                  if Part.GeneralParameters.GEN_sMachiningStrategy == 'FIRST_IN_LIST' and Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sStatus == 'Completed' then
-                     break
-                  end
-
-               -- se non trovo i file della strategia (Script e Config), scrivo che non è più disponibile
-               else
-                  Proc.AvailableStrategies[nIndexCurrentStrategy].Result = {}
-                  Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sInfo = 'Strategy not found'
-                  Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sStatus = 'Not-Applicable'
                end
+               -- si calcola il composite rating delle strategie
+               Proc.AvailableStrategies = FeatureLib.CalculateStrategiesCompositeRating( Proc.AvailableStrategies, Part.GeneralParameters.GEN_sMachiningStrategy)
             end
-            -- si calcola il composite rating delle strategie
-            Proc.AvailableStrategies = FeatureLib.CalculateStrategiesCompositeRating( Proc.AvailableStrategies, Part.GeneralParameters.GEN_sMachiningStrategy)
          end
       end
-   end
+   until ( not bToReprocess) or ( nCounter > 5)
+
    return vProcSingleRot
 end
 
@@ -1381,8 +1434,10 @@ local function CalculateMachinings( vProc, Part, nInitialRotation)
             local StrategyScript = require( StrategyScriptName)
             -- eseguo la strategia e si applicano le lavorazioni. Si passa la Proc e i parametri personalizzati
             local _, Result = StrategyScript.Make( true, Proc, Part, Proc.ChosenStrategy)
+            -- pulizia eventuali geometrie aggiutive create dalla strategia
+            EgtEmptyGroup( Part.idTempGroup)
             -- per i tagli di testa e coda, che non hanno girato nel CalculateStrategies, si devono settare i risultati 
-            if ID.IsHeadCut( Proc) or ID.IsTailCut( Proc) then
+            if ( ID.IsHeadCut( Proc) or ID.IsTailCut( Proc)) and not Proc.ChosenStrategy.Result then
                Proc.ChosenStrategy.Result = Result
             end
          -- se tutte le strategie disponibili non sono applicabili
@@ -1436,8 +1491,6 @@ function BeamExec.GetProcessings( PARTS, bIsFlipRot)
       -- se è prerotazione, oltre al ciclo normale, si devono verificare anche invertiti
       local bCalcInverted = bIsFlipRot and PARTS[nPart].GeneralParameters.GEN_bAllowPieceInversion
       local nCycles = EgtIf( bCalcInverted, 2, 1)
-      PARTS[nPart].HeadcutInfo = {}
-      PARTS[nPart].TailcutInfo = {}
       -- per ogni inversione
       for nInvertIndex = 1, nCycles do
          -- per ogni rotazione
@@ -1453,23 +1506,11 @@ function BeamExec.GetProcessings( PARTS, bIsFlipRot)
 
                -- recupero informazioni ausiliarie feature e dipendenze tra feature stesse
                -- TODO le dipendenze cambiano in base alla rotazione del pezzo? probabilmente no
-               vProcRot[nIndex], HeadcutInfo, TailcutInfo = GetFeatureInfoAndDependency( vProcRot[nIndex], PARTS[nPart], bIsFlipRot)
+               vProcRot[nIndex] = GetFeatureInfoAndDependency( vProcRot[nIndex], PARTS[nPart])
             else
                -- inserisco una tabella vuota
                table.insert( vProcRot, {})
             end
-            if HeadcutInfo then
-               PARTS[nPart].HeadcutInfo[nIndex] = {
-                  OffsetX = HeadcutInfo.OffsetX,
-                  vtN = HeadcutInfo.vtN
-               }
-            end
-            if TailcutInfo then
-               PARTS[nPart].TailcutInfo[nIndex] = {
-                  OffsetX = TailcutInfo.OffsetX,
-                  vtN = TailcutInfo.vtN
-               }
-            end
             -- rotazione pezzo di 90° per volta
             BeamLib.RotateRawPart( PARTS[nPart], 1)
             -- aggiorno info pezzo
@@ -1697,17 +1738,17 @@ local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo, bRePro
          -- ciclo su tutte le feature, ad eccezione dei tagli testa/coda che dipendono dal risultato delle altre
          -- tagli testa e coda vengono aggiunti sempre alla fine
          for nProc = 1, #ProcessingsOnPart.Rotation[1] do
-            -- Si controlla sempre la rotazione 1 perchè la dipendenza di una feature da un'altra non dipende dalla rotazione
+            -- Si controlla sempre la rotazione 1 perchè la dipendenza di una feature da un'altra non dipende dalla rotazione (ma dall'inversione sì!)
             -- se feature disattivata perchè eseguita da master a lei associata dichiaro comunque eseguita
-            local ProcOnFirstRotation = ProcessingsOnPart.Rotation[1][nProc]
+            local nOffsetIndex = EgtIf( SingleCombination.bPartInCombiIsInverted, 4, 0)
+            local ProcOnFirstRotation = ProcessingsOnPart.Rotation[1+nOffsetIndex][nProc]
             if ProcOnFirstRotation.nFlg == 0 and  ProcOnFirstRotation.nIndexMasterProc then
                ProcOnFirstRotation.nIndexRotation = nUnloadPos
                table.insert( SingleCombination.Rot0, ProcOnFirstRotation)
                SingleCombination.nComplete = SingleCombination.nComplete + 1
             else
-               local nOffsetIndex = EgtIf( SingleCombination.bPartInCombiIsInverted, 4, 0)
+               if not ( ( ID.IsHeadCut( ProcessingsOnPart.Rotation[1+nOffsetIndex][nProc]) and ProcessingsOnPart.Rotation[1+nOffsetIndex][nProc].bIsOriginalHeadcut)
-               if not ( ( ID.IsHeadCut( ProcOnFirstRotation) and ProcOnFirstRotation.bIsOriginalHeadcut)
+                  or ( ID.IsTailCut( ProcessingsOnPart.Rotation[1+nOffsetIndex][nProc]) and ProcessingsOnPart.Rotation[1+nOffsetIndex][nProc].bIsOriginalTailcut)) then
-                  or ( ID.IsTailCut( ProcOnFirstRotation) and ProcOnFirstRotation.bIsOriginalTailcut)) then
                   -- ciclo sulle rotazioni
                   local nNextRot = nUnloadPos
                   local ResultsList = {}
@@ -1938,30 +1979,34 @@ function BeamExec.ProcessMachinings( PARTS, bIsFlipRot)
          if nRotSplitCut > 4 then
             nRotSplitCut = nRotSplitCut - 4
          end
+
+         local HeadCut = PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc]
+         local TailCut = PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc]
+
          -- setto nella Proc l'indice rotazione nella quale deve essere lavorata
-         PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].nIndexRotation = nRotHeadCut
+         HeadCut.nIndexRotation = nRotHeadCut
-         PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].nIndexRotation = nRotSplitCut
+         TailCut.nIndexRotation = nRotSplitCut
 
          -- si imposta flag rotazione per taglio di testa
          if MACHININGS.Info.nHeadCutRotation == 2 then
-            PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bSide = true
+            HeadCut.bSide = true
          elseif MACHININGS.Info.nHeadCutRotation == 3 then
-            PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bDown = true
+            HeadCut.bDown = true
          else
-            PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bStd = true
+            HeadCut.bStd = true
          end
          -- si imposta flag rotazione per taglio di coda
          if MACHININGS.Info.nSplitCutRotation == 2 then
-            PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bSide = true
+            TailCut.bSide = true
          elseif MACHININGS.Info.nSplitCutRotation == 3 then
-            PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bDown = true
+            TailCut.bDown = true
          else
-            PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bStd = true
+            TailCut.bStd = true
          end
 
          local vProcHeadTail = {}
-         table.insert( vProcHeadTail, PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc])
+         table.insert( vProcHeadTail, HeadCut)
-         table.insert( vProcHeadTail, PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc])
+         table.insert( vProcHeadTail, TailCut)
 
          MACHININGS = CalculateMachinings( vProcHeadTail, PARTS[nPart], MatrixResult.nInitialPosition)
 
@@ -2267,6 +2312,10 @@ function BeamExec.ProcessAlternatives( PARTS)
       end
    end
 
+   -- informazioni tagli di testa e coda da passare a nesting
+   PARTS[nPart].HeadcutInfo = {}
+   PARTS[nPart].TailcutInfo = {}
+
    -- fino a che ci sono soluzioni da testare
    for z = 1, #TotalCombiToTest do
       -- si svuota il machgroup e si resettano le variabili
@@ -2341,42 +2390,71 @@ function BeamExec.ProcessAlternatives( PARTS)
                if nRotSplitCut > 4 then
                   nRotSplitCut = nRotSplitCut - 4
                end
+
+               local HeadCut = PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc]
+               local TailCut = PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc]
+               local HeadCutOnFirstRotation = PROCESSINGS[nPart].Rotation[1+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc]
+               local TailCutOnFirstRotation = PROCESSINGS[nPart].Rotation[1+nOffsetIndex][MatrixResult.nIndexTailCutInVProc]
+
                -- setto nella Proc l'indice rotazione nella quale deve essere lavorata
-               PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].nIndexRotation = nRotHeadCut
+               HeadCut.nIndexRotation = nRotHeadCut
-               PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].nIndexRotation = nRotSplitCut
+               TailCut.nIndexRotation = nRotSplitCut
 
                -- si imposta flag rotazione per taglio di testa
                if MACHININGS.Info.nHeadCutRotation == 2 then
-                  PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bDown = nil
+                  HeadCut.bDown = nil
-                  PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bSide = true
+                  HeadCut.bSide = true
-                  PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bStd = nil
+                  HeadCut.bStd = nil
                elseif MACHININGS.Info.nHeadCutRotation == 3 then
-                  PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bDown = true
+                  HeadCut.bDown = true
-                  PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bSide = nil
+                  HeadCut.bSide = nil
-                  PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bStd = nil
+                  HeadCut.bStd = nil
                else
-                  PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bDown = nil
+                  HeadCut.bDown = nil
-                  PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bSide = nil
+                  HeadCut.bSide = nil
-                  PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc].bStd = true
+                  HeadCut.bStd = true
                end
                -- si imposta flag rotazione per taglio di coda
                if MACHININGS.Info.nSplitCutRotation == 2 then
-                  PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bDown = nil
+                  TailCut.bDown = nil
-                  PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bSide = true
+                  TailCut.bSide = true
-                  PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bStd = nil
+                  TailCut.bStd = nil
                elseif MACHININGS.Info.nSplitCutRotation == 3 then
-                  PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bDown = true
+                  TailCut.bDown = true
-                  PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bSide = nil
+                  TailCut.bSide = nil
-                  PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bStd = nil
+                  TailCut.bStd = nil
                else
-                  PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bDown = nil
+                  TailCut.bDown = nil
-                  PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bSide = nil
+                  TailCut.bSide = nil
-                  PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc].bStd = true
+                  TailCut.bStd = true
                end
 
                local vProcHeadTail = {}
-               table.insert( vProcHeadTail, PROCESSINGS[nPart].Rotation[nRotHeadCut+nOffsetIndex][MatrixResult.nIndexHeadCutInVProc])
+               table.insert( vProcHeadTail, HeadCut)
-               table.insert( vProcHeadTail, PROCESSINGS[nPart].Rotation[nRotSplitCut+nOffsetIndex][MatrixResult.nIndexTailCutInVProc])
+               table.insert( vProcHeadTail, TailCut)
+
+               -- aggiornamento info testa/coda per Nesting
+               local nRotation = BeamLib.ConvertBitIndexToRotationIndex( BestCombination.sBitIndexCombination)
+               local sBitIndexCombinationWithInvert = BestCombination.sBitIndexCombination .. EgtIf( BestCombination.bPartInCombiIsInverted, '_INV', '')
+               local HeadcutInfo, TailcutInfo = GetHeadTailInfoForNesting( HeadCutOnFirstRotation, TailCutOnFirstRotation, PARTS[nPart])
+               if HeadcutInfo then
+                  -- offset e vettori vanno adeguati alla rotazione attuale (inversione è già corretta)
+                  BeamLib.RotateTableFromIndexInPlace( HeadcutInfo.OffsetX, nRotation)
+                  HeadcutInfo.vtN:rotate( X_AX(), ( nRotation - 1) * 90)
+                  PARTS[nPart].HeadcutInfo[sBitIndexCombinationWithInvert] = {
+                     OffsetX = HeadcutInfo.OffsetX,
+                     vtN = HeadcutInfo.vtN
+                  }
+               end
+               if TailcutInfo then
+                  -- offset e vettori vanno adeguati alla rotazione attuale (inversione è già corretta)
+                  BeamLib.RotateTableFromIndexInPlace( TailcutInfo.OffsetX, nRotation)
+                  TailcutInfo.vtN:rotate( X_AX(), ( nRotation - 1) * 90)
+                  PARTS[nPart].TailcutInfo[sBitIndexCombinationWithInvert] = {
+                     OffsetX = TailcutInfo.OffsetX,
+                     vtN = TailcutInfo.vtN
+                  }
+               end
 
                MACHININGS = CalculateMachinings( vProcHeadTail, PARTS[nPart], MatrixResult.nInitialPosition)
 
@@ -2533,15 +2611,14 @@ function BeamExec.ProcessAlternatives( PARTS)
    BEAM.INFONGEPART = {}
    table.insert( BEAM.INFONGEPART, 'INITIALPOSITION=' .. PARTS[nPart].nInitialPosition)
    for i = 1, #AlternativesNest2D do
-      local sRotation = BeamLib.ConvertBitIndexToRotationIndex( AlternativesNest2D[i])
       if PARTS[nPart].HeadcutInfo then
-         local sOffsetX = table.concat( PARTS[nPart].HeadcutInfo[sRotation].OffsetX, ',')
+         local sOffsetX = table.concat( PARTS[nPart].HeadcutInfo[AlternativesNest2D[i]].OffsetX, ',')
-         local sVtN = ( tostring( PARTS[nPart].HeadcutInfo[sRotation].vtN)):gsub("^%(", ""):gsub("%)$", "")
+         local sVtN = ( tostring( PARTS[nPart].HeadcutInfo[AlternativesNest2D[i]].vtN)):gsub("^%(", ""):gsub("%)$", "")
          table.insert( BEAM.INFONGEPART, 'ALT' .. AlternativesNest2D[i].. '_H' .. '=' .. sOffsetX .. ';' .. sVtN )
       end
       if PARTS[nPart].TailcutInfo then
-         local sOffsetX = table.concat( PARTS[nPart].TailcutInfo[sRotation].OffsetX, ',')
+         local sOffsetX = table.concat( PARTS[nPart].TailcutInfo[AlternativesNest2D[i]].OffsetX, ',')
-         local sVtN = ( tostring( PARTS[nPart].TailcutInfo[sRotation].vtN)):gsub("^%(", ""):gsub("%)$", "")
+         local sVtN = ( tostring( PARTS[nPart].TailcutInfo[AlternativesNest2D[i]].vtN)):gsub("^%(", ""):gsub("%)$", "")
          table.insert( BEAM.INFONGEPART, 'ALT' .. AlternativesNest2D[i] .. '_T' .. '=' .. sOffsetX .. ';' .. sVtN)
       end
    end

LuaLibs/BeamLib.lua

@@ -961,16 +961,36 @@ function BeamLib.ConvertBitIndexToRotationIndex( sBitIndexCombination)
    return nRotationIndex
 end
 
+-------------------------------------------------------------------------------------------------------------
+-- inverte la porzione tra nStartIndex e nEndIndex della tabella passata
+local function ReverseTablePortionInPlace( Table, nStartIndex, nEndIndex)
+   while nStartIndex < nEndIndex do
+      Table[nStartIndex], Table[nEndIndex] = Table[nEndIndex], Table[nStartIndex]
+      nStartIndex = nStartIndex + 1
+      nEndIndex = nEndIndex - 1
+   end
+
+   return Table
+end
+
+
 -------------------------------------------------------------------------------------------------------------
 -- reindicizza una tabella passata ripartendo dall'indice nStartIndex e mantenendo l'ordine
-function BeamLib.RotateTableFromIndex( Table, nStartIndex)
+function BeamLib.RotateTableFromIndexInPlace( Table, nStartIndex)
-    local RotatedTable = {}
+   local dLen = #Table
 
-    for i = 1, #Table do
+   -- Nessuna rotazione necessaria se la tabella è vuota, ha 1 solo elemento, o la rotazione è dall'indice 1
-        RotatedTable[#RotatedTable + 1] = Table[((RotatedTable + i - 2) % #Table) + 1]
+   if dLen <= 1 or nStartIndex <= 1 or nStartIndex > dLen then
-    end
+      return Table
+   end
 
-    return RotatedTable
+   local k = nStartIndex - 1
+
+   ReverseTablePortionInPlace( Table, 1, k)         -- 1. Inverte la parte inziale
+   ReverseTablePortionInPlace( Table, k + 1, dLen)  -- 2. Inverte la parte finale
+   ReverseTablePortionInPlace( Table, 1, dLen)      -- 3. Inverte tutto
+
+   return Table
 end
 
 -------------------------------------------------------------------------------------------------------------

LuaLibs/FeatureLib.lua

@@ -955,7 +955,7 @@ function FeatureLib.CalculateFeatureNotClampableLengths( Proc, Part)
    local dNotClampableLengthTail = 0
 
    -- se il grezzo non è definito, prendo il box del pezzo
-   -- TODO 1- si sta passando b3part per riferimento, 2- non dovrebbe essre sempre definito?
+   -- TODO 1- si sta passando b3part per riferimento, è giusto? 2- non dovrebbe essre sempre definito?
    if not Part.b3Raw then
       Part.b3Raw = Part.b3Part
    end

NestProcess.lua

@@ -223,7 +223,8 @@ function PartTemplates:AddPart( id)
    end
 
    -- info eventuali rotazioni / inversioni custom e forzature manuali
-   local bIsManualFlipRot = ( ( EgtGetInfo( id, 'MANUALROT', 'i') or 0) == 1) or ( ( EgtGetInfo( id, 'MANUALFLIP', 'i') or 0) == 1)
+   -- TODO ignorare gli stati calcolati porta a problemi, valutare se eliminare del tutto la dipendenza da bIsManualFlipRot
+   --local bIsManualFlipRot = ( ( EgtGetInfo( id, 'MANUALROT', 'i') or 0) == 1) or ( ( EgtGetInfo( id, 'MANUALFLIP', 'i') or 0) == 1)
 
    if not bIsManualFlipRot then
 
@@ -392,7 +393,8 @@ local function CalculateMove( Beam, dPartLength, sState, State)
    end
 
    -- Bonus Shared Cut: se le normali sono opposte, si risparmia un taglio/posizionamento
-   if AreOppositeVectorApprox( Beam.LastVtN, State.Tail.vtN) then
+   local bSharedCut = AreOppositeVectorApprox( Beam.LastVtN, State.Tail.vtN)
+   if bSharedCut then
       dScore = dScore + CONFIG.BONUS_SHARED_CUT
    end
 
@@ -405,7 +407,8 @@ local function CalculateMove( Beam, dPartLength, sState, State)
       sState = sState,
       dScore = dScore,
       dSafeOverlap = dSafeOverlap,
-      dFutureResidualLength = dFutureResidualLength
+      dFutureResidualLength = dFutureResidualLength,
+      bSharedCut = bSharedCut
    }
    return Move
 end
@@ -527,7 +530,8 @@ local function CommitBestMove( BestMove)
       sState = BestMove.sState,
       dSafeOverlap = BestMove.dSafeOverlap,
       dLength = Template.dLength,
-      dPosX = BestMove.dFutureResidualLength
+      dPosX = BestMove.dFutureResidualLength,
+      bSharedCut = BestMove.bSharedCut
    })
 
    -- chiusura job
@@ -625,6 +629,8 @@ for i = 1, #RawInventory.ActiveBeams do
 
    -- Spostamento pezzi verso la testa della barra e aggiunta duplo
    local nIndex = 1
+   local bSkipNextHeadCut = false
+
    for j = #Beam.NestedParts, 1, -1 do
       local Part = Beam.NestedParts[j]
       local nInitialPosition = EgtGetInfo( Part.id, 'INITIALPOSITION', 'i')
@@ -635,6 +641,11 @@ for i = 1, #RawInventory.ActiveBeams do
       -- copia del pezzo (aggiunta duplo)
       local idDuplo = EgtDuploNew( Part.id)
 
+      -- pezzo già intestato dal Tailcut precedente: si segnala all'automatismo che si può saltare Headcut
+      if bSkipNextHeadCut then
+         EgtSetInfo( idDuplo, "SKIP_HEADCUT", 1)
+      end
+
       -- eventuale rotazione
       if ( EgtStartsWith( Part.sState, '0010') and nInitialPosition == 1)
          or ( EgtStartsWith( Part.sState, '1000') and nInitialPosition == 3) then
@@ -656,6 +667,8 @@ for i = 1, #RawInventory.ActiveBeams do
       EgtSetInfo( idMachGroup, "PART" .. nIndex, idDuplo .. "," .. dPosX)
 
       nIndex = nIndex + 1
+
+      bSkipNextHeadCut = Part.bSharedCut
    end
 end
 

Strategies/Standard/HEADCUT/HEADCUT.lua

@@ -22,6 +22,31 @@ local function MakeChamfer()
    -- TODO funzionalità da aggiungere
 end
 
+-------------------------------------------------------------------------------------------------------------
+local function CalculateHeadCut( Proc, Part)
+   -- si recuperano gli estremi del box del materiale di testa da togliere
+   local b3PartWithHead = BeamLib.GetPartBoxWithHeadTail( Part, 'Head')
+   local ptStartRestLength = Point3d( Part.b3Part:getMax():getX() - 1, Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
+   local ptEndRestLength = Point3d( b3PartWithHead:getMax():getX(), Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
+
+   local OptionalParametersBladeToWaste = {}
+   OptionalParametersBladeToWaste.b3BoxDicing = BBox3d( ptStartRestLength, ptEndRestLength)
+   OptionalParametersBladeToWaste.dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume
+   OptionalParametersBladeToWaste.dMaxWasteLength = Strategy.Parameters.dMaxWasteLength
+   OptionalParametersBladeToWaste.bReduceBladePath = Strategy.Parameters.bReduceBladePath
+   OptionalParametersBladeToWaste.sRestLengthSideForPreSimulation = 'Head'
+   OptionalParametersBladeToWaste.bCannotSplitRestLength = true
+
+   local Machinings = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
+   -- se taglio non riuscito, si riprova con il riduci percorso forzato (collisione possibile in separazione pezzi alti)
+   if ( not Machinings) or ( #Machinings == 0) then
+      OptionalParametersBladeToWaste.bReduceBladePath = true
+      Machinings = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
+   end
+
+   return Machinings
+end
+
 -------------------------------------------------------------------------------------------------------------
 function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
    local StrategyLib = {}
@@ -47,7 +72,7 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
    end
 
    -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
-   if Strategy.Parameters.bExecutePreCut then
+   if Strategy.Parameters.bExecutePreCut or not Proc.bIsOriginalHeadcut then
       Strategy.SplitStrategy, Strategy.Result = SPLITCUT.GetMachining( Proc, Part, OptionalParameters)
       -- se non faccio tagli PRECUT, imposto tabella Result direttamente. Non serve verificare che riesca a rimuovere il materiale extra 
       -- if not Strategy.SplitStrategy or #Strategy.SplitStrategy == 0 then
@@ -65,8 +90,9 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
    -- TODO di quale utensile si deve impostare la qualità qui?
    Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'SAWBLADE')
 
-   -- se coincide con inizio grezzo, non va fatto
+   -- se settato da saltare o coincide con inizio grezzo, non va fatto
-   if abs( Proc.b3Box:getCenter():getX() - Part.b3Raw:getMax():getX()) < 10 * GEO.EPS_SMALL then
+   --local bSkipHeadCut = ( EgtGetInfo( Part.id, "SKIP_HEADCUT", 'i') or 0) == 1
+   if bSkipHeadCut or ( abs( Proc.b3Box:getCenter():getX() - Part.b3Raw:getMax():getX()) < 10 * GEO.EPS_SMALL) then
       return true, Strategy.Result
    end
 
@@ -80,16 +106,14 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       local MachiningsToAdd = {}
       local bExecutePrecutOnly = false
       -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
-      if Strategy.Parameters.bExecutePreCut then
+      if Strategy.Parameters.bExecutePreCut or not Proc.bIsOriginalHeadcut then
-         bExecutePrecutOnly = Part.dHeadOverMaterial < 20
+         bExecutePrecutOnly = ( Part.dHeadOverMaterial < 20) or not Proc.bIsOriginalHeadcut
          
          if Strategy.SplitStrategy and #Strategy.SplitStrategy > 0 then
             for i = 1, #Strategy.SplitStrategy do
                local TempList = {}
                TempList = Strategy.SplitStrategy[i]
-               if bExecutePrecutOnly then
+               if not bExecutePrecutOnly then
-                  TempList.dLongitudinalOffset = 0
-               else
                   TempList.bIsPreCut = true
                   TempList.dLongitudinalOffset = Part.dHeadOverMaterial
                end
@@ -101,25 +125,8 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
 
       if not bExecutePrecutOnly then
 
-         -- si recuperano gli estremi del box del materiale di testa da togliere
+         Strategy.Machining = CalculateHeadCut( Proc, Part)
-         local b3PartWithHead = BeamLib.GetPartBoxWithHeadTail( Part, 'Head')
-         local ptStartRestLength = Point3d( Part.b3Part:getMax():getX() - 1, Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
-         local ptEndRestLength = Point3d( b3PartWithHead:getMax():getX(), Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
 
-         local OptionalParametersBladeToWaste = {}
-         OptionalParametersBladeToWaste.b3BoxDicing = BBox3d( ptStartRestLength, ptEndRestLength)
-         OptionalParametersBladeToWaste.dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume
-         OptionalParametersBladeToWaste.dMaxWasteLength = Strategy.Parameters.dMaxWasteLength
-         OptionalParametersBladeToWaste.bReduceBladePath = Strategy.Parameters.bReduceBladePath
-         OptionalParametersBladeToWaste.sRestLengthSideForPreSimulation = 'Head'
-         OptionalParametersBladeToWaste.bCannotSplitRestLength = true
-
-         Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
-         -- se taglio non riuscito, si riprova con il riduci percorso forzato (collisione possibile in separazione pezzi alti)
-         if ( not Strategy.Machining) or ( #Strategy.Machining == 0) then
-            OptionalParametersBladeToWaste.bReduceBladePath = true
-            Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
-         end
          if Strategy.Machining and #Strategy.Machining > 0 then
             for i = 1, #Strategy.Machining do
                local TempList = {}
@@ -139,9 +146,9 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       end
 
       return bAreAllMachiningsAdded, Strategy.Result
-   else
-      return nil, Strategy.Result
    end
+
+   return nil, Strategy.Result
 end
 
 -------------------------------------------------------------------------------------------------------------

Strategies/Standard/STR0012/STR0012.json

@@ -14,6 +14,43 @@
          "sMessageId": " ",
          "sMinUserLevel": "1"
       },
+      {
+         "sName": "sCuttingStrategy",
+         "sNameNge": "CUTTING_STRATEGY",
+         "sValue": "AUTO",
+         "sDescriptionShort": "Cutting strategy",
+         "sDescriptionLong": "",
+         "idDescriptionShortMsg": 1000117,
+         "idDescriptionLongMsg": 1000118,
+         "sType": "combo",
+         "sMinUserLevel": "1",
+         "Choices": [
+            {
+               "sValue": "AUTO",
+               "sDescriptionShort": "Automatic",
+               "sDescriptionLong": "",
+               "idDescriptionShortMsg": 1000119,
+               "idDescriptionLongMsg": 1000120,
+               "sMessageId": ""
+            },
+            {
+               "sValue": "DROP_WASTE",
+               "sDescriptionShort": "Drop waste",
+               "sDescriptionLong": "",
+               "idDescriptionShortMsg": 1000121,
+               "idDescriptionLongMsg": 1000122,
+               "sMessageId": ""
+            },
+            {
+               "sValue": "KEEP_WASTE_ATTACHED",
+               "sDescriptionShort": "Keep waste attached",
+               "sDescriptionLong": "",
+               "idDescriptionShortMsg": 1000123,
+               "idDescriptionLongMsg": 1000124,
+               "sMessageId": ""
+            }
+         ]
+      },
       {
          "sName": "sCanDamageNextPiece",
          "sNameNge": "DAMAGE_NEXT_PIECE",

Strategies/Standard/STR0012/STR0012.lua

@@ -94,7 +94,7 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
    -- considerazioni necessarie a determinare se lavorare con codolo oppure no
    local bKeepWasteAttached = ( Strategy.Parameters.sCuttingStrategy == 'KEEP_WASTE_ATTACHED')
    local bDropWaste = ( Strategy.Parameters.sCuttingStrategy == 'DROP_WASTE')
-   local bFeatureHindersClamping = MachiningLib.IsFeatureHinderingClamping( Proc, Part)
+   local bFeatureHindersClamping = MachiningLib.IsFeatureHinderingClamping( NewProc, Part)
 
    -- lavorazione con codolo
    if ( bFeatureHindersClamping and not bDropWaste)

Strategies/Standard/TAILCUT/TAILCUT.lua

@@ -22,6 +22,31 @@ local function MakeChamfer()
    -- TODO funzionalità da aggiungere
 end
 
+-------------------------------------------------------------------------------------------------------------
+local function CalculateTailCut( Proc, Part)
+      -- si recuperano gli estremi del box del materiale di coda da rimuovere
+   local b3PartWithTail = BeamLib.GetPartBoxWithHeadTail( Part, 'Tail')
+   local ptStartRestLength = Point3d( Part.b3Part:getMin():getX() + 1, Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
+   local ptEndRestLength = Point3d( b3PartWithTail:getMin():getX(), Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
+
+   local OptionalParametersBladeToWaste = {}
+   OptionalParametersBladeToWaste.b3BoxDicing = BBox3d( ptStartRestLength, ptEndRestLength)
+   OptionalParametersBladeToWaste.dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume
+   OptionalParametersBladeToWaste.dMaxWasteLength = Strategy.Parameters.dMaxWasteLength
+   OptionalParametersBladeToWaste.bReduceBladePath = Strategy.Parameters.bReduceBladePath
+   OptionalParametersBladeToWaste.sRestLengthSideForPreSimulation = 'Tail'
+   OptionalParametersBladeToWaste.bCannotSplitRestLength = true
+
+   local Machinings = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
+   -- se taglio non riuscito, si riprova con il riduci percorso forzato (collisione possibile in separazione pezzi alti)
+   if ( not Machinings) or ( #Machinings == 0) then
+      OptionalParametersBladeToWaste.bReduceBladePath = true
+      Machinings = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
+   end
+
+   return Machinings
+end
+
 -------------------------------------------------------------------------------------------------------------
 function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
    local StrategyLib = {}
@@ -51,7 +76,7 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
    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
+   if Strategy.bSplit or not Proc.bIsOriginalTailcut then
       OptionalParameters.dOffset = 0
       OptionalParameters.bDisableDicing = true
       Strategy.SplitStrategy, Strategy.Result = SPLITCUT.GetMachining( Proc, Part, OptionalParameters)
@@ -64,7 +89,7 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
    -- se devo rimuovere tutto il restante
    else
       -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
-      if Strategy.Parameters.bExecutePreCut then
+      if Strategy.Parameters.bExecutePreCut and not Part.GeneralParameters.GEN_bGetAlternativesNesting2D then
          if Part.dRestLength < 20 then
             bExecutePrecutOnly = true
             OptionalParameters.dOffset = 0
@@ -101,16 +126,22 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
 
       local MachiningsToAdd = {}
       -- se devo fare split perchè c'è un grezzo da scaricare o un altro pezzo
-      if Strategy.bSplit then
+      if Strategy.bSplit or not Proc.bIsOriginalTailcut then
          if Strategy.SplitStrategy and #Strategy.SplitStrategy > 0 then
             for i = 1, #Strategy.SplitStrategy do
                local TempList = {}
                TempList.Splitting = Strategy.SplitStrategy[i]
+               local sNoteFinalCut = 'Split;'
+               local sNoteOtherCuts = 'Presplit;'
+               if not Strategy.bSplit then
+                  sNoteFinalCut = 'Cut;'
+                  sNoteOtherCuts = 'Precut;'
+               end
                if i == #Strategy.SplitStrategy then
-                  TempList.Splitting.sUserNotes = 'Split;'
+                  TempList.Splitting.sUserNotes = sNoteFinalCut
                   TempList.AuxiliaryData = { bIsSplitOrCut = true}
                else
-                  TempList.Splitting.sUserNotes = 'Presplit;'
+                  TempList.Splitting.sUserNotes = sNoteOtherCuts
                end
                table.insert( MachiningsToAdd, TempList)
             end
@@ -119,7 +150,7 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       -- se devo rimuovere tutto il restante
       else
          -- se abilitato, faccio tagli di PRECUT a zero (come SPLIT)
-         if Strategy.Parameters.bExecutePreCut then
+         if Strategy.Parameters.bExecutePreCut and not Part.GeneralParameters.GEN_bGetAlternativesNesting2D then
             if Strategy.SplitStrategy and #Strategy.SplitStrategy > 0 then
                for i = 1, #Strategy.SplitStrategy do
                   local TempList = {}
@@ -140,25 +171,8 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
 
          if not bExecutePrecutOnly then
 
-            -- si recuperano gli estremi del box del materiale di coda da rimuovere
+            Strategy.Machining = CalculateTailCut( Proc, Part)
-            local b3PartWithTail = BeamLib.GetPartBoxWithHeadTail( Part, 'Tail')
-            local ptStartRestLength = Point3d( Part.b3Part:getMin():getX() + 1, Part.b3Part:getMax():getY(), Part.b3Part:getMax():getZ())
-            local ptEndRestLength = Point3d( b3PartWithTail:getMin():getX(), Part.b3Part:getMin():getY(), Part.b3Part:getMin():getZ())
 
-            local OptionalParametersBladeToWaste = {}
-            OptionalParametersBladeToWaste.b3BoxDicing = BBox3d( ptStartRestLength, ptEndRestLength)
-            OptionalParametersBladeToWaste.dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume
-            OptionalParametersBladeToWaste.dMaxWasteLength = Strategy.Parameters.dMaxWasteLength
-            OptionalParametersBladeToWaste.bReduceBladePath = Strategy.Parameters.bReduceBladePath
-            OptionalParametersBladeToWaste.sRestLengthSideForPreSimulation = 'Tail'
-            OptionalParametersBladeToWaste.bCannotSplitRestLength = true
-
-            Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
-            -- se taglio non riuscito, si riprova con il riduci percorso forzato (collisione possibile in separazione pezzi alti)
-            if ( not Strategy.Machining) or ( #Strategy.Machining == 0) then
-               OptionalParametersBladeToWaste.bReduceBladePath = true
-               Strategy.Machining, _ = BladeToWaste.Make( Proc, Part, OptionalParametersBladeToWaste)
-            end
             if Strategy.Machining and #Strategy.Machining > 0 then
                for i = 1, #Strategy.Machining do
                   local TempList = {}
@@ -185,9 +199,9 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       end
 
       return bAreAllMachiningsAdded, Strategy.Result
-   else
-      return nil, Strategy.Result
    end
+
+   return nil, Strategy.Result
 end
 
 -------------------------------------------------------------------------------------------------------------

StrategyLibs/BLADETOWASTE.lua

@@ -845,8 +845,12 @@ local function CalculateDiceMachinings( vCuts, Parameters)
    local bReduceDiceDepth = Parameters.bReduceDiceDepth
 
    -- trimesh con RestLength
-   local b3CheckCollision = BeamLib.GetPartBoxWithHeadTail( Part, sRestLengthSideForPreSimulation)
+   local idCheckCollisionTm = EgtCopyGlob( Part.idBoxTm, Part.idTempGroup)
-   local idCheckCollisionTm = EgtSurfTmBBox( Part.idTempGroup, b3CheckCollision, false, GDB_RT.GLOB)
+   -- se testa o coda attaccate, si considerano nella superficie di collisione
+   if bCannotSplitRestLength then
+      local b3CheckCollision = BeamLib.GetPartBoxWithHeadTail( Part, sRestLengthSideForPreSimulation)
+      idCheckCollisionTm = EgtSurfTmBBox( Part.idTempGroup, b3CheckCollision, false, GDB_RT.GLOB)
+   end
 
    -- eventuale inversione tagli ortogonali e aggiunta informazioni alla geometria
    local bAreOrthogonalCutsInverted = false