- in BLADEKEEPWASTE il codolo perpendicolare si fa solo se la feature arriva più in basso dell'altezza minima della morsa

- Aggiunta topologia VGroove-2-Through
- Aggiunti messaggi
- In lettura parametri, se il default è nil, ma da json è settato, allora si prende il valore del json

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

@@ -764,7 +764,7 @@ function BeamLib.LoadCustomParametersInStrategy( Proc, Part, CustomParameters, D
          if DefaultStrategyParamList.ParameterList[i].sType == 'b' then
             UpdatedParameters[DefaultStrategyParamList.ParameterList[i].sName] = xParameterValue == 'true' or xParameterValue == '1' or xParameterValue == true
          elseif DefaultStrategyParamList.ParameterList[i].sType == 'd' then
-            if #DefaultStrategyParamList.ParameterList[i].sValue > 0 then
+            if #DefaultStrategyParamList.ParameterList[i].sValue > 0 or #xParameterValue > 0 then
                UpdatedParameters[DefaultStrategyParamList.ParameterList[i].sName] = tonumber( xParameterValue)
             -- stringa vuota equivale a non passare alcun valore (deciderà la strategia)
             else
@@ -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

LuaLibs/LeadInOutLib.lua

@@ -93,7 +93,7 @@ end
 
 
 -------------------------------------------------------------------------------------------------------------
-local function GetToolAddLength( dToolDiameter, dDepthToMachine)
+function LeadInOutLib.GetToolAddLength( dToolDiameter, dDepthToMachine)
    local dCheckDepth = min( dToolDiameter / 2, dDepthToMachine)
    local dToolAddLength = sqrt( dCheckDepth * dToolDiameter - dCheckDepth * dCheckDepth)
 
@@ -119,7 +119,7 @@ function LeadInOutLib.CalculateLeadInOut( sLeadInOutType, Parameters, OptionalPa
    local bIsEndClosed = not Edge.bIsEndOpen
 
    -- accorciamento per lati chiusi
-   LeadInOut.dToolAddLength = GetToolAddLength( Tool.dDiameter, dDepthToMachine)
+   LeadInOut.dToolAddLength = LeadInOutLib.GetToolAddLength( Tool.dDiameter, dDepthToMachine)
    LeadInOut.dExtraAddLengthStart, LeadInOut.dExtraAddLengthEnd = GetExtraAddLengthInclinedSides( Face, Edge)
    -- allungamento per faccia singola (aperta in tutte le direzioni)
    LeadInOut.dAddedLengthOpenFace = BeamData.CUT_EXTRA
@@ -215,6 +215,50 @@ function LeadInOutLib.CalculateLeadInOut( sLeadInOutType, Parameters, OptionalPa
       -- punti dell'attacco
       LeadIn.ptPoint = Point3d( ptStartAtDepth - Edge.vtEdge * dLeadInLength)
       LeadOut.ptPoint = Point3d( ptEndAtDepth + Edge.vtEdge * dLeadOutLength)
+
+   elseif sLeadInOutType == 'SpecialTangent' then
+
+      -- uscita con componente aggiuntiva perpendicolare
+      LeadIn.nType = MCH_MILL_LO.PERP_TG
+      local dStartEndOffset = 10
+      local ptEndAtDepthWithOffset = ptEndAtDepth + Edge.vtN * dStartEndOffset
+      local ptEndBladeCenterWithOffset = ptEndBladeCenter + Edge.vtN * dStartEndOffset
+
+      -- calcolo distanza per uscire dal box con questa lama nella direzione tangenziale
+      local dLeadInLength = CalculateLeadInOutLength( ptStartBladeCenter, Face.vtN, b3BoxPartExpanded, -Edge.vtEdge, Tool)
+      local dLeadOutLength = -CalculateLeadInOutLength( ptEndBladeCenterWithOffset, Face.vtN, b3BoxPartExpanded, -Edge.vtEdge, Tool)
+
+      -- componenti dell'attacco
+      LeadIn.dPerpDistance = 0
+      LeadIn.dTangentDistance = dLeadInLength
+      LeadOut.dPerpDistance = dStartEndOffset
+      LeadOut.dTangentDistance = dLeadOutLength
+
+      -- punti dell'attacco
+      LeadIn.ptPoint = Point3d( ptStartAtDepth - Edge.vtEdge * dLeadInLength)
+      LeadOut.ptPoint = Point3d( ptEndAtDepthWithOffset + Edge.vtEdge * dLeadOutLength)
+
+   elseif sLeadInOutType == 'SpecialTangentInverted' then
+
+      -- ingresso con componente aggiuntiva perpendicolare
+      LeadIn.nType = MCH_MILL_LI.TG_PERP
+      local dStartEndOffset = 10
+      local ptStartAtDepthWithOffset = ptStartAtDepth + Edge.vtN * dStartEndOffset
+      local ptStartBladeCenterWithOffset = ptStartBladeCenter + Edge.vtN * dStartEndOffset
+
+      -- calcolo distanza per uscire dal box con questa lama nella direzione tangenziale
+      local dLeadInLength = -CalculateLeadInOutLength( ptStartBladeCenterWithOffset, Face.vtN, b3BoxPartExpanded, Edge.vtEdge, Tool)
+      local dLeadOutLength = CalculateLeadInOutLength( ptEndBladeCenter, Face.vtN, b3BoxPartExpanded, Edge.vtEdge, Tool)
+
+      -- componenti dell'attacco
+      LeadIn.dPerpDistance = dStartEndOffset
+      LeadIn.dTangentDistance = dLeadInLength
+      LeadOut.dPerpDistance = 0
+      LeadOut.dTangentDistance = dLeadOutLength
+
+      -- punti dell'attacco
+      LeadIn.ptPoint = Point3d( ptStartAtDepthWithOffset - Edge.vtEdge * dLeadInLength)
+      LeadOut.ptPoint = Point3d( ptEndAtDepth + Edge.vtEdge * dLeadOutLength)
    end
 
    -- lunghezza totale attacco

LuaLibs/MachiningLib.lua

@@ -209,6 +209,9 @@ function MachiningLib.GetSplitMachinings( Machinings, SplittingPoints, Part)
             Machinings[nCurrentMachiningIndex].nFeatureSegment = j
             Machinings[nCurrentMachiningIndex].dLengthToMachine = Machinings[nCurrentMachiningIndex].dEdgeLength + Machinings[nCurrentMachiningIndex].LeadIn.dStartAddLength + Machinings[nCurrentMachiningIndex].LeadOut.dEndAddLength
             Machinings[nCurrentMachiningIndex].dTimeToMachine = MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machinings[nCurrentMachiningIndex], Part)
+            Machinings[nCurrentMachiningIndex].bIsFirstSegment = ( j == 1)
+            Machinings[nCurrentMachiningIndex].bIsLastSegment = ( j == nParts)
+            Machinings[nCurrentMachiningIndex].bIsMachiningSplitted = true
          end
       -- anche le lavorazioni non splittate necessitano del segmento assegnato
       else
@@ -411,6 +414,53 @@ local function TestEngagement( sBladeEngagement, Parameters, OptionalParameters)
       end
    end
 
+   -- se attacco tangenziale standard non possibile si prova l'attacco tangenziale speciale tutto da un lato
+   if not LeadInOut.Tangent then
+      -- prima si prova l'invertito (il più frequente)
+      TangentLeadInOut = LeadInOutLib.CalculateLeadInOut( 'SpecialTangentInverted', Parameters, LeadInOutOptionalParameters)
+      -- check extracorsa nei punti di attacco
+      PointsOnToolTipCenter = {
+         PreSimulationLib.GetPointOnToolTipCenter( TangentLeadInOut.LeadIn.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool),
+         PreSimulationLib.GetPointOnToolTipCenter( TangentLeadInOut.LeadOut.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool)
+      }
+      bOutOfStrokeTangent = PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool)
+      -- attacco tangenziale non in extracorsa: si verifica se è in collisione
+      if not bOutOfStrokeTangent then
+         CheckCollisionOptionalParameters.PointsToCheck = {}
+         table.insert( CheckCollisionOptionalParameters.PointsToCheck, TangentLeadInOut.LeadIn.ptPoint)
+         table.insert( CheckCollisionOptionalParameters.PointsToCheck, TangentLeadInOut.LeadOut.ptPoint)
+         local bCollisionFoundTangent, bMoveAfterSplitTangent = PreSimulationLib.CheckCollision( CheckCollisionParameters, CheckCollisionOptionalParameters)
+         -- attacco tangenziale possibile
+         if not bCollisionFoundTangent then
+            LeadInOut.Tangent = TangentLeadInOut
+            LeadInOut.Tangent.bMoveAfterSplit = bMoveAfterSplitTangent
+         end
+      end
+
+      if not LeadInOut.Tangent then
+         -- se speciale invertito non applicabile si prova lo speciale non invertito
+         TangentLeadInOut = LeadInOutLib.CalculateLeadInOut( 'SpecialTangent', Parameters, LeadInOutOptionalParameters)
+         -- check extracorsa nei punti di attacco
+         PointsOnToolTipCenter = {
+            PreSimulationLib.GetPointOnToolTipCenter( TangentLeadInOut.LeadIn.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool),
+            PreSimulationLib.GetPointOnToolTipCenter( TangentLeadInOut.LeadOut.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool)
+         }
+         bOutOfStrokeTangent = PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool)
+         -- attacco tangenziale non in extracorsa: si verifica se è in collisione
+         if not bOutOfStrokeTangent then
+            CheckCollisionOptionalParameters.PointsToCheck = {}
+            table.insert( CheckCollisionOptionalParameters.PointsToCheck, TangentLeadInOut.LeadIn.ptPoint)
+            table.insert( CheckCollisionOptionalParameters.PointsToCheck, TangentLeadInOut.LeadOut.ptPoint)
+            local bCollisionFoundTangent, bMoveAfterSplitTangent = PreSimulationLib.CheckCollision( CheckCollisionParameters, CheckCollisionOptionalParameters)
+            -- attacco tangenziale possibile
+            if not bCollisionFoundTangent then
+               LeadInOut.Tangent = TangentLeadInOut
+               LeadInOut.Tangent.bMoveAfterSplit = bMoveAfterSplitTangent
+            end
+         end
+      end
+   end
+
    -- se disponibili più attacchi si sceglie il più corto, altrimenti quello possibile
    if LeadInOut.Perpendicular and LeadInOut.Tangent then
       if LeadInOut.Perpendicular.dTotalLength > LeadInOut.Tangent.dTotalLength + 10 then

