- in MachiningLib.TestEngagement, PreSimulationLib e LeadInOutLib predisposte funzioni per calcolo extracorsa

LuaLibs/PreSimulationLib.lua

@@ -27,23 +27,32 @@ local function GetRestlengthSurfTm( Part)
 end
 
 -------------------------------------------------------------------------------------------------------------
--- calcolo pivot in riferimento globale
-local function GetGlobalPivot( ptRef, vtC, vtHead, vtMovePivot)
+-- calcolo punto sull'uscita testa a partire dal punto di lavorazione o di attacco sul diametro utensile
+local function GetToolExitPoint( ptMachining, vtNEdge, vtHead, Tool, bIsDownUp)
+
+   local ptToolExitPoint = Point3d( ptMachining + vtNEdge * Tool.dDiameter / 2) + vtHead * EgtIf( bIsDownUp, ( Tool.dLength - Tool.dThickness), Tool.dLength)
+
+   return ptToolExitPoint
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- calcolo pivot in riferimento globale, datipunto sull'uscita utensile e direzioni
+local function GetGlobalPivot( ptToolExit, vtC, vtHead, vtMovePivot)
 
    -- frame solidale all'utensile (lo stesso in cui vtMovePivot è definito)
-   local frTool = Frame3d( ptRef, vtHead, vtC)
+   local frTool = Frame3d( ptToolExit, vtHead, vtC)
    local vtMovePivotGlob = Vector3d( vtMovePivot)
    vtMovePivotGlob:toGlob( frTool)
-   local ptPivot = ptRef + vtMovePivotGlob
+   local ptPivot = ptToolExit + vtMovePivotGlob
 
    return ptPivot
 end
 
 -------------------------------------------------------------------------------------------------------------
 -- restituisce i punti notevoli della lavorazioni in cui fare il controllo
-local function GetMachiningPoints( Edge, dDepthToMachine)
+local function GetPointsToCheck( Edge, dDepthToMachine)
 
-   local MachiningPoints = {}
+   local PointsToCheck = {}
 
    -- punti notevoli
    local ptStart = Edge.ptStart + Edge.vtN * ( Edge.dElevation - dDepthToMachine)
@@ -59,27 +68,67 @@ local function GetMachiningPoints( Edge, dDepthToMachine)
    -- aggiunta punti
    -- inizio e fine solo se lato obliquo
    if not bIsEdgeParallelToMainDirection then
-      table.insert( MachiningPoints, ptStart)
+      table.insert( PointsToCheck, ptStart)
    end
-   table.insert( MachiningPoints, ptMid)
+   table.insert( PointsToCheck, ptMid)
    if not bIsEdgeParallelToMainDirection then
-      table.insert( MachiningPoints, ptEnd)
+      table.insert( PointsToCheck, ptEnd)
    end
 
-   return MachiningPoints
+   return PointsToCheck
 end
 
 -------------------------------------------------------------------------------------------------------------
--- TODO da fare
-function PreSimulationLib.CheckOutOfStroke()
-   
+local function CheckOutOfStrokePoint( ptToolExitToCheck, vtC, vtHead, PreCollisionData)
+
+   local bOutOfStroke = false
+   local ptPivot = GetGlobalPivot( ptToolExitToCheck, vtC, vtHead, PreCollisionData.vtMovePivot)
+
+
+   return bOutOfStroke
+end
+
+-------------------------------------------------------------------------------------------------------------
+-- check finecorsa: se non vengono passati punti si controllano inizio e fine del lato
+function PreSimulationLib.CheckOutOfStroke( Parameters, OptionalParameters )
+
+   -- parametri obbligatori
+   local Edge = Parameters.Edge
+   local vtNFace = Parameters.vtNFace
+   local vtHead = Parameters.vtHead
+   local Tool = Parameters.Tool
+
+   -- parametri opzionali
+   OptionalParameters = OptionalParameters or {}
+   local PointsToCheck = OptionalParameters.PointsToCheck or { Edge.ptStart, Edge.ptEnd}
+
+   local bIsDownUp = AreOppositeVectorApprox( vtNFace, vtHead)
+
+   -- punti curva collisione e direzioni check da macchina
+   -- TODO serve pivot???
+   local vtMovePivot = nil
+
+   -- check collisione sui punti in centro lama su naso mandrino o aggregato. In base a direzione e punto
+   for i = 1, #PointsToCheck do
+
+      local ToolExitPoint = GetToolExitPoint( PointsToCheck[i], Edge.vtN, vtHead, Tool, bIsDownUp)
+
+      --local bOutOfStroke = CheckOutOfStrokePoint( ptToolExitToCheck, vtC, vtHead, vtMovePivot)
+
+      -- se trovato finecorsa inutile procedere con gli altri punti
+      if bOutOfStroke then
+         return true
+      end
+   end
+
+   -- arrivati qui nessun finecorsa
    return false
 end
 
 -------------------------------------------------------------------------------------------------------------
-local function CheckCollisionPoint( ptPointToCheck, vtC, vtHead, PreCollisionData, Part, bCheckOnlyRestlength)
+local function CheckCollisionPoint( ptToolExitToCheck, vtC, vtHead, PreCollisionData, Part, bCheckOnlyRestlength)
 
-   local ptPivot = GetGlobalPivot( ptPointToCheck, vtC, vtHead, PreCollisionData.vtMovePivot)
+   local ptPivot = GetGlobalPivot( ptToolExitToCheck, vtC, vtHead, PreCollisionData.vtMovePivot)
 
    -- orientamento del riferimento locale
    local vtDirectionX = PreCollisionData.Directions.vtDirectionX
@@ -169,13 +218,13 @@ local function CheckCollisionWithAxis( sAxis, MachiningParameters, OptionalParam
    -- end
 
    -- punti notevoli della lavorazione in cui fare il check
-   local MachiningPoints = OptionalParameters.MachiningPoints or GetMachiningPoints( Edge, dDepthToMachine)
+   local PointsToCheck = OptionalParameters.PointsToCheck or GetPointsToCheck( Edge, dDepthToMachine)
 
    -- punti in centro lama su naso mandrino o aggregato. In base a direzione e punto
    local bIsDownUp = AreOppositeVectorApprox( vtNFace, vtHead)
    local ToolExitPoints = {}
-   for i = 1, #MachiningPoints do
-      ToolExitPoints[i] = Point3d( MachiningPoints[i] + Edge.vtN * Tool.dDiameter / 2) + vtHead * EgtIf( bIsDownUp, ( Tool.dLength - Tool.dThickness), Tool.dLength)
+   for i = 1, #PointsToCheck do
+      ToolExitPoints[i] = GetToolExitPoint( PointsToCheck[i], Edge.vtN, vtHead, Tool, bIsDownUp)
    end
 
    -- vtC punta sempre verso il corpo dell'asse C o verso l'aggregato
@@ -227,7 +276,7 @@ function PreSimulationLib.CheckCollision( sBladeEngagement, Parameters, Optional
    
    local OptionalParametersCheckCollisionWithAxis = {}
    OptionalParametersCheckCollisionWithAxis.bCheckOnlyRestlength = false
-   OptionalParametersCheckCollisionWithAxis.MachiningPoints = OptionalParameters.MachiningPoints or nil
+   OptionalParametersCheckCollisionWithAxis.PointsToCheck = OptionalParameters.PointsToCheck or nil
 
    -- asse Z si controlla sempre
    bCollisionFound, bMoveAfterSplitZ = CheckCollisionWithAxis( 'Z', Parameters, OptionalParametersCheckCollisionWithAxis)