- in PreSimulationLIb correzioni importanti in test collisione

- in STR0009 aggiunto antischeggia di lama e, nel caso sia disattivato, lavorazione con lama dell'eventuale faccia inclinata

BatchProcessNew.lua

@@ -492,6 +492,7 @@ if bToProcess then
          return
       end
 
+      -- TODO in caso di  "GEN_sPiecesLoadingPosition = FULL_PRE_ROTATION"  bisogna controllare anche sezione ribaltata di 90°
       -- Verifico sezione barra non troppo grande
       if not BeamData.MAX_WIDTH2 or not BeamData.MAX_HEIGHT2 then
          if ( dRawW > BeamData.MAX_WIDTH + 10 * GEO.EPS_SMALL or dRawH > BeamData.MAX_HEIGHT + 10 * GEO.EPS_SMALL) then

GetBeamData.lua

@@ -0,0 +1,44 @@
+-- GetWallData.lua by Egaltech s.r.l. 2022/06/28
+-- Recupero dati da file WallData.lua di macchina
+
+-- Intestazioni
+require( 'EgtBase')
+_ENV = EgtProtectGlobal()
+EgtEnableDebug( false)
+
+-- Per test
+--GWD = {}
+--GWD.MACHINE = 'Essetre-90480019_MW'
+
+local sLog = 'GetBeamData : ' .. GWD.MACHINE
+EgtOutLog( sLog)
+
+-- Imposto direttorio libreria specializzata per Travi
+EgtAddToPackagePath( GWD.BASEDIR .. '\\LuaLibs\\?.lua')
+
+-- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
+local sMachDir = EgtGetCurrMachineDir()
+if not EgtExistsFile( sMachDir .. '\\Beam\\BeamDataNew.lua') then
+   GWD.ERR = 12
+   GWD.MSG = 'Error not configured for beam machine : ' .. GWD.MACHINE
+   WriteErrToLogFile( GWD.ERR, GWD.MSG)
+   PostErrView( GWD.ERR, GWD.MSG)
+   return
+end
+
+-- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie
+EgtRemoveBaseMachineDirFromPackagePath()
+EgtAddToPackagePath( sMachDir .. '\\Beam\\?.lua')
+
+-- Carico i dati globali
+_G.package.loaded.BeamData = nil
+local BD = require( 'BeamDataNew')
+
+-- Assegno valori di interesse
+GWD.SIMUL_VIEW_DIR = BD.SIMUL_VIEW_DIR
+GWD.OVM_MID = BD.OVM_MID
+
+-- Tutto ok
+GWD.ERR = 0
+
+EgtOutLog( ' +++ GetBeamData completed')

LuaLibs/BeamExec.lua

@@ -1772,8 +1772,9 @@ function BeamExec.ProcessMachinings( PARTS, bIsFlipRot)
          local nInitialPosition = MatrixResult.nInitialPosition
          -- PREROTAZIONE PEZZO
          if MatrixResult.nInitialPosition ~= 1 or PARTS[nPart].bPartInCombiIsInverted then
-            -- si toglie il pezzo dal grezzo per poter fare operazioni
-            EgtRemovePartFromRawPart( PARTS[nPart].id)
+            -- si esce dalle lavorazioni e si torna in disegna
+            local nCurrMachGroup = EgtGetCurrMachGroup()
+            EgtResetCurrMachGroup()
 
             -- salvo situazione precedente su lista BEAM ( scrittura variabili globali per interfaccia)
             if bIsFlipRot then
@@ -1795,11 +1796,8 @@ function BeamExec.ProcessMachinings( PARTS, bIsFlipRot)
                EgtRotate( PARTS[nPart].id, ptRot, X_AX(), nRotationDeg, GDB_RT.GLOB)
             end
 
-            -- si rimette il pezzo nel grezzo
-            EgtAddPartToRawPart( PARTS[nPart].id, {0,0,0}, PARTS[nPart].idRaw)
-
-            -- dico che il pezzo originale è nella posizione iniziale come arriva da BTL ( è stato appena ruotato qui sopra)
-            nInitialPosition = 1
+            -- si riattiva il MachGroup, i pezzi son rimasti dove erano
+           EgtSetCurrMachGroup( nCurrMachGroup)
          end
 
          -- salvo sul PART la posizione di partenza che è stata scelta
@@ -1895,8 +1893,6 @@ function BeamExec.ProcessMachinings( PARTS, bIsFlipRot)
             if PARTS[nPart].bPartInCombiIsInverted then
                BeamLib.InvertRawPart( PARTS[nPart], -2)
             end
-            -- ripristino anche eventuali pre-rotazioni
-            nInitialPosition = nInitialPosition + ( BEAM.PREROTATE90 or 0)
             -- si ribalta il pezzo in posizione iniziale
             BeamLib.RotateRawPart( PARTS[nPart], 1 - nInitialPosition)
          else

LuaLibs/DiceCut.lua

@@ -453,7 +453,7 @@ function DiceCut.GetDice( Part, Face1, Face2, OptionalParameters)
    -- se piani non ortogonali, diminuisco la distanza di offset opportunamente
    local dOffsetParallelOriginal = dOffsetParallel
    if not bGetOrtoPlanes then
-      local dCoeff = ( vtNMainFace ^ vtNSubordinateFace):len()
+      local dCoeff = max( ( vtNMainFace ^ vtNSubordinateFace):len(), 0.5)
       dOffsetParallel = dOffsetParallel * dCoeff
       dOffsetOrthogonal = dOffsetOrthogonal * dCoeff
    end

LuaLibs/FeatureLib.lua

@@ -337,6 +337,9 @@ function FeatureLib.GetAdditionalInfo( Proc, Part)
       Proc.AdjacencyMatrix = FaceData.GetAdjacencyMatrix( Proc)
       Proc.Faces = FaceData.GetFacesInfo( Proc, Part)
       Proc.FeatureInfo, Proc.MainFaces = FeatureLib.GetRafterNotchData( Proc)
+   elseif ( ID.IsScarfJoint( Proc) or ID.IsScarfSimple( Proc)) then
+      Proc.AdjacencyMatrix = FaceData.GetAdjacencyMatrix( Proc)
+      Proc.Faces = FaceData.GetFacesInfo( Proc, Part)
    end
 
    return Proc

LuaLibs/MachiningLib.lua

@@ -363,16 +363,22 @@ local function TestEngagement( sBladeEngagement, Parameters, OptionalParameters)
    -- attacco perpendicolare
    local PerpendicularLeadInOut = LeadInOutLib.CalculateLeadInOut( 'Perpendicular', Parameters, LeadInOutOptionalParameters)
    -- check extracorsa nei punti di attacco
-
    PointsOnToolTipCenter = {
       PreSimulationLib.GetPointOnToolTipCenter( PerpendicularLeadInOut.LeadIn.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool),
       PreSimulationLib.GetPointOnToolTipCenter( PerpendicularLeadInOut.LeadOut.ptPoint, vtHead, Face.vtN, Edge.vtN, Tool)
    }
    local bOutOfStrokePerpendicular = PreSimulationLib.CheckOutOfStrokeFromPoints( PointsOnToolTipCenter, vtHead, nSCC, Tool)
-   -- se non è in extracorsa si aggiunge come attacco possibile
+   -- attacco perpendicolare non in extracorsa: si verifica se è in collisione
    if not bOutOfStrokePerpendicular then
-      LeadInOut.Perpendicular = PerpendicularLeadInOut
-      LeadInOut.Perpendicular.bMoveAfterSplit = bMoveAfterSplit
+      CheckCollisionOptionalParameters.PointsToCheck = {}
+      table.insert( CheckCollisionOptionalParameters.PointsToCheck, PerpendicularLeadInOut.LeadIn.ptPoint)
+      table.insert( CheckCollisionOptionalParameters.PointsToCheck, PerpendicularLeadInOut.LeadOut.ptPoint)
+      local bCollisionFoundPerpendicular, bMoveAfterSplitPerpendicular = PreSimulationLib.CheckCollision( sBladeEngagement, CheckCollisionParameters, CheckCollisionOptionalParameters)
+      -- attacco perpendicolare possibile
+      if not bCollisionFoundPerpendicular then
+         LeadInOut.Perpendicular = PerpendicularLeadInOut
+         LeadInOut.Perpendicular.bMoveAfterSplit = bMoveAfterSplitPerpendicular
+      end
    end
    -- se c'è almeno un lato chiuso l'unico attacco possibile è il perpendicolare
    if not ( Edge.bIsStartOpen and Edge.bIsEndOpen) then
@@ -468,6 +474,11 @@ end
 function MachiningLib.FindMill( Proc, ToolSearchParameters)
    local ToolInfo = {}
 
+   -- direzione utensile e fipo fresa obbligatori, altrimenti si esce
+   if not ToolSearchParameters.vtToolDirection or not ToolSearchParameters.sMillShape then
+      return ToolInfo
+   end
+
    local nBestToolIndex
    local dBestToolResidualDepth = 0
    for i = 1, #TOOLS do