Messages/EgalTechEng.txt

@@ -319,4 +319,8 @@
 1000316=Autocam will apply a machining on the theoretical zero, to avoid collision if the theoretical piece length doesn't correspond to the real length
 1000317=Finish with mill
 1000318=Use a mill to finish the surface if split with chain saw
+1000319=Allow multiple short strips
+1000320=Allow multiple short strips
+1000321=Length limit to drop the waste
+1000322=If Cutting Strategy is set on AUTO, up to this length the software drop the waste, otherwise it'll keep attached
 // ----- End -----

Messages/EgalTechIta.txt

@@ -319,4 +319,8 @@
 1000316=Autocam applicherà una lavorazione sullo zero teorico per evitare collisioni se la lunghezza teorica del pezzo non corrisponde alla lunghezza reale
 1000317=Finisci con la fresa
 1000318=Utilizza una fresa per rifinire la superficie se tagliata con la sega a catena
+1000319=Permettere codoli multipli
+1000320=Permettere codoli multipli
+1000321=Lunghezza limite fino alla quale lo scarto viene staccato
+1000322=Se la strategia di taglio è impostata su AUTO, fino a questa lunghezza il software stacca gli scarti, altrimenti li mantiene attaccati
 // ----- End -----

Messages/EgalTechNld.txt

