Prime modifiche per indice posizionamento feature. La feature lavorata con codolo deve stare dal lato opposto della battuta.

LuaLibs/BeamExec.lua

@@ -1174,9 +1174,6 @@ 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])
 
-                     -- 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
@@ -1434,8 +1431,6 @@ 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)) and not Proc.ChosenStrategy.Result then
                Proc.ChosenStrategy.Result = Result
@@ -1722,6 +1717,7 @@ local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo, bRePro
          SingleCombination.nRotations = 0
          SingleCombination.dTotalTimeToMachine = 0
          SingleCombination.dTotalQuality = 0
+         SingleCombination.dFeatureRotationIndex = 0
          SingleCombination.dTotalCompletionIndex = 0
          SingleCombination.nComplete = 0
          SingleCombination.nNotComplete = 0
@@ -1797,6 +1793,7 @@ local function GetCombinationListFromMatrix( ProcessingsOnPart, PartInfo, bRePro
                         SingleCombination.dTotalTimeToMachine = SingleCombination.dTotalTimeToMachine + Data.dTimeToMachine
                         SingleCombination.dTotalQuality = SingleCombination.dTotalQuality + Data.dQuality
                         SingleCombination.dTotalCompletionIndex = SingleCombination.dTotalCompletionIndex + Data.dCompletionIndex
+                        SingleCombination.dFeatureRotationIndex = SingleCombination.dFeatureRotationIndex + ( Data.dFeatureRotationIndex or 3)
                         SingleCombination.nComplete = SingleCombination.nComplete + EgtIf( Data.bComplete, 1, 0)
                         SingleCombination.nNotComplete = SingleCombination.nNotComplete + EgtIf( Data.bNotComplete, 1, 0)
                         SingleCombination.nNotExecute = SingleCombination.nNotExecute + EgtIf( Data.bNotApplicable, 1, 0)
@@ -2393,8 +2390,6 @@ function BeamExec.ProcessAlternatives( PARTS)
 
                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
                HeadCut.nIndexRotation = nRotHeadCut
@@ -2436,7 +2431,7 @@ function BeamExec.ProcessAlternatives( PARTS)
                -- 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])
+               local HeadcutInfo, TailcutInfo = GetHeadTailInfoForNesting( HeadCut, TailCut, PARTS[nPart])
                if HeadcutInfo then
                   -- offset e vettori vanno adeguati alla rotazione attuale (inversione è già corretta)
                   BeamLib.RotateTableFromIndexInPlace( HeadcutInfo.OffsetX, nRotation)

LuaLibs/FeatureLib.lua

@@ -788,15 +788,17 @@ function FeatureLib.CalculateCombinationsCompositeRating( CombinationsList, sMac
          local dIndexWeightTimeToMachine =  5 - ( 4 * ( EgtClamp( CombinationsList[n].dTotalTimeToMachine / CombinationsList.dAllCombinationsTotalTime, 0, 1)))
 
          -- si calcolano gli indici pesati in base alla configurazione utente. Possibili parametri di configurazione:
-         local dQuality, dCompletion, dTime, dCoeffQuality, dCoeffCompletion, dCoeffTime
+         local dQuality, dCompletion, dTime, dFeatureRotationIndex, dCoeffQuality, dCoeffCompletion, dCoeffTime
          dCoeffQuality, dCoeffCompletion, dCoeffTime = GetMachiningStrategyCoefficients( sMachiningStrategy)
 
 
          dQuality = CombinationsList[n].dTotalQuality * dCoeffQuality
          dCompletion = CombinationsList[n].dTotalCompletionIndex * dCoeffCompletion
          dTime = dIndexWeightTimeToMachine * dCoeffTime
+         dFeatureRotationIndex = CombinationsList[n].dFeatureRotationIndex
 
-         CombinationsList[n].dTotalRating = dQuality + dCompletion + dTime   -- TODO da verificare se meglio sommare o moltiplicare gli indici
+         -- TODO da verificare se meglio sommare o moltiplicare gli indici
+         CombinationsList[n].dTotalRating = dQuality + dCompletion + dTime + dFeatureRotationIndex
       else
          CombinationsList[n].dTotalRating = 0
       end

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

Messages/EgalTechEng.txt

@@ -319,4 +319,6 @@
 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
 // ----- End -----

Messages/EgalTechIta.txt

@@ -319,4 +319,6 @@
 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
 // ----- End -----

Messages/EgalTechNld.txt

@@ -319,4 +319,6 @@
 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
 // ----- End -----

Strategies/Standard/STR0001/STR0001.lua

@@ -292,7 +292,7 @@ local function GetTenonMachiningResult( Proc, Result)
       else
          TotalResult.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
       end
-      TotalResult.nFeatureRotationIndex = GetFeatureRotationIndex( Proc)
+      TotalResult.dFeatureRotationIndex = GetFeatureRotationIndex( Proc)
       TotalResult.dTimeToMachine = Result.Milling.dTimeToMachine + Result.Cutting.dTimeToMachine
       TotalResult.sInfo = ''
    -- lavorazione incompleta

Strategies/Standard/STR0005/STR0005.json

@@ -136,6 +136,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

@@ -46,6 +46,20 @@ local function IsTwoFacesCommonEdgeTooLong( Proc, Part)
    return bIsTwoFacesCommonEdgeTooLong
 end
 
+-------------------------------------------------------------------------------------------------------------
+-- si cerca di tenere la feature rivolta verso il fronte o sopra, cioè dal lato opposto la battuta
+local function GetFeatureRotationIndex( Proc)
+   local nVoteIndex
+
+   if Proc.MainFaces.BottomFaces[1].vtN:getY() < 0 or Proc.MainFaces.BottomFaces[1].vtN:getZ() < 0 then
+      nVoteIndex = 2
+   else
+      nVoteIndex = 3
+   end
+
+   return nVoteIndex
+end
+
 -------------------------------------------------------------------------------------------------------------
 function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
    -- carico parametri da default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
@@ -112,7 +126,12 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
       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
@@ -120,6 +139,7 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
       dCompletionPercentage = BladeKeepWasteResult.dCompletionPercentage
       dQuality = BladeKeepWasteResult.dQuality
       Strategy.Result.sInfo = BladeKeepWasteResult.sInfo or ''
+      Strategy.Result.dFeatureRotationIndex = GetFeatureRotationIndex( Proc)
    end
 
    -- lavorazione a cubetti / taglio singolo
@@ -157,6 +177,7 @@ function STR0005.Make( bAddMachining, Proc, Part, CustomParameters)
       dMRRBlade = BladeKeepWasteResult.dMRR
       dCompletionPercentage = BladeKeepWasteResult.dCompletionPercentage
       dQuality = BladeKeepWasteResult.dQuality
+      Strategy.Result.dFeatureRotationIndex = GetFeatureRotationIndex( Proc)
    end
 
    -- lavorazione eventuale terza faccia tipo RidgeLap

Strategies/Standard/STR0006/STR0006.lua

@@ -247,7 +247,7 @@ local function GetTenonMachiningResult( Proc, Result)
       TotalResult.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
       TotalResult.dMRR =  ( Result.Milling.dMRR + Result.Cutting.dMRR) / 2
       TotalResult.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Strategy.Machining.bCuttingWithMill, 'STD', 'FINE'))