@@ -511,6 +522,18 @@ function MachiningLib.FindMill( Proc, ToolSearchParameters)
             bIsToolCompatible = false
          end
       end
+      
+      -- TODO da sostituire con test collisione come lama
+      local bIsFromBottom = ToolSearchParameters.vtToolDirection:getZ() < - 10 * GEO.EPS_SMALL
+      local bIsFromTop = ToolSearchParameters.vtToolDirection:getZ() > 10 * GEO.EPS_SMALL
+      local bIsSlanted = abs( ToolSearchParameters.vtToolDirection:getY()) > 0.707
+      local bIsOnHeadOrTail = Proc.AffectedFaces.bLeft or Proc.AffectedFaces.bRight
+      if ( ( bIsFromBottom and TOOLS[i].SetupInfo.HeadType.bTop) or ( bIsFromTop and TOOLS[i].SetupInfo.HeadType.bBottom))
+         and ( not bIsSlanted)
+         and ( not bIsOnHeadOrTail) then
+
+         bIsToolCompatible = false
+      end
 
       -- scelgo il migliore
       if bIsToolCompatible then
@@ -579,6 +602,7 @@ end
 -------------------------------------------------------------------------------------------------------------
 -- funzione per cercare utensile tipo LAMA con certe caratteristiche
 -- TODO da rivedere/completare
+-- TODO per Engagement serviranno (opzionali) sBlockedAxis e vtAux
 function MachiningLib.FindBlade( Proc, ToolSearchParameters)
    local ToolInfo = {}
 
@@ -607,6 +631,7 @@ function MachiningLib.FindBlade( Proc, ToolSearchParameters)
    local bIsDicing = ToolSearchParameters.bIsDicing or false
    local sRestLengthSideForPreSimulation = ToolSearchParameters.sRestLengthSideForPreSimulation or 'Tail'
    local bCannotSplitRestLength = ToolSearchParameters.bCannotSplitRestLength or false
+   local bDisableRealElevationCheck = ToolSearchParameters.bDisableRealElevationCheck or false
 
    local nBestToolIndex
    local dBestToolResidualDepth = 0
@@ -640,7 +665,8 @@ function MachiningLib.FindBlade( Proc, ToolSearchParameters)
             local BladeEngagementOptionalParameters = {
                bIsDicing = bIsDicing,
                sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
-               bCannotSplitRestLength = bCannotSplitRestLength
+               bCannotSplitRestLength = bCannotSplitRestLength,
+               bDisableRealElevationCheck = bDisableRealElevationCheck
             }
             TIMER:startElapsed( 'GetBladeEngagement')
             bIsBladeOk, CurrentEngagement = MachiningLib.GetBladeEngagement( BladeEngagementParameters, BladeEngagementOptionalParameters)
@@ -1443,7 +1469,7 @@ function MachiningLib.AddOperations( MACHININGS, Part, sRotation)
                   local idDisp = EgtGetPhaseDisposition( nPhase)
 
                   -- posizione iniziale considerando eventuiali prerotazioni
-                  local nRealInitialPosition = Part.nInitialPosition - ( BEAM.PREROTATE90 or 0)
+                  local nRealInitialPosition = Part.nInitialPosition
                   if sRotation == 'DOWN' then
                      local nRotation = EgtIf( nRealInitialPosition + 2 > 4, nRealInitialPosition + 2 - 4, nRealInitialPosition + 2) - 1
                      BeamLib.RotateRawPart( Part, nRotation)

LuaLibs/PreSimulationLib.lua

@@ -113,7 +113,7 @@ local function GetToolExitPoint( ptMachining, vtNEdge, vtHead, Tool, bIsDownUp)
 end
 
 -------------------------------------------------------------------------------------------------------------
--- calcolo pivot in riferimento globale, datipunto sull'uscita utensile e direzioni
+-- calcolo pivot in riferimento globale, dati punto sull'uscita utensile e direzioni
 local function GetGlobalPivot( ptToolExit, vtC, vtHead, vtMovePivot)
 
    -- frame solidale all'utensile (lo stesso in cui vtMovePivot è definito)