@@ -319,4 +319,8 @@
 1000316=Autocam past een bewerking toe op het theoretische nulpunt om botsingen te voorkomen als de theoretische lengte niet overeenkomt met de werkelijke lengte
 1000317=Afwerken met frees
 1000318=Gebruik een frees om het oppervlak na te bewerken als dit met de kettingzaag is gespleten
+1000319=Sta meerdere korte verbindingsstrips toe
+1000320=Sta meerdere korte verbindingsstrips toe
+1000321=Maximale lengte voor het uitwerpen van het reststuk
+1000322=Als de snijstrategie op AUTO staat, wordt het reststuk tot deze maximale lengte automatisch uitgeworpen; bij grotere lengtes blijft het reststuk aan het werkstuk bevestigd.
 // ----- 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/AvailableStrategyList.json

@@ -108,6 +108,10 @@
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]
@@ -151,6 +155,10 @@
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]
@@ -196,6 +204,10 @@
          {  "sName": "Rabbet-2-Through",
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          }
       ]
    },
@@ -224,6 +236,10 @@
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]
@@ -271,6 +287,10 @@
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]
@@ -314,6 +334,10 @@
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]
@@ -368,6 +392,10 @@
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]
@@ -455,6 +483,10 @@
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]
@@ -520,6 +552,10 @@
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]
@@ -575,6 +611,10 @@
             "sImage": "ConfigStrategy\\Rabbet-2-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
          },
