- in BeamExec altre correzioni riguardanti la sostituzione dei tagli di testa o coda

- inHEADCUT e TAILCUT, se non è taglio originale, si calcola risultato anche per CalculateStrategies

LuaLibs/BeamExec.lua

@@ -966,10 +966,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,6 +980,10 @@ 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.sFamily = 'HeadCut'
@@ -1131,6 +1131,10 @@ end
 -------------------------------------------------------------------------------------------------------------
 -- funzione che processa tutte le feature del pezzo
 local function CalculateStrategies( vProcSingleRot, Part)
+   local nCounter = 0
+   repeat
+      nCounter = nCounter + 1
+      local bToReprocess = false
       -- per ogni feature
       for i = 1, #vProcSingleRot do
          -- processo tutte le feature attive
@@ -1162,6 +1166,33 @@ local function CalculateStrategies( vProcSingleRot, Part)
                      -- 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])
 
+                     -- 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
+                           Proc.HeadProcOriginal.nFlg = 1
+                           Proc.HeadProcOriginal.nIndexMasterProc = nil
+                           Proc.Topology = FeatureLib.ClassifyTopology( Proc, Part)
+                           -- TODO è corretto? se era già un taglio a zero non lo devo più fare
+                           if Proc.Topology.sName == 'HeadCut' then
+                              Proc.nFlg = 0
+                           end
+                           Proc.SlaveProcIndexes = nil
+                           bToReprocess = true
+                           break
+                        elseif ID.IsTailCut( Proc) and not Proc.bIsOriginalTailcut then
+                           Proc.TailProcOriginal.nFlg = 1
+                           Proc.TailProcOriginal.nIndexMasterProc = nil
+                           Proc.Topology = FeatureLib.ClassifyTopology( Proc, Part)
+                           -- TODO è corretto? se era già un taglio a zero non lo devo più fare
+                           if Proc.Topology.sName == 'TailCut' then
+                              Proc.nFlg = 0
+                           end
+                           Proc.SlaveProcIndexes = nil
+                           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
@@ -1184,11 +1215,16 @@ local function CalculateStrategies( vProcSingleRot, Part)
                      Proc.AvailableStrategies[nIndexCurrentStrategy].Result.sStatus = 'Not-Applicable'
                   end
                end
+               if bToReprocess then
+                  break
+               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
 
@@ -1382,7 +1418,7 @@ local function CalculateMachinings( vProc, Part, nInitialRotation)
             -- 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)
             -- 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

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

@@ -20,14 +20,7 @@ local function GetExtraAddLengthInclinedSides( Face, Edge)
       return 0, 0
    end
 