@@ -269,32 +269,70 @@ function PreSimulationLib.CheckOutOfStrokeFromGeometry( idGeometry, vtHead, nSCC
 end
 
 -------------------------------------------------------------------------------------------------------------
-local function CheckCollisionPoint( ptToolExitToCheck, vtC, vtHead, PreCollisionData, Part, bCannotSplitRestLength, sRestLengthSideForPreSimulation, bCheckOnlyRestlength)
+local function MoveMachineAxesToPosition( ptOnToolTipCenter, vtHead, vtAux)
 
-   local ptPivot = GetGlobalPivot( ptToolExitToCheck, vtC, vtHead, PreCollisionData.vtMovePivot)
+   -- calcolo assi rotativi
+   local bOkAngles, nSolutionsAngles, RotativeAxesValues = EgtGetCalcAnglesEx( vtHead, vtAux)
+   local dRotative1 = RotativeAxesValues[1]
+   local dRotative2 = RotativeAxesValues[2]
+   local dRotative3 = RotativeAxesValues[3]
 
-   -- orientamento del riferimento locale
-   local vtDirectionX = PreCollisionData.Directions.vtDirectionX
-   local vtDirectionY = PreCollisionData.Directions.vtDirectionY
-   local vtDirectionZ = PreCollisionData.Directions.vtDirectionZ
+   if not bOkAngles then
+      error( ' MoveMachineAxesToPosition : error')
+   end
 
-   -- costruzione trimesh a partire dalla curva di collisione
-   -- recupero punti da macchina per costruire trimesh
-   local CollisionCurvePoints = PreCollisionData.Points
-   -- curva di collisione in riferimento locale
-   local idCollisionCurve = EgtCurveCompoFromPoints( Part.idTempGroup, CollisionCurvePoints)
-   -- curva in riferimento globale
-   local frReference = Frame3d( ptPivot, vtDirectionZ, vtDirectionX)
-   EgtTransform( idCollisionCurve, frReference, GDB_RT.GLOB)
-   -- trimesh di collisione
-   local idCollisionSurfTm
-   if PreCollisionData.bSurfTmByRevolve then
-      idCollisionSurfTm = EgtSurfTmByRevolve( Part.idTempGroup, idCollisionCurve, ptPivot, vtDirectionY, true, 0.05, GDB_RT.GLOB)
-   else
-      local vtPreMove = -vtDirectionZ * ( PreCollisionData.dExtrusionDepth / 2)
-      EgtMove( idCollisionCurve, vtPreMove, GDB_RT.GLOB)
-      local vtExtrusion = vtDirectionZ * PreCollisionData.dExtrusionDepth
-      idCollisionSurfTm = EgtSurfTmByRegionExtrusion( Part.idTempGroup, idCollisionCurve, vtExtrusion, 0.05, GDB_RT.GLOB)
+   -- calcolo assi lineari
+   local bOkPositions, _, dLinear1, dLinear2, dLinear3 = EgtGetCalcPositions( ptOnToolTipCenter, dRotative1, dRotative2, dRotative3)
+
+   if not bOkPositions then
+
+      error( ' MoveMachineAxesToPosition : error')
+   end
+
+   local AxesNames = EgtGetAllCurrAxesNames()
+   local dTHome = EgtGetAxisHomePos( AxesNames[1])
+
+   -- spostamento assi in posizione (la T non si sposta perchè si sposta il pezzo)
+   EgtSetAxisPos( AxesNames[2], dLinear2)
+   EgtSetAxisPos( AxesNames[3], dLinear3)
+   EgtSetAxisPos( AxesNames[4], dRotative1)
+   EgtSetAxisPos( AxesNames[5], dRotative2)
+   if dRotative3 then
+      EgtSetAxisPos( AxesNames[6], dRotative3)
+   end
+
+   return dLinear1 - dTHome
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function CheckCollisionPoint( sAxis, ptOnToolTipCenter, vtHead, vtAux, Part, bCannotSplitRestLength, sRestLengthSideForPreSimulation, bCheckOnlyRestlength)
+
+   -- spostamento assi macchina in posizione
+   local dDeltaXHeadOffset = MoveMachineAxesToPosition( ptOnToolTipCenter, vtHead, vtAux)
+
+   -- si recuperano gli id delle geometrie dell'asse con cui controllare la collisione
+   local idCollisionGroup = EgtGetFirstNameInGroup( EgtGetAxisId( sAxis), 'COLLISION')
+   local idCollisionGroupOther = EgtGetFirstNameInGroup( EgtGetAxisId( sAxis), 'OTHER_COLLISION') or GDB_ID.NULL
+   local CollisionGroupEntitiesId = EgtGetAllInGroup( idCollisionGroup)
+   local CollisionGroupOtherEntitiesId = EgtGetAllInGroup( idCollisionGroupOther)
+   -- si tengono solo gli elementi trimesh
+   local CollisionSurfTmId = {}
+   for i = 1, #CollisionGroupEntitiesId do
+      if EgtGetType( CollisionGroupEntitiesId[i]) == GDB_TY.SRF_MESH then
+         local idCollisionSurfTmCopy = EgtCopyGlob( CollisionGroupEntitiesId[i], Part.idTempGroup)
+         EgtMove( idCollisionSurfTmCopy, Vector3d( dDeltaXHeadOffset, 0, 0), GDB_RT.GLOB)
+         table.insert( CollisionSurfTmId, idCollisionSurfTmCopy)
+      end
+   end
+   -- se presenti geometrie nel gruppo other si aggiungono anche quelle
+   if CollisionGroupOtherEntitiesId and #CollisionGroupOtherEntitiesId > 0 then
+      for i = 1, #CollisionGroupOtherEntitiesId do
+         if EgtGetType( CollisionGroupOtherEntitiesId[i]) == GDB_TY.SRF_MESH then
+            local idCollisionOtherSurfTmCopy = EgtCopyGlob( CollisionGroupOtherEntitiesId[i], Part.idTempGroup)
+            EgtMove( idCollisionOtherSurfTmCopy, Vector3d( dDeltaXHeadOffset, 0, 0), GDB_RT.GLOB)
+            table.insert( CollisionSurfTmId, idCollisionOtherSurfTmCopy)
+         end
+      end
    end
 
    -- check collisione con pezzo
@@ -306,16 +344,22 @@ local function CheckCollisionPoint( ptToolExitToCheck, vtC, vtHead, PreCollision
          local b3CheckCollision = BeamLib.GetPartBoxWithHeadTail( Part, sRestLengthSideForPreSimulation)
          idCheckCollisionTm = EgtSurfTmBBox( Part.idTempGroup, b3CheckCollision, false, GDB_RT.GLOB)
       end
-      bCollisionFoundPiece = EgtCDeSolidSolid( idCheckCollisionTm, idCollisionSurfTm, BeamData.COLL_SIC)
-      if not type( bCollisionFoundPiece) == "boolean" then
-         error( 'Presimulation fail')
-      end
-      if EgtGetDebugLevel() >= 3 and bCollisionFoundPiece then
-         EgtSetColor( idCollisionSurfTm, RED())
+      for i = 1, #CollisionSurfTmId do
+         bCollisionFoundPiece = EgtCDeSolidSolid( idCheckCollisionTm, CollisionSurfTmId[i], BeamData.COLL_SIC)
+         if not type( bCollisionFoundPiece) == "boolean" then
+            error( 'Presimulation fail')
+         end
+         if EgtGetDebugLevel() >= 3 and bCollisionFoundPiece then
+            EgtSetColor( CollisionSurfTmId[i], RED())
+         end
+         if bCollisionFoundPiece then
+            break
+         end
       end
 
       -- se trovata collisione con pezzo è inutile procedere con il grezzo
       if bCollisionFoundPiece then
+
          return true
       end
    end
@@ -325,12 +369,17 @@ local function CheckCollisionPoint( ptToolExitToCheck, vtC, vtHead, PreCollision
    if not ( bCollisionFoundPiece or bCannotSplitRestLength) then
       local idRestLengthSurfFr = GetRestlengthSurfTm( Part, sRestLengthSideForPreSimulation)
       if idRestLengthSurfFr then
-         bCollisionFoundRestLength = EgtCDeSolidSolid( idRestLengthSurfFr, idCollisionSurfTm, BeamData.COLL_SIC)
-         if not type( bCollisionFoundRestLength) == "boolean" then
-            error( 'Presimulation fail')
-         end
-         if EgtGetDebugLevel() >= 3 and bCollisionFoundRestLength then
-            EgtSetColor( idCollisionSurfTm, ORANGE())
+         for i = 1, #CollisionSurfTmId do
+            bCollisionFoundRestLength = EgtCDeSolidSolid( idRestLengthSurfFr, CollisionSurfTmId[i], BeamData.COLL_SIC)
+            if not type( bCollisionFoundRestLength) == "boolean" then
+               error( 'Presimulation fail')
+            end
+            if EgtGetDebugLevel() >= 3 and bCollisionFoundRestLength then
+               EgtSetColor( CollisionSurfTmId[i], ORANGE())
+            end
+            if bCollisionFoundRestLength then
+               break
+            end
          end
       end
    end
@@ -355,43 +404,29 @@ local function CheckCollisionWithAxis( sAxis, MachiningParameters, OptionalParam
    local bCheckOnlyRestlength = OptionalParameters.bCheckOnlyRestlength or false
    local sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation or 'Tail'
    local bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength or false
+   local vtAux = OptionalParameters.vtAux
 
    -- se normale faccia non parallela a direzione testa c'è qualcosa che non va
    if not AreSameOrOppositeVectorApprox( vtNFace, vtHead) then
       error( 'CheckCollisionWithAxis : invalid directions')
    end
-   
+
    -- punti notevoli della lavorazione in cui fare il check
    local PointsToCheck = OptionalParameters.PointsToCheck or GetCollisionPointsToCheck( Edge, dDepthToMachine)
 
-   -- punti in centro lama su naso mandrino o aggregato. In base a direzione e punto
-   local bIsDownUp = AreOppositeVectorApprox( vtNFace, vtHead)
-   local ToolExitPoints = {}
+   -- punti sul tip dell'utensile, in centro
+   local PointsOnToolTipCenter = {}
    for i = 1, #PointsToCheck do
-      ToolExitPoints[i] = GetToolExitPoint( PointsToCheck[i], Edge.vtN, vtHead, Tool, bIsDownUp)
+      PointsOnToolTipCenter[i] = PreSimulationLib.GetPointOnToolTipCenter( PointsToCheck[i], vtHead, vtNFace, Edge.vtN, Tool)
    end
 
-   -- vtC punta sempre verso il corpo dell'asse C o verso l'aggregato
-   local nSCC = Tool.SetupInfo.GetSCC( Edge.vtN, Edge.vtEdge, vtNFace)
-   local vtSCC = BeamLib.GetDirectionFromSCC( nSCC)
-   local vtC = vtHead ^ Tool.SetupInfo.vtRotationAxisC
-   vtC:normalize()
-   if vtC:isSmall() then
-      vtC = vtSCC
-   elseif vtC * vtSCC < GEO.EPS_SMALL then
-      vtC = -vtC
-   end
-
-   -- punti curva collisione e direzioni check da macchina
-   local PreCollisionData = Tool.SetupInfo.GetPreCollisionData( sAxis, vtC, vtHead)
-
    local bMoveAfterSplit = false
 
    -- se almeno in un punto c'è collisione con il pezzo si ritorna collisione
    -- se non si trova collisione si ritorna se è necessario separare prima di effettuare la lavorazione (ossia non c'è collisione con il pezzo ma c'è con il grezzo restante)
-   for i = 1, #ToolExitPoints do
+   for i = 1, #PointsOnToolTipCenter do
 
-      local bCollisionFoundPiece, bCollisionFoundRestLength = CheckCollisionPoint( ToolExitPoints[i], vtC, vtHead, PreCollisionData, Part, bCannotSplitRestLength, sRestLengthSideForPreSimulation, bCheckOnlyRestlength)
+      local bCollisionFoundPiece, bCollisionFoundRestLength = CheckCollisionPoint( sAxis, PointsOnToolTipCenter[i], vtHead, vtAux, Part, bCannotSplitRestLength, sRestLengthSideForPreSimulation, bCheckOnlyRestlength)
 
       -- se trovata collisione con pezzo è inutile controllare gli altri punti
       if bCollisionFoundPiece then
@@ -413,7 +448,12 @@ end
 function PreSimulationLib.CheckCollision( sBladeEngagement, Parameters, OptionalParameters)
 
    local bCollisionFound
-   local bMoveAfterSplitZ, bMoveAfterSplitC, bMoveAfterSplitAB
+   local bMoveAfterSplitL3, bMoveAfterSplitR3, bMoveAfterSplitR2, bMoveAfterSplitR1
+
+   -- parametri obbligatori
+   local Edge = Parameters.Edge
+   local vtNFace = Parameters.vtNFace
+   local Tool = Parameters.Tool
 
    -- parametri opzionali, in parte da far transitare
    OptionalParameters = OptionalParameters or {}
@@ -423,8 +463,12 @@ function PreSimulationLib.CheckCollision( sBladeEngagement, Parameters, Optional
    OptionalParametersCheckCollisionWithAxis.PointsToCheck = OptionalParameters.PointsToCheck or nil
    OptionalParametersCheckCollisionWithAxis.sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation or 'Tail'
    OptionalParametersCheckCollisionWithAxis.bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength or false
+   OptionalParametersCheckCollisionWithAxis.sBlockedAxis = OptionalParameters.sBlockedAxis
+   OptionalParametersCheckCollisionWithAxis.vtAux = OptionalParameters.vtAux
 
+   local sBlockedAxis = OptionalParameters.sBlockedAxis
    local bIsDicing = OptionalParameters.bIsDicing or false
+   local bDisableRealElevationCheck = OptionalParameters.bDisableRealElevationCheck or false
    local bCheckOnlyRestlengthForAxisABC = false
 
    -- se cubetti in modalità standard (no DownUp) gli assi AB e C si controllano solo con grezzo (ci sarebbe collisione con il materiale già rimosso controllando AB e C con pezzo)
@@ -432,7 +476,7 @@ function PreSimulationLib.CheckCollision( sBladeEngagement, Parameters, Optional
       bCheckOnlyRestlengthForAxisABC = true
    -- se l'elevazione reale (rispetto al pezzo + eventuale materiale in testa/coda) è maggiore del massimo materiale è sempre collisione
    -- TODO rifare con funzione
-   else
+   elseif not bDisableRealElevationCheck then
       local Edge = Parameters.Edge
       local vtNFace = Parameters.vtNFace
       local dDepthToMachine = Parameters.dDepthToMachine
@@ -455,21 +499,46 @@ function PreSimulationLib.CheckCollision( sBladeEngagement, Parameters, Optional
       end
    end
 
-   -- asse Z si controlla sempre
-   bCollisionFound, bMoveAfterSplitZ = CheckCollisionWithAxis( 'Z', Parameters, OptionalParametersCheckCollisionWithAxis)
+   -- SCC
+   local nSCC = Tool.SetupInfo.GetSCC( Edge.vtN, Edge.vtEdge, vtNFace)
 
-   -- assi AB e C: se richiesto si controlla la collisione solo col grezzo
+   -- si settano utensile, SCC e asse bloccato per il controllo collisione
+   local bOkTool = EgtSetCalcTool( Tool.sName, Tool.sHead, Tool.nExit)
+   if not bOkTool then
+      error( 'CheckCollisionWithAxis : cannot set calc tool')
+   end
+   EgtSetCalcSolCh( nSCC)
+   if sBlockedAxis and type( sBlockedAxis) == "string" then
+      local BlockedAxis = EgtSplitString( sBlockedAxis, '=')
+      EgtSetRotAxisBlock( BlockedAxis[1], tonumber( BlockedAxis[2]))
+   end
+
+   -- nomi degli assi con cui controllare la collisione
+   local AxesNames = EgtGetAllCurrAxesNames()
+   local sL3 = AxesNames[3]
+   local sR3 = AxesNames[6]
+   local sR2 = AxesNames[5]
+   local sR1 = AxesNames[4]
+
+   -- ultimo asse lineare prima dei rotativi (solitamente Z) si controlla sempre
+   bCollisionFound, bMoveAfterSplitL3 = CheckCollisionWithAxis( sL3, Parameters, OptionalParametersCheckCollisionWithAxis)
+
+   -- assi rotativi: se richiesto si controlla la collisione solo col grezzo
    OptionalParametersCheckCollisionWithAxis.bCheckOnlyRestlength = bCheckOnlyRestlengthForAxisABC
 
-   if not bCollisionFound then
-      bCollisionFound, bMoveAfterSplitAB = CheckCollisionWithAxis( 'AB', Parameters, OptionalParametersCheckCollisionWithAxis)
+   if sR3 and not bCollisionFound then
+      bCollisionFound, bMoveAfterSplitR3 = CheckCollisionWithAxis( sR3, Parameters, OptionalParametersCheckCollisionWithAxis)
    end
 
    if not bCollisionFound then
-      bCollisionFound, bMoveAfterSplitC = CheckCollisionWithAxis( 'C', Parameters, OptionalParametersCheckCollisionWithAxis)
+      bCollisionFound, bMoveAfterSplitR2 = CheckCollisionWithAxis( sR2, Parameters, OptionalParametersCheckCollisionWithAxis)
    end
 
-   local bMoveAfterSplit = bMoveAfterSplitZ or bMoveAfterSplitC or bMoveAfterSplitAB
+   if not bCollisionFound then
+      bCollisionFound, bMoveAfterSplitR1 = CheckCollisionWithAxis( sR1, Parameters, OptionalParametersCheckCollisionWithAxis)
+   end
+
+   local bMoveAfterSplit = bMoveAfterSplitL3 or bMoveAfterSplitR3 or bMoveAfterSplitR2 or bMoveAfterSplitR1
 
    return bCollisionFound, bMoveAfterSplit
 end

Strategies/AvailableStrategyList.json

@@ -688,7 +688,7 @@
       "TopologyList" : [
          {  "sName": "Feature",
             "sImage": "ConfigStrategy\\ScarfJoint.png",
-            "StrategyList" : [ ]
+            "StrategyList" : [ { "sStrategyId": "STR0009" }]
          }
       ]
    },

Strategies/Standard/STR0002/STR0002.lua

@@ -269,6 +269,8 @@ local function GetBestPocketingStrategy( Proc, Part)
          Milling.idProc = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.id
          Milling.dElevation = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP
          Milling.bMachAppliedToTunnelFace = true
+      else
+         ToolSearchParameters.vtToolDirection = nil
       end
       ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sPocketingList, 'Pocketing')
       Milling.ToolInfo = {}
@@ -278,6 +280,19 @@ local function GetBestPocketingStrategy( Proc, Part)
          local ParametersMRR = {}
          ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
          Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+         -- se la faccia tunnel è troppo piccola non si lavora
+         if Milling.bMachAppliedToTunnelFace then
+            local dLongestEdgeLength = 0
+            for i = 1, #Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].Edges do
+               if Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].Edges[i].dLength > dLongestEdgeLength + 10 * GEO.EPS_SMALL then
+                  dLongestEdgeLength = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].Edges[i].dLength
+               end
+            end
+            if dLongestEdgeLength < TOOLS[Milling.ToolInfo.nToolIndex].dDiameter then
+               Milling.bIsApplicable = false
+               ParametersMRR = {}
+            end
+         end
       end
    end
    table.insert( Machining, Milling)
@@ -309,6 +324,8 @@ local function GetBestPocketingStrategy( Proc, Part)
          Milling.idFaceToMachine = Proc.MainFaces.SideFaces[1].id
          Milling.idProc = Proc.id
          Milling.dElevation = Proc.MainFaces.SideFaces[1].dElevation
+      else
+         ToolSearchParameters.vtToolDirection = nil
       end
       ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sPocketingList, 'Pocketing')
       Milling.ToolInfo = {}
@@ -318,6 +335,19 @@ local function GetBestPocketingStrategy( Proc, Part)
          local ParametersMRR = {}
          ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
          Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
+         -- se la faccia tunnel è troppo piccola non si lavora
+         if Milling.bMachAppliedToTunnelFace then
+            local dLongestEdgeLength = 0
+            for i = 1, #Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].Edges do
+               if Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].Edges[i].dLength > dLongestEdgeLength + 10 * GEO.EPS_SMALL then
+                  dLongestEdgeLength = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].Edges[i].dLength
+               end
+            end
+            if dLongestEdgeLength < TOOLS[Milling.ToolInfo.nToolIndex].dDiameter then
+               Milling.bIsApplicable = false
+               ParametersMRR = {}
+            end
+         end
       end
    end
    table.insert( Machining, Milling)