+         {  "sName": "VGroove-2-Through",
+            "sImage": "ConfigStrategy\\VGroove-2-Through.png",
+            "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" }, { "sStrategyId": "STR0010"} ]
+         },
          {  "sName": "Cut-1-Through",
             "sImage": "ConfigStrategy\\Cut-1-Through.png",
             "StrategyList" : [ { "sStrategyId": "STR0002" }, { "sStrategyId": "STR0005" } ]

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/STR0005/STR0005.json

@@ -100,6 +100,18 @@
             }
          ]
       },
+      {
+         "sName": "dLengthLimitToDropWaste",
+         "sNameNge": "LEN_DROP_WASTE",
+         "sValue": "",
+         "sDescriptionShort": "Length limit to drop the waste",
+         "sDescriptionLong": "If Cutting Strategy is set on AUTO, up to this length the software drop the waste, otherwise it'll keep attached",
+         "idDescriptionShortMsg": 1000321,
+         "idDescriptionLongMsg": 1000322,
+         "sType": "d",
+         "sMessageId": " ",
+         "sMinUserLevel": "1"
+      },
       {
          "sName": "bDisableDicing",
          "sNameNge": "DISABLE_DICING",
@@ -136,6 +148,18 @@
          "sMessageId": " ",
          "sMinUserLevel": "1"
       },
+      {
+         "sName": "bAllowPerpendicularStrip",
+         "sNameNge": "ALLOW_PERPENDICULAR_STRIP",
+         "sValue": "false",
+         "sDescriptionShort": "Allow multiple short strips",
+         "sDescriptionLong": "Allow multiple short strips",
+         "idDescriptionShortMsg": 1000319,
+         "idDescriptionLongMsg": 1000320,
+         "sType": "b",
+         "sMessageId": " ",
+         "sMinUserLevel": "1"
+      },
       {
          "sName": "bFinishWithMill",
          "sNameNge": "ALLOW_FINISH_MILL",

Strategies/Standard/STR0005/STR0005.lua

@@ -100,8 +100,8 @@ function STR0005.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 dLengthLimitToDropWaste = Strategy.Parameters.dLengthLimitToDropWaste
 
    local bIsFeatureLong = FeatureLib.IsMachiningLong( Proc.b3Box:getDimX(), Part, { dMaxSegmentLength = BeamData.LONGCUT_ENDLEN})
    local bIsTwoFacesCommonEdgeTooLong = ( ( Proc.Topology and ( Proc.Topology.sName == 'Rabbet-2-Through' or Proc.Topology.sName == 'Bevel-2-Blind')) and IsTwoFacesCommonEdgeTooLong( Proc, Part))
@@ -109,10 +109,16 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
    -- lavorazione con codolo
    if ( Proc.nFct > 2 and bIsFeatureLong)
       or ( bFeatureHindersClamping and not bDropWaste)
+      or ( dLengthLimitToDropWaste and Proc.b3Box:getDimX() > dLengthLimitToDropWaste)
       or bKeepWasteAttached then
 
       local BladeKeepWasteResult
-      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dStripWidth = Strategy.Parameters.dStripWidth, bForced = bKeepWasteAttached}
+      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail,
+                                   dStripWidth = Strategy.Parameters.dStripWidth,
+                                   bAllowPerpendicularStrip = Strategy.Parameters.bAllowPerpendicularStrip,
+                                   bFinishWithMill = Strategy.Parameters.bFinishWithMill,
+                                   bForced = bKeepWasteAttached
+                                 }
       AuxiliaryData.bIgnoreNotClampableLength = true
       Blade.Result, BladeKeepWasteResult = BladeKeepWaste.Make( Proc, Part, OptionalParameters)
       dTimeToMachine = BladeKeepWasteResult.dTimeToMachine