-      TotalResult.nFeatureRotationIndex = GetFeatureRotationIndex( Proc)
+      TotalResult.dFeatureRotationIndex = GetFeatureRotationIndex( Proc)
       TotalResult.dTimeToMachine = Result.Milling.dTimeToMachine + Result.Cutting.dTimeToMachine
       TotalResult.sInfo = ''
    -- lavorazione incompleta

Strategies/Standard/STR0007/STR0007.lua

@@ -249,7 +249,7 @@ function GetMortiseMachiningResult( Proc, Result)
          sQuality = 'STD'
       end
       TotalResult.dQuality = FeatureLib.GetStrategyQuality( sQuality)
-      TotalResult.nFeatureRotationIndex = GetFeatureRotationIndex( Proc)
+      TotalResult.dFeatureRotationIndex = GetFeatureRotationIndex( Proc)
       TotalResult.sInfo = ''
    -- lavorazione mortasa completa
    elseif Strategy.Machining.Milling.bIsApplicable and not( Proc.FeatureInfo.bIsFrontMortise) then
@@ -258,7 +258,7 @@ function GetMortiseMachiningResult( Proc, Result)
       TotalResult.dMRR = Result.Milling.dMRR
       local sQuality = EgtIf( Strategy.Machining.AntiSplint.bIsApplicable, 'BEST', 'STD')
       TotalResult.dQuality = FeatureLib.GetStrategyQuality( sQuality)
-      TotalResult.nFeatureRotationIndex = GetFeatureRotationIndex( Proc)
+      TotalResult.dFeatureRotationIndex = GetFeatureRotationIndex( Proc)
       TotalResult.sInfo = ''
    -- lavorazione incompleta
    elseif Strategy.Machining.Cutting.bIsApplicable then

Strategies/Standard/STR0012/STR0012.json

@@ -125,6 +125,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

@@ -18,6 +18,20 @@ local Strategy = {}
 local RidgeLap = {}
 RidgeLap.Result = {}
 
+-------------------------------------------------------------------------------------------------------------
+-- si cerca di tenere la feature rivolta verso il fronte o sopra, cioè dal lato opposto la battuta
+local function GetFeatureRotationIndex( Proc)
+   local nVoteIndex
+
+   if Proc.MainFaces.BottomFaces[1].vtN:getY() < 0 or Proc.MainFaces.BottomFaces[1].vtN:getZ() < 0 then
+      nVoteIndex = 2
+   else
+      nVoteIndex = 3
+   end
+
+   return nVoteIndex
+end
+
 -------------------------------------------------------------------------------------------------------------
 -- TODO risolvere problemi calcolo volume nullo se facce rimosse
 -- TODO gestire lavorazione con svuotatura
@@ -101,22 +115,25 @@ function STR0012.Make( bAddMachining, Proc, Part, CustomParameters)
       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
       dMRRBlade = BladeKeepWasteResult.dMRR
       dCompletionPercentage = BladeKeepWasteResult.dCompletionPercentage
       dQuality = BladeKeepWasteResult.dQuality
+      Strategy.Result.dFeatureRotationIndex = GetFeatureRotationIndex( NewProc)
 
    -- lavorazione a cubetti facce concave
    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)

StrategyLibs/BLADEKEEPWASTE.lua

@@ -146,10 +146,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,8 +177,15 @@ 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
+      OptionalParametersFaceByBlade2.bAllowPerpendicularStrip = bAllowPerpendicularStrip
 
       Cutting2 = FaceByBlade.Make( Proc, Part, BottomFace, EdgeToMachine, OptionalParametersFaceByBlade2)
       Cutting2.nInternalSortingPriority = 2
@@ -189,8 +198,15 @@ 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
+      OptionalParametersFaceByBlade1.bAllowPerpendicularStrip = bAllowPerpendicularStrip
 
       Cutting1 = FaceByBlade.Make( Proc, Part, BottomFace, EdgeToMachine, OptionalParametersFaceByBlade1)
       Cutting1.nInternalSortingPriority = 2
@@ -250,6 +266,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 or false
    local bForced = OptionalParameters.bForced or false
 
    -- volume della feature
@@ -296,6 +313,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 +445,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)