Strategies/Standard/STR0003/STR0003.lua

@@ -195,6 +195,17 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
    Blade.Result = {}
    Chainsaw.Result = {}
 
+
+   -- se arriva una feature senza MainFaces o MainEdges necessari la strategia non è applicabile
+   -- TODO riuniure a IsTopologyOk?
+   if not Proc.MainFaces
+      or not Proc.MainFaces.LongFaces[1]
+      or not Proc.MainFaces.LongFaces[1].MainEdges then
+
+      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Topology')
+      return false, Strategy.Result
+   end
+
    if not IsTopologyOk( Proc) then
       local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not implemented'
       EgtOutLog( sErr)
@@ -241,16 +252,6 @@ function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
       dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
    end
 
-   -- se arriva una feature senza MainFaces o MainEdges necessari la strategia non è applicabile
-   -- TODO riuniure a IsTopologyOk?
-   if not Proc.MainFaces
-      or not Proc.MainFaces.LongFaces[1]
-      or not Proc.MainFaces.LongFaces[1].MainEdges then
-
-      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Topology')
-      return false, Strategy.Result
-   end
-
    -- riferimenti locali per leggibilità e performance
    local LongFace = Proc.MainFaces.LongFaces[1]
    local OppositeEdge1 = LongFace.MainEdges.OppositeEdges[1]

Strategies/Standard/STR0004/STR0004.lua

@@ -132,6 +132,16 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
       bIsSplitFeature = true
    end
 
+   -- se arriva una feature senza MainFaces o MainEdges necessari la strategia non è applicabile
+   -- TODO riuniure a IsTopologyOk?
+   if not Proc.MainFaces
+      or not Proc.MainFaces.LongFaces[1]
+      or not Proc.MainFaces.LongFaces[1].MainEdges then
+
+      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Topology')
+      return false, Strategy.Result
+   end
+
    -- altezza tasca
    local dPocketHeight = 0
    if Proc.Topology.sFamily == 'Tunnel' then
@@ -145,16 +155,6 @@ function STR0004.Make( bAddMachining, Proc, Part, CustomParameters)
       dPocketHeight = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
    end
 