Strategies/Standard/STR0012/STR0012.json

@@ -14,6 +14,55 @@
          "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": "dLengthLimitToDropWaste",
+         "sNameNge": "LEN_DROP_WASTE",
+         "sValue": "",
+         "sDescriptionShort": "Length limit to drop the waste",
+         "sDescriptionLong": "If Cutting Strategy is set on AUTO, up to this length the software drop the waste, otherwise it'll keep attached",
+         "idDescriptionShortMsg": 1000321,
+         "idDescriptionLongMsg": 1000322,
+         "sType": "d",
+         "sMessageId": " ",
+         "sMinUserLevel": "1"
+      },
       {
          "sName": "sCanDamageNextPiece",
          "sNameNge": "DAMAGE_NEXT_PIECE",
@@ -88,6 +137,30 @@
             }
          ]
       },
+      {
+         "sName": "dStripWidth",
+         "sNameNge": "STRIP_WIDTH",
+         "sValue": "5",
+         "sDescriptionShort": "Strip width",
+         "sDescriptionLong": "In case the waste is still kept attached, this is the wigth dimension of the strip",
+         "idDescriptionShortMsg": 1000129,
+         "idDescriptionLongMsg": 1000130,
+         "sType": "d",
+         "sMessageId": " ",
+         "sMinUserLevel": "1"
+      },
+      {
+         "sName": "bAllowPerpendicularStrip",
+         "sNameNge": "ALLOW_PERPENDICULAR_STRIP",
+         "sValue": "false",
+         "sDescriptionShort": "Allow multiple short strips",
+         "sDescriptionLong": "Allow multiple short strips",
+         "idDescriptionShortMsg": 1000319,
+         "idDescriptionLongMsg": 1000320,
+         "sType": "b",
+         "sMessageId": " ",
+         "sMinUserLevel": "1"
+      },
       {
          "sName": "dMaxWasteLength",
          "sSource": "GEN_dMaxWasteLength",

Strategies/Standard/STR0012/STR0012.lua

@@ -94,14 +94,18 @@ 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)
+   local dLengthLimitToDropWaste = Strategy.Parameters.dLengthLimitToDropWaste
 
    -- lavorazione con codolo
    if ( bFeatureHindersClamping and not bDropWaste)
+      or ( dLengthLimitToDropWaste and Proc.b3Box:getDimX() > dLengthLimitToDropWaste)
       or bKeepWasteAttached then
 
       local BladeKeepWasteResult
-      local OptionalParameters = { dExtendAfterTail = dExtendAfterTail, dStripWidth = 5, bFinishWithMill = false}
+      local OptionalParameters = { bAllowPerpendicularStrip = Strategy.Parameters.bAllowPerpendicularStrip,
+                                   dStripWidth = Strategy.Parameters.dStripWidth,
+                                   dExtendAfterTail = dExtendAfterTail, bFinishWithMill = false}
       AuxiliaryData.bIgnoreNotClampableLength = true
       TwoFaces.Result, BladeKeepWasteResult = BladeKeepWaste.Make( NewProc, Part, OptionalParameters)
       dTimeToMachine = BladeKeepWasteResult.dTimeToMachine
@@ -113,10 +117,10 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
    else
       local BladeToWasteResult
       local OptionalParameters = { dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume,
-                                 dMaxWasteLength = Strategy.Parameters.dMaxWasteLength,
+                                   dMaxWasteLength = Strategy.Parameters.dMaxWasteLength,
-                                 bSaveAddedGeometries = bAddMachining,
+                                   bSaveAddedGeometries = bAddMachining,
-                                 dExtendAfterTail = dExtendAfterTail,
+                                   dExtendAfterTail = dExtendAfterTail,
-                                 bReduceBladePath = Strategy.Parameters.bReduceBladePath
+                                   bReduceBladePath = Strategy.Parameters.bReduceBladePath
                                  }
       AuxiliaryData.bIgnoreNotClampableLength = false
       TwoFaces.Result, BladeToWasteResult = BladeToWaste.Make( NewProc, Part, OptionalParameters)

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/BLADEKEEPWASTE.lua