-   local nPreviousEdgeIndex = Edge.id + 1 - 1
+   local nPreviousEdgeIndex, nNextEdgeIndex = BeamLib.GetAdjacentIndices( Edge.id + 1, #Face.Edges)
-   if nPreviousEdgeIndex < 1 then
-      nPreviousEdgeIndex = #Face.Edges
-   end
-   local nNextEdgeIndex = Edge.id + 1 + 1
-   if nNextEdgeIndex > #Face.Edges then
-      nNextEdgeIndex = 1
-   end
 
    local vtEdgePrevious = Face.Edges[nPreviousEdgeIndex].vtEdge
    local vtEdgeNext = Face.Edges[nNextEdgeIndex].vtEdge
@@ -99,6 +92,14 @@ local function CalculateLeadInOutLength( ptToolCenter, vtNFace, b3Box, vtLeadInO
 end
 
 
+-------------------------------------------------------------------------------------------------------------
+local function GetToolAddLength( dToolDiameter, dDepthToMachine)
+   local dCheckDepth = min( dToolDiameter / 2, dDepthToMachine)
+   local dToolAddLength = sqrt( dCheckDepth * dToolDiameter - dCheckDepth * dCheckDepth)
+
+   return dToolAddLength
+end
+
 -------------------------------------------------------------------------------------------------------------
 function LeadInOutLib.CalculateLeadInOut( sLeadInOutType, Parameters, OptionalParameters)
 
@@ -118,7 +119,7 @@ function LeadInOutLib.CalculateLeadInOut( sLeadInOutType, Parameters, OptionalPa
    local bIsEndClosed = not Edge.bIsEndOpen
 
    -- accorciamento per lati chiusi
-   LeadInOut.dToolMarkLength = sqrt( dDepthToMachine * Tool.dDiameter - dDepthToMachine * dDepthToMachine)
+   LeadInOut.dToolAddLength = 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
@@ -140,14 +141,14 @@ function LeadInOutLib.CalculateLeadInOut( sLeadInOutType, Parameters, OptionalPa
 
    -- calcolo allungamenti / accorciamenti
    if bIsStartClosed and bIsEndClosed then
-      LeadIn.dStartAddLength = -LeadInOut.dToolMarkLength - LeadInOut.dExtraAddLengthStart
+      LeadIn.dStartAddLength = -LeadInOut.dToolAddLength - LeadInOut.dExtraAddLengthStart
-      LeadOut.dEndAddLength = -LeadInOut.dToolMarkLength - LeadInOut.dExtraAddLengthEnd
+      LeadOut.dEndAddLength = -LeadInOut.dToolAddLength - LeadInOut.dExtraAddLengthEnd
    elseif bIsStartClosed then
-      LeadIn.dStartAddLength = -LeadInOut.dToolMarkLength - LeadInOut.dExtraAddLengthStart
+      LeadIn.dStartAddLength = -LeadInOut.dToolAddLength - LeadInOut.dExtraAddLengthStart
       -- eventuale correzione per accorciamento maggiore di larghezza tasca
       LeadOut.dEndAddLength = max( -LeadIn.dStartAddLength - Edge.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
    elseif bIsEndClosed then
-      LeadOut.dEndAddLength = -LeadInOut.dToolMarkLength - LeadInOut.dExtraAddLengthEnd
+      LeadOut.dEndAddLength = -LeadInOut.dToolAddLength - LeadInOut.dExtraAddLengthEnd
       -- eventuale correzione per accorciamento maggiore di larghezza tasca
       LeadIn.dStartAddLength = max( -LeadOut.dEndAddLength - Edge.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
    else

NestProcessNew.lua

@@ -191,6 +191,19 @@ local Parts = {}
 -- ciclo su pezzi per aggiungerli al nesting
 local dTotLen = 0
 for nPartId, nCount in pairs( PARTLIST) do
+   -- verifico se usa etichette
+   local sTagList = EgtGetInfo( nPartId, 'LuxTagList')
+   if sTagList and #sTagList then
+      local TagTypeList = EgtSplitString( sTagList, ';')
+      local UnusedTagList = EgtSplitString( TagTypeList[1], ',')
+      if #UnusedTagList < nCount then
+         NEST.ERR = 12
+         NEST.MSG = 'Errore! Tentativo di nestare piu\' pezzi delle etichette disponibili!'
+         WriteErrToLogFile( NEST.ERR, NEST.MSG)
+         PostErrView( NEST.ERR, NEST.MSG)
+      end
+   end
+   
    -- recupero lunghezza pezzo
    local Len = EgtGetInfo( nPartId, "L", 'd')
    local DispLen = EgtIf( Len <= 1000, 2000, 0) --EgtIf( Len <= 2000, max( 2000, 6000 - Len), 0)
@@ -500,6 +513,9 @@ for nMachineIndex = 1, #NEST.MACHINELIST do
                end
             end
             local nAssignedTagIndex = #UnusedTagList
+            if nAssignedTagIndex == 0 then
+               EgtOutLog( 'Errore! Etichetta per pezzo non trovata dopo nesting!')
+            else
                local sAssignedTag = UnusedTagList[nAssignedTagIndex]
                -- creo stringa per info etichette aggiornata
                local sNewTagList = ''
@@ -520,6 +536,7 @@ for nMachineIndex = 1, #NEST.MACHINELIST do
             end
          end
       end
+   end
    EgtResetCurrMachGroup()
 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 and not Part.GeneralParameters.GEN_bGetAlternativesNesting2D 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
@@ -80,7 +105,7 @@ 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 and not Part.GeneralParameters.GEN_bGetAlternativesNesting2D then
          bExecutePrecutOnly = Part.dHeadOverMaterial < 20
          
          if Strategy.SplitStrategy and #Strategy.SplitStrategy > 0 then
@@ -101,25 +126,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,11 +147,19 @@ function HEADCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       end
 
       return bAreAllMachiningsAdded, Strategy.Result
-   else
+
-      return nil, Strategy.Result
+   elseif not Proc.bIsOriginalHeadcut then
+
+      Strategy.Machining = CalculateHeadCut( Proc, Part)
+
+      if not Strategy.Machining or #Strategy.Machining == 0 then
+         Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Head machining not possible')
       end
    end
 
+   return nil, Strategy.Result
+end
+
 -------------------------------------------------------------------------------------------------------------
 
  return HEADCUT

Strategies/Standard/STR0007/STR0007.lua

@@ -30,6 +30,7 @@ local function GetSCC( Machining)
 end
 
 -------------------------------------------------------------------------------------------------------------
+-- TODO l'utensile non viene scelto correttamente in base alla dimensione della geometria da lavorare!
 function GetMortiseStrategy( Proc, Part)
    local Machining = {}
    Machining.Milling = {}

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 = {}
@@ -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
@@ -119,7 +144,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 +165,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,11 +193,19 @@ function TAILCUT.Make( bAddMachining, Proc, Part, CustomParameters)
       end
 
       return bAreAllMachiningsAdded, Strategy.Result
-   else
+
-      return nil, Strategy.Result
+   elseif not Proc.bIsOriginalTailcut then
+
+      Strategy.Machining = CalculateTailCut( Proc, Part)
+
+      if not Strategy.Machining or #Strategy.Machining == 0 then
+         Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Tail machining not possible')
       end
    end
 
+   return nil, Strategy.Result
+end
+
 -------------------------------------------------------------------------------------------------------------
 
  return TAILCUT

StrategyLibs/FACEBYBLADE.lua

@@ -607,7 +607,7 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       end
       local bStartLeft = MachiningLib.StartsLeftSide( Cutting)
       local dAddLengthLeftSide = Cutting.LeadOut.dEndAddLength
-      local dAddLengthToReduce = sqrt( Cutting.dDepthToMachine * TOOLS[Cutting.nToolIndex].dDiameter - Cutting.dDepthToMachine * Cutting.dDepthToMachine)
+      local dToolAddLength = sqrt( Cutting.dDepthToMachine * TOOLS[Cutting.nToolIndex].dDiameter - Cutting.dDepthToMachine * Cutting.dDepthToMachine)
       if bStartLeft then
          dAddLengthLeftSide = Cutting.LeadIn.dStartAddLength
       end
@@ -618,15 +618,15 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
          else
             Cutting.bIsApplicable = false
          end
-      elseif dAddLengthLeftSide + dAddLengthToReduce > dExtendAfterTail then
+      elseif dAddLengthLeftSide + dToolAddLength > dExtendAfterTail then
          if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
             Cutting.sStage = 'AfterTail'
             Cutting.bMoveAfterSplit = true
          else
             if bStartLeft then
-               Cutting.LeadIn.dStartAddLength = - dAddLengthToReduce + dExtendAfterTail
+               Cutting.LeadIn.dStartAddLength = - dToolAddLength + dExtendAfterTail
             else
-               Cutting.LeadOut.dEndAddLength = - dAddLengthToReduce + dExtendAfterTail
+               Cutting.LeadOut.dEndAddLength = - dToolAddLength + dExtendAfterTail
             end
          end
       end

StrategyLibs/FACEBYCHAINSAW.lua

@@ -17,8 +17,8 @@ local function CalculateLeadInOut( Machining, EdgeToMachine, sSideToMachine, dLe
    -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
 
    -- si determina l'eventuale riduzione da applicare in caso di inizio o fine chiusi
-   local dAddLengthToReduce = 0
+   local dToolAddLength = 0
-   dAddLengthToReduce = TOOLS[Machining.nToolIndex].dDiameter / 2
+   dToolAddLength = TOOLS[Machining.nToolIndex].dDiameter / 2
 
    if Machining.bInvert then
       Machining.bIsStartClosed, Machining.bIsEndClosed = Machining.bIsEndClosed, Machining.bIsStartClosed
@@ -29,16 +29,16 @@ local function CalculateLeadInOut( Machining, EdgeToMachine, sSideToMachine, dLe
    LeadIn.dStartAddLength = 0
    LeadOut.dEndAddLength = 0
    if sSideToMachine == 'End' then
-      LeadIn.dStartAddLength = dAddLengthToReduce + dLengthToMachine + BeamData.CUT_EXTRA - EdgeToMachine.dLength
+      LeadIn.dStartAddLength = dToolAddLength + dLengthToMachine + BeamData.CUT_EXTRA - EdgeToMachine.dLength
    elseif Machining.bIsStartClosed then
-      LeadIn.dStartAddLength = -dAddLengthToReduce
+      LeadIn.dStartAddLength = -dToolAddLength
    else
       LeadIn.dStartAddLength = BeamData.CUT_EXTRA
    end
    if sSideToMachine == 'Start' then
-      LeadOut.dEndAddLength = dAddLengthToReduce + dLengthToMachine + BeamData.CUT_EXTRA - EdgeToMachine.dLength
+      LeadOut.dEndAddLength = dToolAddLength + dLengthToMachine + BeamData.CUT_EXTRA - EdgeToMachine.dLength
    elseif Machining.bIsEndClosed then
-      LeadOut.dEndAddLength = -dAddLengthToReduce
+      LeadOut.dEndAddLength = -dToolAddLength
    else
       LeadOut.dEndAddLength = BeamData.CUT_EXTRA
    end

StrategyLibs/FACEBYMILL.lua

@@ -58,11 +58,19 @@ local function GetLeadInOutType( Machining)
 end
 
 
+local function GetToolAddLength( dToolDiameter, dDepthToMachine)
+   local dCheckDepth = min( dToolDiameter / 2, dDepthToMachine)
+   local dToolAddLength = sqrt( dCheckDepth * dToolDiameter - dCheckDepth * dCheckDepth)
+
+   return dToolAddLength
+end
+
+
 local function CalculateLeadInOut( Machining, EdgeToMachine, bIsSplitFeature)
    -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
 
    -- si determina l'eventuale riduzione da applicare in caso di inizio o fine chiusi
-   local dAddLengthToReduce = sqrt( Machining.dDepthToMachine * TOOLS[Machining.nToolIndex].dDiameter - Machining.dDepthToMachine * Machining.dDepthToMachine)
+   local dToolAddLength = GetToolAddLength( TOOLS[Machining.nToolIndex].dDiameter, Machining.dDepthToMachine)
 
    if Machining.bInvert then
       Machining.bIsStartClosed, Machining.bIsEndClosed = Machining.bIsEndClosed, Machining.bIsStartClosed
@@ -106,14 +114,14 @@ local function CalculateLeadInOut( Machining, EdgeToMachine, bIsSplitFeature)
    LeadIn.dCompLength = 0
    LeadOut.dCompLength = 0
    if Machining.bIsStartClosed and Machining.bIsEndClosed then
-      LeadIn.dStartAddLength = -dAddLengthToReduce
+      LeadIn.dStartAddLength = -dToolAddLength
-      LeadOut.dEndAddLength = -dAddLengthToReduce
+      LeadOut.dEndAddLength = -dToolAddLength
    elseif Machining.bIsStartClosed then
-      LeadIn.dStartAddLength = -dAddLengthToReduce
+      LeadIn.dStartAddLength = -dToolAddLength
       -- eventuale correzione per accorciamento maggiore di larghezza tasca
       LeadOut.dEndAddLength = max( -LeadIn.dStartAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
    elseif Machining.bIsEndClosed then
-      LeadOut.dEndAddLength = -dAddLengthToReduce
+      LeadOut.dEndAddLength = -dToolAddLength
       -- eventuale correzione per accorciamento maggiore di larghezza tasca
       LeadIn.dStartAddLength = max( -LeadOut.dEndAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
    else
@@ -421,7 +429,7 @@ function FACEBYMILL.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPara
       end
       local bStartLeft = MachiningLib.StartsLeftSide( Milling)
       local dAddLengthLeftSide = Milling.LeadOut.dEndAddLength
-      local dAddLengthToReduce = sqrt( Milling.dDepthToMachine * TOOLS[Milling.nToolIndex].dDiameter - Milling.dDepthToMachine * Milling.dDepthToMachine)
+      local dToolAddLength = sqrt( Milling.dDepthToMachine * TOOLS[Milling.nToolIndex].dDiameter - Milling.dDepthToMachine * Milling.dDepthToMachine)
       if bStartLeft then
          dAddLengthLeftSide = Milling.LeadIn.dStartAddLength
       end
@@ -431,14 +439,14 @@ function FACEBYMILL.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPara
          else
             Milling.bIsApplicable = false
          end
-      elseif dAddLengthLeftSide + dAddLengthToReduce > dExtendAfterTail then
+      elseif dAddLengthLeftSide + dToolAddLength > dExtendAfterTail then
          if MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part) then
             Milling.sStage = 'AfterTail'
          else
             if bStartLeft then
-               Milling.LeadIn.dStartAddLength = - dAddLengthToReduce + dExtendAfterTail
+               Milling.LeadIn.dStartAddLength = - dToolAddLength + dExtendAfterTail
             else
-               Milling.LeadOut.dEndAddLength = - dAddLengthToReduce + dExtendAfterTail
+               Milling.LeadOut.dEndAddLength = - dToolAddLength + dExtendAfterTail
             end
          end
       end