-   -- se arriva una feature senza MainFaces o MainEdges necessari la strategia non è applicabile
-   -- TODO riuniure a IsTopologyOk?
-   if not Proc.MainFaces
-      or not Proc.MainFaces.LongFaces[1]
-      or not Proc.MainFaces.LongFaces[1].MainEdges then
-
-      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( 'Topology')
-      return false, Strategy.Result
-   end
-
    -- riferimenti locali per leggibilità e performance
    local LongFace = Proc.MainFaces.LongFaces[1]
    local OppositeEdge1 = LongFace.MainEdges.OppositeEdges[1]

Strategies/Standard/STR0007/STR0007.lua

@@ -441,7 +441,7 @@ function STR0007.Make( bAddMachining, Proc, Part, CustomParameters)
       local ptCutC, vtCutN = EgtSurfTmFacetCenter( Proc.id, 1, GDB_ID.ROOT)
       if ptCutC and vtCutN and AreSameVectorApprox( Proc.FeatureInfo.vtMortiseN, vtCutN) then
          -- recupero gruppo per geometria addizionale
-         local nAddGrpId = Part.idTempGroup
+         local nAddGrpId = BeamLib.GetAddGroup( Part.id)
          Strategy.idMortiseCutPlane = EgtSurfTmPlaneInBBox( nAddGrpId, ptCutC, vtCutN, Part.b3Part, GDB_RT.GLOB)
       end
    end

Strategies/Standard/STR0008/STR0008.lua

@@ -311,10 +311,7 @@ function STR0008.Make( bAddMachining, Proc, Part, CustomParameters)
       -- si applicano le lavorazioni di svuotatura
       for i = 1, #Strategy.Machining.Pocketing do
          if Strategy.Machining.Pocketing[i].bIsApplicable then
-            Pocketing = {}
-            Pocketing.Steps = {}
-            Pocketing.LeadIn = {}
-            Pocketing.nType = MCH_MY.POCKETING
+            Pocketing = MachiningLib.InitMachiningParameters( MCH_MY.POCKETING)
             Pocketing.nSubType = MCH_POCK_SUB.SPIRALOUT
             Pocketing.LeadIn.nType = MCH_POCK_LI.ZIGZAG
             Pocketing.Steps.dStep = TOOLS[Strategy.Machining.Pocketing[i].ToolInfo.nToolIndex].dStep

Strategies/Standard/STR0009/STR0009.json