@@ -11,7 +11,8 @@ require( 'EgtBase')
 local FeatureLib = require( 'FeatureLib')
 local FaceData = require( 'FaceData')
 local MachiningLib = require( 'MachiningLib')
-local BeamLib = require('BeamLib')
+local BeamLib = require( 'BeamLib')
+local BeamData = require( 'BeamDataNew')
 -- strategie di base
 local FaceByBlade = require('FACEBYBLADE')
 local FaceByMill = require( 'FACEBYMILL')
@@ -146,10 +147,12 @@ local function MakeBottomFace( Proc, Part, BottomFace, EdgeToMachine, Parameters
    local dExtendAfterTail = Parameters.dExtendAfterTail
    local nToolIndex = Parameters.nToolIndex
    local dStripWidth = Parameters.dStripWidth
+   local bAllowPerpendicularStrip = Parameters.bAllowPerpendicularStrip
    local OtherBottomFace = Parameters.OtherBottomFace
 
    local dDepthToMachine = EdgeToMachine.dElevation / 2 - dStripWidth / 2
-   local OptionalParametersFaceByBlade1 = { dDepthToMachine = dDepthToMachine, bIsSplitFeature = bIsSplitFeature, dExtendAfterTail = dExtendAfterTail, nToolIndex = nToolIndex}
+   local OptionalParametersFaceByBlade1 = { dDepthToMachine = dDepthToMachine, bIsSplitFeature = bIsSplitFeature,
+                                            dExtendAfterTail = dExtendAfterTail, nToolIndex = nToolIndex}
    local EdgeToMachineOpposite = BeamLib.FindEdgeBestOrientedAsDirection( BottomFace.Edges, -EdgeToMachine.vtN)
 
    -- primo lato
@@ -175,7 +178,13 @@ local function MakeBottomFace( Proc, Part, BottomFace, EdgeToMachine, Parameters
       if OtherBottomFace and ( EdgeToMachine.idAdjacentFace == OtherBottomFace.id) then
          dStripWidth = TOOLS[Cutting2.nToolIndex].dThickness + 2 * dStripWidth
       end
-      dDepthToMachine = min( TOOLS[Cutting2.nToolIndex].dMaxMaterial, EdgeToMachine.dElevation - dStripWidth)
+      -- se richiesto, si calcola il codolo verticale
+      if bAllowPerpendicularStrip and FeatureLib.IsMachiningLong( Cutting1.dEdgeLength, Part) then
+         dDepthToMachine = TOOLS[Cutting2.nToolIndex].dMaxMaterial - 10
+      else
+         dDepthToMachine = min( TOOLS[Cutting2.nToolIndex].dMaxMaterial, EdgeToMachine.dElevation - dStripWidth)
+      end
+
       OptionalParametersFaceByBlade2.dDepthToMachine = dDepthToMachine
 
       Cutting2 = FaceByBlade.Make( Proc, Part, BottomFace, EdgeToMachine, OptionalParametersFaceByBlade2)
@@ -189,7 +198,13 @@ local function MakeBottomFace( Proc, Part, BottomFace, EdgeToMachine, Parameters
       if OtherBottomFace and ( EdgeToMachine.idAdjacentFace == OtherBottomFace.id) then
          dStripWidth = TOOLS[Cutting1.nToolIndex].dThickness + 2 * dStripWidth
       end
-      dDepthToMachine = min( TOOLS[Cutting1.nToolIndex].dMaxMaterial, EdgeToMachine.dElevation - dStripWidth)
+      -- se richiesto, si calcola il codolo verticale
+      if bAllowPerpendicularStrip and FeatureLib.IsMachiningLong( Cutting2.dEdgeLength, Part) then
+         dDepthToMachine = TOOLS[Cutting1.nToolIndex].dMaxMaterial - 10
+      else
+         dDepthToMachine = min( TOOLS[Cutting1.nToolIndex].dMaxMaterial, EdgeToMachine.dElevation - dStripWidth)
+      end
+
       OptionalParametersFaceByBlade1.dDepthToMachine = dDepthToMachine
 
       Cutting1 = FaceByBlade.Make( Proc, Part, BottomFace, EdgeToMachine, OptionalParametersFaceByBlade1)
@@ -250,6 +265,7 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
    local bFinishWithMill = ( OptionalParameters.bFinishWithMill ~= false)
    local dMillingOffsetFromSide = OptionalParameters.dMillingOffsetFromSide or 1
    local dStripWidth = OptionalParameters.dStripWidth or 5
+   local bAllowPerpendicularStrip = ( OptionalParameters.bAllowPerpendicularStrip and ( Part.b3Raw:getMin():getZ() + BeamData.VICE_MINH > Proc.b3Box:getMin():getZ() - 10 * GEO.EPS_SMALL)) or false
    local bForced = OptionalParameters.bForced or false
 
    -- volume della feature
@@ -296,6 +312,7 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
       dExtendAfterTail = dExtendAfterTail,
       nToolIndex = nToolIndex,
       dStripWidth = dStripWidth,
+      bAllowPerpendicularStrip = bAllowPerpendicularStrip,
       OtherBottomFace = BottomFace2
    }
    local Cuttings1 = MakeBottomFace( Proc, Part, BottomFace1, BottomEdgeToMachine1, Parameters1)
@@ -427,6 +444,37 @@ function BLADEKEEPWASTE.Make( Proc, Part, OptionalParameters)
       Machinings = MachiningLib.GetSplitMachinings( Machinings, FeatureSplittingPoints, Part)
    end
 
+   -- se codoli perpendicolari, si accorciano LeadIn/LeadOut
+   if bAllowPerpendicularStrip then
+      for j = 1, #Machinings do
+         if Machinings[j].bIsMachiningSplitted then
+            -- se primo spezzone
+            if Machinings[j].bIsFirstSegment then
+               if MachiningLib.StartsLeftSide( Machinings[j]) then
+                  Machinings[j].LeadIn.dStartAddLength = Machinings[j].LeadIn.dStartAddLength - Machinings[j].dToolMarkLength - dStripWidth
+                  Machinings[j].LeadOut.dEndAddLength = Machinings[j].LeadOut.dEndAddLength - dStripWidth
+               else
+                  Machinings[j].LeadOut.dEndAddLength = Machinings[j].LeadOut.dEndAddLength - Machinings[j].dToolMarkLength - dStripWidth
+                  Machinings[j].LeadIn.dStartAddLength = Machinings[j].LeadIn.dStartAddLength - dStripWidth
+               end
+            -- se ultimo spezzone
+            elseif Machinings[j].bIsLastSegment then
+               if MachiningLib.StartsLeftSide( Machinings[j]) then
+                  Machinings[j].LeadOut.dEndAddLength = Machinings[j].LeadOut.dEndAddLength - Machinings[j].dToolMarkLength - dStripWidth
+                  Machinings[j].LeadIn.dStartAddLength = Machinings[j].LeadIn.dStartAddLength - dStripWidth
+               else
+                  Machinings[j].LeadIn.dStartAddLength = Machinings[j].LeadIn.dStartAddLength - Machinings[j].dToolMarkLength - dStripWidth
+                  Machinings[j].LeadOut.dEndAddLength = Machinings[j].LeadOut.dEndAddLength - dStripWidth
+               end
+            -- se spezzoni centrali
+            else
+               Machinings[j].LeadIn.dStartAddLength = Machinings[j].LeadIn.dStartAddLength - Machinings[j].dToolMarkLength - dStripWidth
+               Machinings[j].LeadOut.dEndAddLength = Machinings[j].LeadOut.dEndAddLength - Machinings[j].dToolMarkLength - dStripWidth
+            end
+         end
+      end
+   end
+
    -- ordinamento
    table.sort( Machinings, SortMachiningsBySegment)
 

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

StrategyLibs/FACEBYBLADE.lua

@@ -583,6 +583,8 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       Cutting.dToolMarkLength = abs( Cutting.LeadIn.dStartAddLength)
    elseif Cutting.bIsEndClosed then
       Cutting.dToolMarkLength = abs( Cutting.LeadOut.dEndAddLength)
+   else
+      Cutting.dToolMarkLength = LeadInOutLib.GetToolAddLength( TOOLS[Cutting.nToolIndex].dDiameter, dDepthToMachine)
    end
    -- area lavorata
    Cutting.dAreaToMachine = min( EdgeToMachine.dElevation, Cutting.dDepthToMachine) * ( min( Cutting.dEdgeLength, Cutting.dLengthToMachine + 2 * Cutting.dToolMarkLength))