@@ -1,6 +1,6 @@
 {
    "sStrategyId": "STR0009",
-   "sStrategyName": "Mill Heading",
+   "sStrategyName": "ScarfJoint",
    "ParameterList" : [
       {
          "sName": "dDepthChamfer",
@@ -13,35 +13,15 @@
          "sMinUserLevel": "1"
       },
       {
-         "sName": "dOverMaterial",
-         "sNameNge": "OVERMAT",
-         "sValue": "0",
-         "sDescriptionShort": "Overmaterial",
-         "sDescriptionLong": "",
-         "sType": "d",
-         "sMessageId": " ",
-         "sMinUserLevel": "1"
-      },
-      {
-         "sName": "bForceStrip",
-         "sNameNge": "FORCE_STRIP",
+         "sName": "bAntiSplint",
+         "sNameNge": "ANTISPLINT",
          "sValue": "false",
-         "sDescriptionShort": "Force strip",
-         "sDescriptionLong": "Enable the parameter to force the software to leave a strip to sustain the piece",
+         "sDescriptionShort": "Use Anti-Splint strategy",
+         "sDescriptionLong": "The strategy will apply blade cuts on corner to avoid wood splint",
          "sType": "b",
          "sMessageId": " ",
          "sMinUserLevel": "1"
       },
-      {
-         "sName": "dStripWidth",
-         "sNameNge": "STRIP_WIDTH",
-         "sValue": "0",
-         "sDescriptionShort": "Strip width",
-         "sDescriptionLong": "Width of the strip in case if foreseen from the machining",
-         "sType": "d",
-         "sMessageId": " ",
-         "sMinUserLevel": "1"
-      },
       {
          "sName": "sMillingList",
          "sNameNge": "PROFILE_TOOL_LIST",

Strategies/Standard/STR0009/STR0009.lua

@@ -1,7 +1,6 @@
 -- Strategia: STR0009
 -- Descrizione 
--- Fresatura di contorno
--- Feature tipo Arco
+-- Feature tipo ScarfJoint
 
 
 -- carico librerie
@@ -10,156 +9,182 @@ local BeamData = require( 'BeamDataNew')
 local MachiningLib = require( 'MachiningLib')
 local FeatureLib = require( 'FeatureLib')
 -- strategie di base
-local BladeToWaste = require('BLADETOWASTE')
+local BladeToWaste = require( 'BLADETOWASTE')
+local FaceByMill = require( 'FACEBYMILL')
+local FaceByBlade = require( 'FACEBYBLADE')
+local AntiSplintOnFace = require( 'ANTISPLINTONFACE')
 
 -- Tabella per definizione modulo
 local STR0009 = {}
 local Strategy = {}
 
 -------------------------------------------------------------------------------------------------------------
--- TODO gestire il caso in cui non si trova l'utensile
-local function GetArcStrategy( Proc, Part)
-   local Machining = {}
-   local ToolSearchParameters = {}
+local function GetFacesIdOrder( Proc, Part)
+   local Faces = {}
+   if Proc.nFct == 5 then
+      -- carico gli id delle facce
+      for i = 1, Proc.nFct do
+         Faces[#Faces + 1] = BeamLib.TableCopyDeep( Proc.Faces[i])
+      end
+   elseif Proc.nFct == 4 then
+      local vtN1 = Proc.Faces[1].vtN
+      local vtN2 = Proc.Faces[2].vtN
+      local nIndex = EgtIf( abs( vtN1:getX()) > abs( vtN2:getX()), 1, 2)
+      for i = nIndex, Proc.nFct do
+         Faces[#Faces + 1] = BeamLib.TableCopyDeep( Proc.Faces[i])
+      end
+   -- TODO manca il caso in cui mancano facce 4 e 5
+   else -- Proc.nFct == 3
+      for i = 2, Proc.nFct do
+         Faces[#Faces + 1] = BeamLib.TableCopyDeep( Proc.Faces[i])
+      end
+   end
 
-   -- recupero e verifico l'entità curva
-   local idAux = EgtGetInfo( Proc.id, 'AUXID', 'i')
-   if idAux then idAux = idAux + Proc.id end
-   if not idAux  or  ( EgtGetType( idAux) & GDB_FY.GEO_CURVE) == 0 then
-      local sErr = 'Error on process ' .. tostring( Proc.id) .. ' missing profile geometry'
+   return Faces
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetEdgeToMachine( ClosingFace, idBottomFace)
+   local EdgeToMachine
+
+   for i = 1, #ClosingFace.Edges do
+      if ClosingFace.Edges[i].idAdjacentFace == idBottomFace then
+         EdgeToMachine = ClosingFace.Edges[i]
+         break
+      end
+   end
+
+   return EdgeToMachine
+end
+
+-------------------------------------------------------------------------------------------------------------
+local function GetScarfJointStrategy( Proc, Part)
+   -- ordino le facce in base al loro numero e al parallelismo delle due facce principali
+   -- faccia 0: superficie tappo (*potrebbe non esserci)
+   -- faccia 1: superficie principale di fondo
+   -- faccia 2: superficie opposta alla faccia 1
+   -- faccia 3: superficie principale superiore
+   -- faccia 4: superficie di testa (*potrebbe non esserci)
+   -- creo una tabella unica contenente tutte le lavorazioni
+   local Result = {}
+   local Cutting = { Machinings = {}, Result = {}}
+   local AntiSplints = {}
+   local Pocketing = {}
+
+   Result.dTimeToMachine = 0
+   local Faces = GetFacesIdOrder( Proc)
+   -- taglio su faccia 4
+   if Faces[4] and Faces[4].vtN then
+      -- recupero gruppo per geometria addizionale
+      local nAddGrpId = BeamLib.GetAddGroup( Part.id)
+      -- TODO la nuova faccia creata sulla 4 può tagliare faccia 1. In caso tagliasse faccia 1, bisogna calcolare i cubetti con 2 facce 
+      Strategy.idFeatureCutPlane = EgtSurfTmPlaneInBBox( nAddGrpId, Faces[4].ptCenter, Faces[4].vtN, Part.b3Part, GDB_RT.GLOB)
+      Cutting.Machinings, Cutting.Result = BladeToWaste.Make( Strategy.idFeatureCutPlane, Part)
+      if Cutting.Result.sStatus == 'Completed' then
+         Cutting.Machinings.bIsApplicable = true
+      end
+   end
+
+   -- antischeggia facce 1 e 3
+   local bAreAllAntisplintsApplicable = true
+   if Strategy.Parameters.bAntiSplint then
+      AntiSplints = AntiSplintOnFace.Make( Proc, Part, Faces[2])
+      for k = 1, #AntiSplints do
+         if not AntiSplints[k].bIsApplicable then
+            bAreAllAntisplintsApplicable = false
+            break
+         end
+      end
+   end
+
+   -- svuotatura faccia 2
+   if Faces[2] then
+      local frPock, dL, dW = EgtSurfTmFacetMinAreaRectangle( Proc.id, Faces[2].id, GDB_ID.ROOT)
+      local ToolSearchParameters = {}
+      ToolSearchParameters.sMillShape = 'STANDARD'
+      ToolSearchParameters.vtToolDirection = Faces[2].vtN
+      ToolSearchParameters.dElevation = abs( ( Faces[2].ptCenter - Faces[4].ptCenter) * Faces[2].vtN)
+      ToolSearchParameters.dMaxToolDiameter = min( dL, dW)
+      ToolSearchParameters.ToolInfo = {}
+      ToolSearchParameters.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
+      if ToolSearchParameters.ToolInfo.nToolIndex then
+         local Machining = MachiningLib.InitMachiningParameters( MCH_MY.POCKETING)
+         Machining.Geometry = {{ Proc.id, Faces[2].id}}
+         Machining.dElevation = ToolSearchParameters.dElevation
+         Machining.dMaxElev = Machining.dElevation
+         Machining.vtToolDirection = ToolSearchParameters.vtToolDirection
+         Machining.nSubType = MCH_POCK_SUB.SPIRALIN
+         Machining.LeadIn.nType = MCH_POCK_LI.ZIGZAG
+         Machining.Steps.dStep = TOOLS[ToolSearchParameters.ToolInfo.nToolIndex].dStep
+         Machining.Steps.dSideStep = TOOLS[ToolSearchParameters.ToolInfo.nToolIndex].dSideStep
+         Machining.nToolIndex = ToolSearchParameters.ToolInfo.nToolIndex
+         Machining.LeadIn.dTangentDistance = TOOLS[ToolSearchParameters.ToolInfo.nToolIndex].dDiameter / 2
+         Machining.LeadIn.dElevation = TOOLS[ToolSearchParameters.ToolInfo.nToolIndex].dDiameter / 2
+         Machining.sDepth = 0
+         Machining.dResidualDepth = ToolSearchParameters.ToolInfo.dResidualDepth
+         -- TODO vedere se questo parametro con svuotature nuove si può rimuovere
+         Machining.dOpenMinSafe = Strategy.Parameters.dOpenMinSafe
+         Machining.dTimeToMachine = MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machining, Part)
+         Result.dTimeToMachine = Result.dTimeToMachine + Machining.dTimeToMachine
+         table.insert( Pocketing, Machining)
+         Pocketing.bIsApplicable = true
+         -- se non sono stati fatti i passaggi antischeggia si verifica che le facce siano a 90°, altrimenti serve passaggio con fresa
+         if not Strategy.Parameters.bAntiSplint or not bAreAllAntisplintsApplicable then
+            local dAngleBetweenFaces = Proc.AdjacencyMatrix[1][2] or 0
+            -- si fa passaggio con fresa
+            if dAngleBetweenFaces > -90 then
+               local EdgeToMachine = GetEdgeToMachine( Faces[1], Faces[2].id)
+               local CuttingClosingFace = FaceByBlade.Make( Proc, Part, Faces[1], EdgeToMachine)
+               if CuttingClosingFace.bIsApplicable then
+                  table.insert( AntiSplints, CuttingClosingFace)
+               end
+            end
+         end
+      end
+   end
+
+   -- se manca taglio principale, feature non eseguibile
+   if not Cutting.Machinings.bIsApplicable then
+      local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable'
       EgtOutLog( sErr)
-      return false, sErr
-   end
-   Proc.idAddAuxGeom = idAux
-
-   -- recupero i dati della curva e del profilo
-   local dDepth = abs( EgtCurveThickness( idAux))
-   local vtExtr = EgtCurveExtrusion( idAux, GDB_RT.GLOB)
-   local bToolInvert = ( vtExtr:getZ() < -0.1)
-   local bIsHorizontal = abs( vtExtr:getZ()) < 10 * GEO.EPS_SMALL
-   local bIsFeatureDown = Proc.AffectedFaces.bBottom and not Proc.AffectedFaces.bTop
-   local bIsFeatureBack = Proc.AffectedFaces.bBack and not Proc.AffectedFaces.bFront
-   local bForceStrip = Strategy.Parameters.bForceStrip
-   local dDimStrip = EgtIf( Strategy.Parameters.dStripWidth < 100 * GEO.EPS_SMALL, nil, Strategy.Parameters.dStripWidth)
-
-   local bExecStrip = false
-   -- se la lavorazione si trova nella parte inferiore o in battuta dietro, il codolo va sempre lasciato
-   if bIsFeatureDown or bIsFeatureBack or bForceStrip then
-      if bIsFeatureDown or bIsFeatureBack then
-         dDimStrip = dDimStrip or max( BeamData.DIM_STRIP or 5, 5)
-      else
-         dDimStrip = dDimStrip or max( BeamData.DIM_STRIP_SMALL or 5, 1)
-      end
-      bExecStrip = true
-   end
-   if not bExecStrip then
-      dDimStrip = 0
-   end
-
-   -- se lavorazione orizzontale
-   if bIsHorizontal then
-      local bDouble
-      local Milling = MachiningLib.InitMachiningParameters( MCH_MY.MILLING)
-      Milling.bIsApplicable = false
-      ToolSearchParameters = {}
-      ToolSearchParameters.sMillShape = 'STANDARD'
-      ToolSearchParameters.dElevation = EgtIf( bExecStrip, ( dDepth - dDimStrip) / 2, dDepth + BeamData.MILL_OVERLAP)
-      ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, -vtExtr, vtExtr)
-      ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sMillingList, 'Milling')
-      Milling.ToolInfo = {}
-      Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
-      -- se posso lavorare in una passata, ma utensile trovato non completa la lavorazione,
-      -- allora provo a cercare utensile con massimo materiale sufficiente per fare le due passate, magari trova un utensile più prestante
-      if Milling.ToolInfo.dResidualDepth > 10 * GEO.EPS_SMALL and not bExecStrip then
-         bDouble = true
-         ToolSearchParameters.dElevation = ( dDepth + BeamData.MILL_OVERLAP) / 2
-         ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, -vtExtr, vtExtr)
-      end
-      Milling.bToolInvert = bToolInvert
-      Milling.vtToolDirection = vtExtr
-
-      if bDouble or bExecStrip then
-         if bDouble then
-            Milling.sDepth = ( dDepth + BeamData.MILL_OVERLAP) / 2
-         else
-            Milling.sDepth = ( dDepth - dDimStrip) / 2
-         end
-         table.insert( Machining, Milling)
-         local Milling2 = BeamLib.TableCopyDeep( Milling)
-         table.insert( Machining, Milling2)
-      else
-         Milling.sDepth = dDepth + BeamData.MILL_OVERLAP
-         table.insert( Machining, Milling)
-      end
-   -- se lavorazione verticale
+      Result = FeatureLib.GetStrategyResultNotApplicable( sErr)
    else
-      -- si cerca utensile 1
-      local Milling = {}
-      Milling.bIsApplicable = false
-      ToolSearchParameters = {}
-      ToolSearchParameters.sMillShape = 'STANDARD'
-      ToolSearchParameters.dElevation = dDepth + BeamData.MILL_OVERLAP
-      ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, -vtExtr, vtExtr)
-      ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sMillingList, 'Milling')
-      Milling.ToolInfo = {}
-      Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
-      -- si cerca utensile 2
-      local Milling2 = {}
-      Milling2.bIsApplicable = false
-      ToolSearchParameters = {}
-      ToolSearchParameters.sMillShape = 'STANDARD'
-      ToolSearchParameters.dElevation = dDepth + BeamData.MILL_OVERLAP
-      ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, vtExtr, -vtExtr)
-      ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sMillingList, 'Milling')
-      Milling2.ToolInfo = {}
-      Milling2.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
-
-      -- se serve codolo
-      if bExecStrip then
-         -- se a disposizione entrambi gli utensili
-         if Milling.ToolInfo.nToolIndex and Milling2.ToolInfo.nToolIndex then
-            table.insert( Machining, Milling)
-            table.insert( Machining, Milling2)
-         -- se disponibile solo primo utensile
-         elseif Milling.ToolInfo.nToolIndex then
-            table.insert( Machining, Milling)
-         -- se disponibile solo secondo utensile
-         elseif Milling2.ToolInfo.nToolIndex then
-            table.insert( Machining, Milling2)
-         -- nessun utensile disponibile
+      local dCompletionPercentage = 100
+      -- completa se svuotatura eseguita e antisplit eseguiti (o non richiesti)
+      if Pocketing.bIsApplicable and ( bAreAllAntisplintsApplicable or not Strategy.Parameters.bAntiSplint) then
+         Result.sStatus = 'Completed'
+         if bAreAllAntisplintsApplicable then
+            Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
          else
-         -- non si fa nulla
+            Result.dQuality = FeatureLib.GetStrategyQuality( 'STD')
          end
-      -- altrimenti senza codolo
+      -- altrimenti non completa
       else
-         -- se utensile 1 esegue completamente
-         if Milling.ToolInfo.nToolIndex and Milling.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
-            table.insert( Machining, Milling)
-         -- se utensile 2 esegue completamente
-         elseif Milling2.ToolInfo.nToolIndex and Milling2.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
-            table.insert( Machining, Milling2)
-         -- se possono lavorare entrambi
-         elseif Milling.ToolInfo.nToolIndex and Milling2.ToolInfo.nToolIndex then
-            table.insert( Machining, Milling)
-            table.insert( Machining, Milling2)
-         -- se utensile 1 non completo
-         elseif Milling.ToolInfo.nToolIndex then
-            table.insert( Machining, Milling)
-            -- se utensile 2 non completo
-         elseif Milling2.ToolInfo.nToolIndex then
-            table.insert( Machining, Milling2)
+         Result.dQuality = FeatureLib.GetStrategyQuality( 'STD')
+         Result.sStatus = 'Not-Completed'
+         -- se fa solo svuotatura
+         if Pocketing.bIsApplicable then
+            dCompletionPercentage = 90
+            Result.sInfo = 'Anti-Split not executed'
+         elseif Strategy.Parameters.bAntiSplint and bAreAllAntisplintsApplicable then
+            dCompletionPercentage = 75
+            Result.sInfo = 'Pocketing not executed'
+         else
+            dCompletionPercentage = 50
+            Result.sInfo = 'Only the cut has been executed'
          end
       end
+
+      Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
    end
 
-   -- TODO VOTO DA FARE!!!!
-   Strategy.Result.sStatus = 'Completed'
-   Strategy.Result.dCompletionIndex = 5
-   Strategy.Result.dMRR = MachiningLib.GetToolMRR( Machining[1].ToolInfo or Machining[2].ToolInfo)
-   Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'MILL')
-   Strategy.Result.sInfo = ''
+   -- creo una tabella unica contenente tutte le lavorazioni
+   local Machinings = {}
+   EgtJoinTables( Machinings, Cutting.Machinings)
+   EgtJoinTables( Machinings, AntiSplints)
+   EgtJoinTables( Machinings, Pocketing)
 
-   return Machining
+   return Machinings, Result
 end
 
 -------------------------------------------------------------------------------------------------------------
@@ -173,79 +198,33 @@ function STR0009.Make( bAddMachining, Proc, Part, CustomParameters)
    Strategy.Result = {}
 
    local bAreAllMachiningsAdded = true
-   local Milling = {}
 
-   Strategy.Machinings = GetArcStrategy( Proc, Part)
+   -- controlli preliminari
+   if Proc.nFct < 3 or Proc.nFct > 5 then
+      local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. StrategyLib.Config.sStrategyId .. ' not applicable'
+      EgtOutLog( sErr)
+      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( sErr)
+      return false, Strategy.Result
+   end
 
-   if bAddMachining and Strategy.Result.sStatus ~= 'Not-Applicable' then
-      -- eventuali punti di spezzatura
-      local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
+   Strategy.Machinings, Strategy.Result = GetScarfJointStrategy( Proc, Part)
 
-      for i = 1, #Strategy.Machinings do
-
-         Strategy.Machinings[i].Geometry = {{ Proc.idAddAuxGeom, -1}}
-         Strategy.Machinings[i].nToolIndex = Strategy.Machinings[i].ToolInfo.nToolIndex
-         Strategy.Machinings[i].nType = MCH_MY.MILLING
-         Strategy.Machinings[i].dStartSafetyLength = 0
-         Strategy.Machinings[i].Steps = {}
-         Strategy.Machinings[i].Steps = MachiningLib.GetMachiningSteps( false, tonumber( Strategy.Machinings[i].sDepth), TOOLS[Strategy.Machinings[i].nToolIndex].dStep)
-
-         -- LeadIn / LeadOut
-         Strategy.Machinings[i].LeadIn = {}
-         Strategy.Machinings[i].LeadOut = {}
-         Strategy.Machinings[i].LeadIn.nType = MCH_MILL_LI.TANGENT
-         Strategy.Machinings[i].LeadOut.nType = MCH_MILL_LI.TANGENT
-         Strategy.Machinings[i].LeadIn.dTangentDistance = TOOLS[Strategy.Machinings[i].ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
-         Strategy.Machinings[i].LeadIn.dPerpDistance = 0
-         Strategy.Machinings[i].LeadIn.dStartAddLength = 0
-         Strategy.Machinings[i].LeadOut.dTangentDistance = TOOLS[Strategy.Machinings[i].ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
-         Strategy.Machinings[i].LeadOut.dPerpDistance = 0
-         Strategy.Machinings[i].LeadOut.dEndAddLength = 0
-
-         local dLengthOnX = Proc.b3Box:getDimX()
-         Strategy.bCanMoveAfterSplit = MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part)
-         if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
-            Strategy.Machinings[i].sStage = 'AfterTail'
-         end
-
-         -- preparo attacco/uscita in caso di spezzatura arco
-         Strategy.Machinings[i].LeadInForSplit = BeamLib.TableCopyDeep( Strategy.Machinings[i].LeadIn)
-         Strategy.Machinings[i].LeadOutForSplit = BeamLib.TableCopyDeep( Strategy.Machinings[i].LeadOut)
-         Strategy.Machinings[i].LeadInForSplit.nType = MCH_MILL_LI.LINEAR
-         Strategy.Machinings[i].LeadOutForSplit.nType = MCH_MILL_LI.LINEAR
-         Strategy.Machinings[i].LeadInForSplit.dTangentDistance = 0
-         Strategy.Machinings[i].LeadInForSplit.dPerpDistance = TOOLS[Strategy.Machinings[i].ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
-         Strategy.Machinings[i].LeadOutForSplit.dTangentDistance = 0
-         Strategy.Machinings[i].LeadOutForSplit.dPerpDistance = TOOLS[Strategy.Machinings[i].ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
-
-         -- sistemo il lato e la direzione di lavoro
-         if i == 1 then
-            Strategy.Machinings[i].bInvert = EgtIf( TOOLS[Strategy.Machinings[i].ToolInfo.nToolIndex].bIsCCW, false, true)
-            Strategy.Machinings[i].nWorkside = EgtIf( TOOLS[Strategy.Machinings[i].ToolInfo.nToolIndex].bIsCCW, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
-         else
-            Strategy.Machinings[i].bToolInvert = true
-            Strategy.Machinings[i].bInvert = EgtIf( TOOLS[Strategy.Machinings[i].ToolInfo.nToolIndex].bIsCCW, true, false)
-            Strategy.Machinings[i].nWorkside = EgtIf( TOOLS[Strategy.Machinings[i].ToolInfo.nToolIndex].bIsCCW, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
-         end
-         Strategy.Machinings[i].ptEdge1 = EgtSP( Proc.idAddAuxGeom, GDB_ID.ROOT)
-         Strategy.Machinings[i].ptEdge2 = EgtEP( Proc.idAddAuxGeom, GDB_ID.ROOT)
-         Strategy.Machinings[i].dEdgeLength = EgtCurveLength( Proc.idAddAuxGeom)
-         Strategy.Machinings[i].vtEdgeDirection = EgtSV( Proc.idAddAuxGeom, GDB_ID.ROOT) + EgtMV( Proc.idAddAuxGeom, GDB_ID.ROOT) + EgtEV( Proc.idAddAuxGeom, GDB_ID.ROOT)
-         Strategy.Machinings[i].dLengthOnX = Proc.b3Box:getDimX()
-
-         local MachiningToSplit = {}
-         table.insert( MachiningToSplit, Strategy.Machinings[i])
-         local MachiningResult = MachiningLib.GetSplitMachinings( MachiningToSplit, FeatureSplittingPoints, Part)
+   -- aggiunta lavorazioni
+   if #Strategy.Machinings > 0 then
+      if bAddMachining and Strategy.Result.sStatus ~= 'Not-Applicable' then
          -- aggiunge lavorazione
-         for j = 1, #MachiningResult do
-            bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, MachiningResult[j])
+         for j = 1, #Strategy.Machinings do
+            if Proc.AffectedFaces.bLeft then
+               Strategy.Machinings[j].sStage = 'AfterTail'
+            end
+            bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, Strategy.Machinings[j])
          end
       end
-
    else
-      bAreAllMachiningsAdded = false
+      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable()
    end
 
+
    return bAreAllMachiningsAdded, Strategy.Result
 end
 

Strategies/Standard/STR0010/STR0010.lua

@@ -253,6 +253,7 @@ function STR0010.Make( bAddMachining, Proc, Part, CustomParameters)
    ToolSearchParameters.vtToolDirection = BottomFace1.vtN
    ToolSearchParameters.bAllowTopHead = true
    ToolSearchParameters.bAllowBottomHead = true
+   ToolSearchParameters.sMillShape = 'STANDARD'
    local ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
    local nToolIndex = ToolInfo.nToolIndex
 
@@ -391,7 +392,12 @@ function STR0010.Make( bAddMachining, Proc, Part, CustomParameters)
    Strategy.Machinings = MachiningLib.GetSplitMachinings( Strategy.Machinings, FeatureSplittingPoints, Part)
    table.sort( Strategy.Machinings, SortMachiningsBySegment)
 
-   Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( Strategy.Machinings)
+   -- se non ci sono lati chiusi, la qualità è migliore
+   if Proc.Topology.sName == 'Bevel-1-Through' or Proc.Topology.sName == 'DoubleBevel-2-Through' or Proc.Topology.sName == 'Cut-1-Through' then
+      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
+   else
+      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( Strategy.Machinings)
+   end
    Strategy.Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( Strategy.Machinings)
    Strategy.Result.dMRR = ( dFeatureVolume / Strategy.Result.dTimeToMachine) / pow( 10, 6)
    if Strategy.Result.dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then

Strategies/Standard/STR0013/STR0013.lua

@@ -74,7 +74,7 @@ local function GetDrillingWithMillStrategy( Proc, Part)
          HalfMilling2.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
 
          -- se entrambi gli utensili lavorano in modo completo fino alla metà del foro, li sostituisco a qeulli trovati in precedenza
-         if HalfMilling.ToolInfo.dResidualDepth < 0 and HalfMilling2.ToolInfo.dResidualDepth < 0 then
+         if HalfMilling.ToolInfo.dResidualDepth and HalfMilling2.ToolInfo.dResidualDepth and HalfMilling.ToolInfo.dResidualDepth < 0 and HalfMilling2.ToolInfo.dResidualDepth < 0 then
             if Milling.ToolInfo.nToolIndex ~= HalfMilling.ToolInfo.nToolIndex then
                Milling.ToolInfo.nToolIndex, Milling.ToolInfo.dResidualDepth = HalfMilling.ToolInfo.nToolIndex, HalfMilling.ToolInfo.dResidualDepth
             end

Strategies/Standard/STR0014/STR0014.lua

@@ -109,7 +109,7 @@ function STR0014.Make( bAddMachining, Proc, Part, CustomParameters)
          for i = 1, #Proc.FeatureInfo.AdditionalGeometries do
             local AuxId = Proc.id + Proc.FeatureInfo.AdditionalGeometries[i]
             Strategy.AuxiliaryData.Clones[i+1] = {}
-            Strategy.AuxiliaryData.Clones[i+1].Geometry = EgtSetMachiningGeometry( {{ AuxId, -1}})
+            Strategy.AuxiliaryData.Clones[i+1].Geometry = {{ AuxId, -1}}
          end
 
          bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, Strategy.Machining, Strategy.AuxiliaryData)

Strategies/Strategies.ini

@@ -8,7 +8,7 @@ STR0005 = 1, 2 o 3 facce. Lama con taglio singolo o cubetti. Se richiesto o nece
 STR0006 = Tenone. Lama + fresa
 STR0007 = Mortasa a coda di rondine e mortasa frontale a coda di rondine
 STR0008 = Svuotatura mortasa (raggiata)
-STR0009 = !!DEPRECATA!! Sostituita da STR0015. RIUTILIZZABILE!
+STR0009 = ScarfJoint
 STR0010 = Fresatura perpendicolare (tipo cut, longcut)
 STR0011 = Foratura
 STR0012 = RidgeLap

StrategyLibs/BLADETOWASTE.lua

@@ -795,6 +795,7 @@ local function CalculateDiceMachinings( vCuts, Parameters)
    local bReduceBladePath = Parameters.bReduceBladePath
    local sRestLengthSideForPreSimulation = Parameters.sRestLengthSideForPreSimulation
    local bCannotSplitRestLength = Parameters.bCannotSplitRestLength
+   local bReduceDiceDepth = Parameters.bReduceDiceDepth
 
    -- eventuale inversione tagli ortogonali e aggiunta informazioni alla geometria
    local bAreOrthogonalCutsInverted = false
@@ -884,8 +885,13 @@ local function CalculateDiceMachinings( vCuts, Parameters)
       -- caso standard (tagli perpendicolari o paralleli non accorpabili)
       if ( not bCanMergeParallelCuts) or ( not bIsDicingOk) then
          for j = 1, #vCuts[i] do
-            -- in generale sta sollevato di pochissimo
-            local dExtraCut = -0.1
+            -- se abilitato, la lama sta sollevata per non rovinare le facce
+            local dExtraCut
+            if bReduceDiceDepth == false then
+               dExtraCut = 0
+            else
+               dExtraCut = -0.1
+            end
             -- se tagli paralleli
             if ( i % 2) == 0 then
                -- se non ci sono tagli ortogonali devo affondare
@@ -914,7 +920,8 @@ local function CalculateDiceMachinings( vCuts, Parameters)
                dExtendAfterTail = dExtendAfterTail,
                bIsDicing = true,
                sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
-               bCannotSplitRestLength = bCannotSplitRestLength
+               bCannotSplitRestLength = bCannotSplitRestLength,
+               bDisableRealElevationCheck = ( i % 2) > 0 -- se taglio perpendicolare non si deve mai considerare il materiale precedente
             }
             Cutting = FaceByBlade.Make( ProcTrimesh, Part, FaceToMachine, EdgeToMachine, OptionalParametersFaceByBlade)
             Cutting.ptCenter = Point3d( ProcTrimesh.Faces[1].ptCenter:getX(), 0, 0)
@@ -964,6 +971,9 @@ local function CutWithDicing( Proc, Part, OptionalParameters)
       end
    end
 
+   -- angolo tra le facce, se più di una
+   local dAngleBetweenFaces = Proc.AdjacencyMatrix[1][2] or 0
+
    -- scelta lama da sopra o da sotto
    local sChosenBladeType = ''
    if not nToolIndex then
@@ -1008,7 +1018,8 @@ local function CutWithDicing( Proc, Part, OptionalParameters)
       dExtendAfterTail = dExtendAfterTail,
       bReduceBladePath = bReduceBladePath,
       sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
-      bCannotSplitRestLength = bCannotSplitRestLength
+      bCannotSplitRestLength = bCannotSplitRestLength,
+      bReduceDiceDepth = ( dAngleBetweenFaces < - 10) -- per facce molto aperte non si riduce l'affondamento della lama nei cubetti (rischio che non si stacchino)
    }
 
    bIsDicingOk, Machinings, bMoveAfterSplit = CalculateDiceMachinings( vCuts, Parameters)

StrategyLibs/FACEBYBLADE.lua

@@ -211,6 +211,7 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
    local bIsDicing = OptionalParameters.bIsDicing or false
    local sRestLengthSideForPreSimulation = OptionalParameters.sRestLengthSideForPreSimulation or 'Tail'
    local bCannotSplitRestLength = OptionalParameters.bCannotSplitRestLength or false
+   local bDisableRealElevationCheck = OptionalParameters.bDisableRealElevationCheck or false
 
    -- lunghezze, direzioni e punti caratteristici della lavorazione e del lato lavorato
    Cutting.dEdgeLength = EdgeToMachine.dLength
@@ -231,10 +232,14 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
          Tool = TOOLS[Cutting.nToolIndex],
          dDepthToMachine = dDepthToMachine
       }
+      if OppositeToolDirectionMode == 'Enabled' then
+         BladeEngagementParameters.Edge = EdgeToMachineOpposite
+      end
       local BladeEngagementOptionalParameters = {
          bIsDicing = bIsDicing,
          sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
-         bCannotSplitRestLength = bCannotSplitRestLength
+         bCannotSplitRestLength = bCannotSplitRestLength,
+         bDisableRealElevationCheck = bDisableRealElevationCheck
       }
       local Engagement
       TIMER:startElapsed( 'GetBladeEngagement')
@@ -258,6 +263,7 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       ToolSearchParameters.Part = Part
       ToolSearchParameters.sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation
       ToolSearchParameters.bCannotSplitRestLength = bCannotSplitRestLength
+      ToolSearchParameters.bDisableRealElevationCheck = bDisableRealElevationCheck
 
       local ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
       Cutting.nToolIndex = ToolInfo.nToolIndex
@@ -355,7 +361,8 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
       local BladeEngagementOptionalParameters = {
          bIsDicing = bIsDicing,
          sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
-         bCannotSplitRestLength = bCannotSplitRestLength
+         bCannotSplitRestLength = bCannotSplitRestLength,
+         bDisableRealElevationCheck = bDisableRealElevationCheck
       }
       TIMER:startElapsed( 'GetBladeEngagement')
       local bIsApplicableOpposite, EngagementOpposite = MachiningLib.GetBladeEngagement( BladeEngagementParameters, BladeEngagementOptionalParameters)
@@ -472,7 +479,8 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
          local BladeEngagementOptionalParameters = {
             bIsDicing = bIsDicing,
             sRestLengthSideForPreSimulation = sRestLengthSideForPreSimulation,
-            bCannotSplitRestLength = bCannotSplitRestLength
+            bCannotSplitRestLength = bCannotSplitRestLength,
+            bDisableRealElevationCheck = bDisableRealElevationCheck
          }
          TIMER:startElapsed( 'GetBladeEngagement')
          local bIsApplicable, CurrentEngagement = MachiningLib.GetBladeEngagement( BladeEngagementParameters, BladeEngagementOptionalParameters )