Merge remote-tracking branch 'origin/STR0003_BladePlusChainsaw' into develop
This commit is contained in:
andrea.villa
@@ -56,17 +56,25 @@ local function GetStrategies_Egalware( Proc)
|
||||
-- Feature : Slot
|
||||
elseif ID.IsSlot( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Front Slot
|
||||
elseif ID.IsFrontSlot( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Birds Mouth
|
||||
@@ -78,25 +86,37 @@ local function GetStrategies_Egalware( Proc)
|
||||
-- Feature : Ridge Lap
|
||||
elseif ID.IsRidgeLap( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Lap Joint
|
||||
elseif ID.IsLapJoint( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Notch/Rabbet
|
||||
elseif ID.IsNotchRabbet( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Block Haus
|
||||
@@ -105,9 +125,13 @@ local function GetStrategies_Egalware( Proc)
|
||||
-- Feature : Notch
|
||||
elseif ID.IsNotch( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : French Ridge Lap
|
||||
@@ -125,9 +149,13 @@ local function GetStrategies_Egalware( Proc)
|
||||
-- Feature : Pocket
|
||||
elseif ID.IsPocket( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Drilling
|
||||
@@ -268,17 +296,25 @@ local function GetStrategies_Essetre( Proc)
|
||||
-- Feature : Slot
|
||||
elseif ID.IsSlot( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Front Slot
|
||||
elseif ID.IsFrontSlot( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Birds Mouth
|
||||
@@ -290,25 +326,37 @@ local function GetStrategies_Essetre( Proc)
|
||||
-- Feature : Ridge Lap
|
||||
elseif ID.IsRidgeLap( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Lap Joint
|
||||
elseif ID.IsLapJoint( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Notch/Rabbet
|
||||
elseif ID.IsNotchRabbet( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Block Haus
|
||||
@@ -317,9 +365,13 @@ local function GetStrategies_Essetre( Proc)
|
||||
-- Feature : Notch
|
||||
elseif ID.IsNotch( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : French Ridge Lap
|
||||
@@ -337,9 +389,13 @@ local function GetStrategies_Essetre( Proc)
|
||||
-- Feature : Pocket
|
||||
elseif ID.IsPocket( Proc) then
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}}
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0002'}, { sStrategyId = 'STR0003'}}
|
||||
elseif Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
Strategies = { { sStrategyId = 'STR0003'}}
|
||||
end
|
||||
---------------------------------------------------------------------
|
||||
-- Feature : Drilling
|
||||
|
||||
+12
-6
@@ -17,7 +17,7 @@ local ID = require( 'Identity')
|
||||
local BCS = require( 'BasicCustomerStrategies')
|
||||
local FeatureData = require( 'FeatureData')
|
||||
local FaceData = require( 'FaceData')
|
||||
local MachLib = require( 'MachiningLib')
|
||||
local MachiningLib = require( 'MachiningLib')
|
||||
|
||||
|
||||
EgtOutLog( ' BeamExec started', 1)
|
||||
@@ -68,8 +68,12 @@ local function IsToolOk( Tool)
|
||||
if Tool.sFamily == 'DRILLBIT' then
|
||||
return true
|
||||
-- altrimenti controllo dati aggiuntivi altre famiglie di utensili
|
||||
elseif Tool.sFamily == 'MORTISE' then
|
||||
if Tool.dCornerRadius then
|
||||
return true
|
||||
end
|
||||
else
|
||||
if Tool.dThick then
|
||||
if Tool.dThickness then
|
||||
return true
|
||||
end
|
||||
end
|
||||
@@ -130,7 +134,7 @@ function BeamExec.GetToolsFromDB()
|
||||
|
||||
-- lettura parametri non comuni ( famiglia DRILLBIT non ha parametri specifici)
|
||||
if sToolFamily ~= 'DRILLBIT' then
|
||||
Tool.dThick = EgtTdbGetCurrToolParam( MCH_TP.THICK)
|
||||
Tool.dThickness = EgtTdbGetCurrToolParam( MCH_TP.THICK)
|
||||
Tool.dLongitudinalOffset = EgtTdbGetCurrToolParam( MCH_TP.LONOFFSET)
|
||||
Tool.dRadialOffset = EgtTdbGetCurrToolParam( MCH_TP.RADOFFSET)
|
||||
-- recupero parametri propri delle frese
|
||||
@@ -148,15 +152,17 @@ function BeamExec.GetToolsFromDB()
|
||||
-- recupero parametri propri delle lame
|
||||
elseif sToolFamily == 'SAWBLADE' then
|
||||
Tool.bIsUsedForLongCut = EgtGetValInNotes( Tool.sUserNotes, 'LONGCUT') == 1 or false -- false coem valore di default
|
||||
Tool.dStep = EgtGetValInNotes( Tool.sUserNotes, 'STEP') or Tool.dThick -- se non settato nell'utensile, considero lo spessore lama
|
||||
Tool.dStep = EgtGetValInNotes( Tool.sUserNotes, 'STEP') or Tool.dThickness -- se non settato nell'utensile, considero lo spessore lama
|
||||
Tool.dSideStep = EgtGetValInNotes( Tool.sUserNotes, 'SIDESTEP') or floor( Tool.dDiameter / 4) -- se non settato nell'utensile, considero un quarto del diametro
|
||||
-- recupero parametri propri delle motoseghe
|
||||
elseif sToolFamily == 'MORTISE' then
|
||||
Tool.dDistance = EgtTdbGetCurrToolParam( MCH_TP.DIST) or 90 -- 90mm dimensione standard aggregato catena
|
||||
Tool.bIsMortise = EgtGetValInNotes( Tool.sUserNotes, 'MORTISE') == 1
|
||||
Tool.bIsChainSaw = not Tool.bIsMortise
|
||||
Tool.dStep = EgtGetValInNotes( Tool.sUserNotes, 'STEP') or ( Tool.dThick - 1) -- se non settato nell'utensile, considero spessore catena meno 1mm di sicurezza
|
||||
Tool.dSideStep = EgtGetValInNotes( Tool.sUserNotes, 'SIDESTEP') or floor( Tool.dMaxMaterial / 3) -- se non settato nell'utensile, considero un terzo della lunghezza
|
||||
Tool.dStep = EgtGetValInNotes( Tool.sUserNotes, 'STEP') or floor( Tool.dMaxMaterial / 3) -- se non settato nell'utensile, considero un terzo della lunghezza
|
||||
Tool.dSideStep = EgtGetValInNotes( Tool.sUserNotes, 'SIDESTEP') or ( Tool.dThickness - 1) -- se non settato nell'utensile, considero spessore catena meno 1mm di sicurezza
|
||||
Tool.dCornerRadius = EgtTdbGetCurrToolParam( MCH_TP.CORNRAD)
|
||||
Tool.dWidth = Tool.dDiameter
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
@@ -175,6 +175,41 @@ function BeamLib.GetAffectedFaces( Proc)
|
||||
return vtFacesAffected
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
function BeamLib.GetNearestOrthoOpposite( vtRef, vtNorm)
|
||||
-- se definita anche la normale alla faccia, elimino la parte di vtRef parallela a questa
|
||||
local vtMyRef = Vector3d( vtRef)
|
||||
if vtNorm then
|
||||
vtMyRef = vtMyRef - ( vtMyRef * vtNorm) * vtNorm
|
||||
vtMyRef:normalize()
|
||||
end
|
||||
-- se prevalente una componente orizzontale (con piccolissimo vantaggio)
|
||||
if abs( vtMyRef:getX()) > 0.91 * abs( vtMyRef:getZ()) or abs( vtMyRef:getY()) > 0.91 * abs( vtMyRef:getZ()) then
|
||||
-- se prevale la componente destra/sinistra
|
||||
if abs( vtMyRef:getX()) > 0.95 * abs( vtMyRef:getY()) then
|
||||
if vtMyRef:getX() > -GEO.EPS_SMALL then
|
||||
return MCH_MILL_FU.ORTHO_LEFT
|
||||
else
|
||||
return MCH_MILL_FU.ORTHO_RIGHT
|
||||
end
|
||||
else
|
||||
if vtMyRef:getY() > -GEO.EPS_SMALL then
|
||||
return MCH_MILL_FU.ORTHO_FRONT
|
||||
else
|
||||
return MCH_MILL_FU.ORTHO_BACK
|
||||
end
|
||||
end
|
||||
-- altrimenti prevale la verticale
|
||||
else
|
||||
if vtMyRef:getZ() > -GEO.EPS_SMALL then
|
||||
return MCH_MILL_FU.ORTHO_DOWN
|
||||
else
|
||||
return MCH_MILL_FU.ORTHO_TOP
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
---------------------------------------------------------------------
|
||||
-- Funzione per determinare se la faccia ha lati molto corti (trascurabili) ed è quindi approssimabile ad una 3 facce
|
||||
function BeamLib.Is3EdgesApprox( Proc, idFace, nAddGrpId)
|
||||
|
||||
+30
-41
@@ -120,6 +120,7 @@ function FaceData.GetFacesInfo( Proc, Part)
|
||||
local frHV, dFaceWidth, dFaceHeight = BeamLib.GetFaceHvRefDim( Proc.id, i - 1, Part)
|
||||
-- frame OCS faccia
|
||||
Faces[i].vtFrameHV = frHV
|
||||
-- TODO valutare se Width e Height si possono rimuovere
|
||||
-- larghezza OCS faccia
|
||||
Faces[i].dWidth = dFaceWidth
|
||||
-- altezza OCS faccia
|
||||
@@ -195,6 +196,7 @@ local function GetTunnelFaces( Proc)
|
||||
EgtCutSurfTmPlane( TunnelAddedFaces.MiddleFaceTm.id, Proc.Faces[i].ptCenter, -Proc.Faces[i].vtN, false, GDB_ID.ROOT)
|
||||
end
|
||||
TunnelAddedFaces.MiddleFaceTm.Type = 'Tunnel'
|
||||
-- TODO aggiungere anche informazioni Edges tunnel??
|
||||
|
||||
return TunnelAddedFaces
|
||||
end
|
||||
@@ -291,8 +293,8 @@ local function GetLongFaces( Proc, MainFaces)
|
||||
|
||||
local BottomFace = MainFaces.BottomFace or GetBottomFace( Proc)
|
||||
|
||||
local nFirstLongFaceId = GDB_ID.NULL
|
||||
local nSecondLongFaceId = GDB_ID.NULL
|
||||
local idFirstLongFace = GDB_ID.NULL
|
||||
local idSecondLongFace = GDB_ID.NULL
|
||||
if not BottomFace then
|
||||
local FacesSortedByGreatestArea = {}
|
||||
for i = 1, Proc.nFct do
|
||||
@@ -301,22 +303,22 @@ local function GetLongFaces( Proc, MainFaces)
|
||||
FacesSortedByGreatestArea[i].dArea = Proc.Faces[i].dArea
|
||||
end
|
||||
table.sort( FacesSortedByGreatestArea, function (a, b) return a.dArea > b.dArea end)
|
||||
nFirstLongFaceId = FacesSortedByGreatestArea[1].id
|
||||
local FacesNotAdjacent = GetNotAdjacentFaces( Proc, nFirstLongFaceId)
|
||||
nSecondLongFaceId = FacesNotAdjacent[1].id
|
||||
idFirstLongFace = FacesSortedByGreatestArea[1].id
|
||||
local FacesNotAdjacent = GetNotAdjacentFaces( Proc, idFirstLongFace)
|
||||
idSecondLongFace = FacesNotAdjacent[1].id
|
||||
else
|
||||
if not BottomFace.MainEdges.LongEdges[1].bIsOpen then
|
||||
nFirstLongFaceId = BottomFace.MainEdges.LongEdges[1].idAdjacentFace
|
||||
idFirstLongFace = BottomFace.MainEdges.LongEdges[1].idAdjacentFace
|
||||
end
|
||||
if not BottomFace.MainEdges.LongEdges[2].bIsOpen then
|
||||
nSecondLongFaceId = BottomFace.MainEdges.LongEdges[2].idAdjacentFace
|
||||
idSecondLongFace = BottomFace.MainEdges.LongEdges[2].idAdjacentFace
|
||||
end
|
||||
end
|
||||
if nFirstLongFaceId > -1 then
|
||||
LongFaces[1] = Proc.Faces[nFirstLongFaceId + 1]
|
||||
if idFirstLongFace > -1 then
|
||||
table.insert( LongFaces, Proc.Faces[idFirstLongFace + 1])
|
||||
end
|
||||
if nSecondLongFaceId > -1 then
|
||||
LongFaces[2] = Proc.Faces[nSecondLongFaceId + 1]
|
||||
if idSecondLongFace > -1 then
|
||||
table.insert( LongFaces, Proc.Faces[idSecondLongFace + 1])
|
||||
end
|
||||
|
||||
for i = 1, #LongFaces do
|
||||
@@ -379,39 +381,26 @@ local function GetSideFaces( Proc, MainFaces)
|
||||
error( 'GetSideFaces : Topology not implemented')
|
||||
end
|
||||
|
||||
local idBottomFace = GDB_ID.NULL
|
||||
if Proc.Topology.sFamily ~= 'Tunnel' then
|
||||
if MainFaces.BottomFace then
|
||||
idBottomFace = MainFaces.BottomFace.id
|
||||
else
|
||||
local BottomFace = GetBottomFace( Proc)
|
||||
idBottomFace = BottomFace.id or idBottomFace
|
||||
end
|
||||
local LongFaces = MainFaces.LongFaces or GetLongFaces( Proc, MainFaces)
|
||||
|
||||
local idFirstSideFace = GDB_ID.NULL
|
||||
local idSecondSideFace = GDB_ID.NULL
|
||||
if not LongFaces[1].MainEdges.SideEdges[1].bIsOpen then
|
||||
idFirstSideFace = LongFaces[1].MainEdges.SideEdges[1].idAdjacentFace
|
||||
end
|
||||
|
||||
local LongFaces = {}
|
||||
if MainFaces.LongFaces then
|
||||
LongFaces = MainFaces.LongFaces
|
||||
else
|
||||
LongFaces = GetLongFaces( Proc, MainFaces)
|
||||
if not LongFaces[1].MainEdges.SideEdges[2].bIsOpen then
|
||||
idSecondSideFace = LongFaces[1].MainEdges.SideEdges[2].idAdjacentFace
|
||||
end
|
||||
if idFirstSideFace > -1 then
|
||||
table.insert( SideFaces, Proc.Faces[idFirstSideFace + 1])
|
||||
SideFaces[#SideFaces].Type = 'Side'
|
||||
end
|
||||
if idSecondSideFace > -1 then
|
||||
table.insert( SideFaces, Proc.Faces[idSecondSideFace + 1])
|
||||
SideFaces[#SideFaces].Type = 'Side'
|
||||
end
|
||||
|
||||
|
||||
for i = 1, Proc.nFct do
|
||||
if not idBottomFace or i ~= ( idBottomFace + 1) then
|
||||
local bIsSideFace = true
|
||||
for j = 1, #LongFaces do
|
||||
if Proc.Faces[i].id == LongFaces[j].id then
|
||||
bIsSideFace = false
|
||||
break
|
||||
end
|
||||
end
|
||||
if bIsSideFace then
|
||||
table.insert( SideFaces, Proc.Faces[i])
|
||||
SideFaces[#SideFaces].Type = 'Side'
|
||||
end
|
||||
end
|
||||
end
|
||||
-- TODO aggiungere anche informazioni Edges??
|
||||
|
||||
return SideFaces
|
||||
end
|
||||
|
||||
+180
-44
@@ -14,11 +14,10 @@ local BeamData = require( 'BeamData')
|
||||
EgtOutLog( ' MachiningLib started', 1)
|
||||
|
||||
---------------------------------------------------------------------
|
||||
---
|
||||
---@param Proc table la feature
|
||||
---@param vtTool Vector3d il vettore direzione utensile
|
||||
---@return number dAngle angolo tra la faccia d'ingresso e la direzione utensile
|
||||
-- TODO da considerare solo angolo 2D??
|
||||
local function GetToolEntryAngle( Proc, vtTool)
|
||||
local Angle = {}
|
||||
|
||||
local dSinAngle = -10 * GEO.EPS_SMALL
|
||||
local vtNorm
|
||||
if Proc.AffectedFaces.bTop then
|
||||
@@ -48,82 +47,151 @@ local function GetToolEntryAngle( Proc, vtTool)
|
||||
|
||||
local dCosAngle = sqrt( 1 - sqr( dSinAngle))
|
||||
local dAngle = acos( dCosAngle)
|
||||
local dTanAngle
|
||||
if dAngle ~= 0 and dAngle ~= 90 then
|
||||
dTanAngle = sqrt( 1 - dCosAngle * dCosAngle) / dCosAngle
|
||||
end
|
||||
|
||||
return dAngle
|
||||
Angle.dValue = dAngle
|
||||
Angle.dSin = dSinAngle
|
||||
Angle.dCos = dCosAngle
|
||||
Angle.dTan = dTanAngle
|
||||
|
||||
return Angle
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
function MachiningLib.GetMachiningSteps( dMachiningDepth, dStep)
|
||||
|
||||
local MachiningSteps = {}
|
||||
MachiningSteps.dStepLength = 0
|
||||
MachiningSteps.nCount = ceil( ( dMachiningDepth - 10 * GEO.EPS_SMALL) / dStep)
|
||||
if MachiningSteps.nCount > 1 then
|
||||
MachiningSteps.dStepLength = ( dMachiningDepth - dStep) / ( MachiningSteps.nCount - 1)
|
||||
end
|
||||
|
||||
return MachiningSteps
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
-- funzione per cercare utensile tipo FRESA con certe caratteristiche
|
||||
function MachiningLib.FindMill( Proc, ToolSearchParameters)
|
||||
local ToolInfo = {}
|
||||
|
||||
for nCurrIndex=1, #TOOLS do
|
||||
local nBestToolIndex
|
||||
local dBestToolResidualDepth = 0
|
||||
for i = 1, #TOOLS do
|
||||
-- prima verifico che utensile sia compatibile
|
||||
local bCompatibleTool = true
|
||||
if TOOLS[nCurrIndex].sType ~= ToolSearchParameters.sType then
|
||||
bCompatibleTool = false
|
||||
elseif TOOLS[nCurrIndex].dDiameter > ToolSearchParameters.dMaxToolDiameter then
|
||||
bCompatibleTool = false
|
||||
elseif ToolSearchParameters.sMillShape == 'STANDARD' and ( TOOLS[nCurrIndex].dSideAngle ~= 0 or TOOLS[nCurrIndex].bIsPen) then
|
||||
bCompatibleTool = false
|
||||
elseif ToolSearchParameters.sMillShape == 'DOVETAIL' and not TOOLS[nCurrIndex].bIsDoveTail then
|
||||
bCompatibleTool = false
|
||||
elseif ToolSearchParameters.sMillShape == 'TSHAPEMILL' and not TOOLS[nCurrIndex].bIsTMill then
|
||||
bCompatibleTool = false
|
||||
elseif ToolSearchParameters.sMillShape == 'PEN' and not TOOLS[nCurrIndex].bIsPen then
|
||||
bCompatibleTool = false
|
||||
local bIsToolCompatible = true
|
||||
if TOOLS[i].sType ~= ToolSearchParameters.sType then
|
||||
bIsToolCompatible = false
|
||||
elseif TOOLS[i].dDiameter > ToolSearchParameters.dMaxToolDiameter then
|
||||
bIsToolCompatible = false
|
||||
elseif ToolSearchParameters.sMillShape == 'STANDARD' and ( TOOLS[i].dSideAngle ~= 0 or TOOLS[i].bIsPen) then
|
||||
bIsToolCompatible = false
|
||||
elseif ToolSearchParameters.sMillShape == 'DOVETAIL' and not TOOLS[i].bIsDoveTail then
|
||||
bIsToolCompatible = false
|
||||
elseif ToolSearchParameters.sMillShape == 'TSHAPEMILL' and not TOOLS[i].bIsTMill then
|
||||
bIsToolCompatible = false
|
||||
elseif ToolSearchParameters.sMillShape == 'PEN' and not TOOLS[i].bIsPen then
|
||||
bIsToolCompatible = false
|
||||
-- TODO controllare montaggio e verificare se direzione utensile raggiungibile. Serve funzione in BeamData
|
||||
end
|
||||
|
||||
-- scelgo il migliore
|
||||
if bCompatibleTool then
|
||||
if bIsToolCompatible then
|
||||
-- calcolo riduzione del massimo materiale utilizzabile
|
||||
local dToolEntryAngle = GetToolEntryAngle( Proc, ToolSearchParameters.vtToolDir)
|
||||
local ToolEntryAngle = GetToolEntryAngle( Proc, ToolSearchParameters.vtToolDir)
|
||||
-- se ToolHolder più grande dell'utensile, il primo oggetto in collisione è il ToolHolder. Altrimenti il motore.
|
||||
-- TODO Per il momento il motore ha un valore fisso: diametro di 180. Vedere se scrivere il diametro corretto in BeamData
|
||||
local dDimObjToCheck = EgtIf( TOOLS[nCurrIndex].ToolHolder.dDiameter > TOOLS[nCurrIndex].dDiameter, TOOLS[nCurrIndex].ToolHolder.dDiameter, 180)
|
||||
local dCurrMaxMatReduction = BeamData.COLL_SIC or 5
|
||||
local dDimObjToCheck = EgtIf( TOOLS[i].ToolHolder.dDiameter > TOOLS[i].dDiameter, TOOLS[i].ToolHolder.dDiameter, BeamData.C_SIMM_ENC)
|
||||
local dCurrentMaxMatReduction = BeamData.COLL_SIC or 5
|
||||
|
||||
-- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
|
||||
-- TODO considerare anche il caso in cui lo stelo sia più grande del diametro utensile
|
||||
-- TODO nei confronti tra valori gestire tolleranze
|
||||
-- calcolo riduzione per non toccare con ToolHolder / Motore
|
||||
if dToolEntryAngle > 0 and dToolEntryAngle < 90 then
|
||||
dCurrMaxMatReduction = dCurrMaxMatReduction / cos( 90 - dToolEntryAngle) + ( ( dDimObjToCheck - TOOLS[nCurrIndex].dDiameter) / 2) / tan( dToolEntryAngle)
|
||||
if ToolEntryAngle.dValue > 0 and ToolEntryAngle.dValue < 90 then
|
||||
dCurrentMaxMatReduction = dCurrentMaxMatReduction / ToolEntryAngle.dSin + ( ( dDimObjToCheck - TOOLS[i].dDiameter) / 2) / ToolEntryAngle.dTan
|
||||
end
|
||||
-- dCurrMachReduction = negativo -> limitare, positivo -> mm extra disponibili
|
||||
local dCurrMachReduction = TOOLS[nCurrIndex].dMaxDepth - ToolSearchParameters.dElevation - dCurrMaxMatReduction
|
||||
local dCurrentResidualDepth = ToolSearchParameters.dElevation + dCurrentMaxMatReduction - TOOLS[i].dMaxDepth
|
||||
|
||||
-- se non ancora trovato, oppure se completo e il migliore fino ad ora non è completo: corrente è il migliore
|
||||
if not ToolInfo.nToolIndex or ( ToolInfo.dMaxMatReduction <= 0 and dCurrMachReduction > 0) then
|
||||
ToolInfo.nToolIndex = nCurrIndex
|
||||
ToolInfo.dMaxMatReduction = dCurrMachReduction
|
||||
if not nBestToolIndex or ( dBestToolResidualDepth > 0 and dCurrentResidualDepth <= 0) then
|
||||
nBestToolIndex = i
|
||||
dBestToolResidualDepth = dCurrentResidualDepth
|
||||
-- altrimenti scelgo il migliore
|
||||
else
|
||||
-- se entrambi completi
|
||||
if ToolInfo.dMaxMatReduction > 0 and dCurrMachReduction > 0 then
|
||||
if dBestToolResidualDepth <= 0 and dCurrentResidualDepth <= 0 then
|
||||
-- scelgo utensile con rapporto lunghezza / diametro minore
|
||||
if ( TOOLS[nCurrIndex].dLength / pow( TOOLS[nCurrIndex].dDiameter, 1.5)) < ( TOOLS[ToolInfo.nToolIndex].dLength / pow( TOOLS[ToolInfo.nToolIndex].dDiameter, 1.5)) then
|
||||
ToolInfo.nToolIndex = nCurrIndex
|
||||
ToolInfo.dMaxMatReduction = dCurrMachReduction
|
||||
if ( TOOLS[i].dLength / pow( TOOLS[i].dDiameter, 1.5)) < ( TOOLS[nBestToolIndex].dLength / pow( TOOLS[nBestToolIndex].dDiameter, 1.5)) then
|
||||
nBestToolIndex = i
|
||||
dBestToolResidualDepth = dCurrentResidualDepth
|
||||
end
|
||||
-- se entrambi incompleti
|
||||
elseif ToolInfo.dMaxMatReduction < 0 and dCurrMachReduction < 0 then
|
||||
elseif dBestToolResidualDepth > 0 and dCurrentResidualDepth > 0 then
|
||||
--scelgo quello che lavora di più
|
||||
if dCurrMachReduction > ToolInfo.dMaxMatReduction then
|
||||
ToolInfo.nToolIndex = nCurrIndex
|
||||
ToolInfo.dMaxMatReduction = dCurrMachReduction
|
||||
if dCurrentResidualDepth > dBestToolResidualDepth then
|
||||
nBestToolIndex = i
|
||||
dBestToolResidualDepth = dCurrentResidualDepth
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
ToolInfo.nToolIndex = nBestToolIndex
|
||||
ToolInfo.dResidualDepth = dBestToolResidualDepth
|
||||
|
||||
return ToolInfo
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
-- funzione per cercare utensile tipo LAMA con certe caratteristiche
|
||||
-- TODO da fare
|
||||
function MachiningLib.FindBlade()
|
||||
-- TODO da completare
|
||||
function MachiningLib.FindBlade( Proc, ToolSearchParameters)
|
||||
local ToolInfo = {}
|
||||
|
||||
-- parametri obbligatori
|
||||
if type( ToolSearchParameters.vtToolDirection) ~= 'table' then
|
||||
error( 'FindBlade : missing tool direction')
|
||||
end
|
||||
if type( ToolSearchParameters.bAllowTopHead) ~= 'boolean' then
|
||||
error( 'FindBlade : missing top head info')
|
||||
end
|
||||
if type( ToolSearchParameters.bAllowBottomHead) ~= 'boolean' then
|
||||
error( 'FindBlade : missing bottom head info')
|
||||
end
|
||||
if not ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
|
||||
error( 'FindBlade : wrong head info')
|
||||
end
|
||||
|
||||
-- parametri opzionali
|
||||
ToolSearchParameters.dElevation = ToolSearchParameters.dElevation or 0
|
||||
ToolSearchParameters.bForceLongcutBlade = ToolSearchParameters.bForceLongcutBlade or false
|
||||
|
||||
local nBestToolIndex
|
||||
for i = 1, #TOOLS do
|
||||
local bIsToolCompatible = false
|
||||
|
||||
if TOOLS[i].sFamily == 'SAWBLADE' then
|
||||
if ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
|
||||
bIsToolCompatible = TOOLS[i].SetupInfo.bIsTopHead
|
||||
elseif ToolSearchParameters.bAllowBottomHead and not ToolSearchParameters.bAllowTopHead then
|
||||
bIsToolCompatible = TOOLS[i].SetupInfo.bIsBottomHead
|
||||
end
|
||||
end
|
||||
|
||||
if bIsToolCompatible then
|
||||
nBestToolIndex = i
|
||||
break
|
||||
end
|
||||
end
|
||||
|
||||
ToolInfo.nToolIndex = nBestToolIndex
|
||||
|
||||
return ToolInfo
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
@@ -133,9 +201,77 @@ function MachiningLib.FindDrill()
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
-- funzione per cercare utensile tipo PUNTA A FORARE con certe caratteristiche
|
||||
-- TODO da fare
|
||||
function MachiningLib.FindChainSaw()
|
||||
-- funzione per cercare utensile tipo SEGA A CATENA con certe caratteristiche
|
||||
-- TODO da completare
|
||||
function MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
|
||||
local ToolInfo = {}
|
||||
|
||||
-- parametri obbligatori
|
||||
if type( ToolSearchParameters.vtToolDirection) ~= 'table' then
|
||||
error( 'FindBlade : missing tool direction')
|
||||
end
|
||||
if type( ToolSearchParameters.bAllowTopHead) ~= 'boolean' then
|
||||
error( 'FindBlade : missing top head info')
|
||||
end
|
||||
if type( ToolSearchParameters.bAllowBottomHead) ~= 'boolean' then
|
||||
error( 'FindBlade : missing bottom head info')
|
||||
end
|
||||
if not ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
|
||||
error( 'FindBlade : wrong head info')
|
||||
end
|
||||
|
||||
-- parametri opzionali
|
||||
ToolSearchParameters.dElevation = ToolSearchParameters.dElevation or 0
|
||||
ToolSearchParameters.bExtendWithCornerRadius = ToolSearchParameters.bExtendWithCornerRadius or false
|
||||
|
||||
local nBestToolIndex
|
||||
local dBestToolResidualDepth = 0
|
||||
for i = 1, #TOOLS do
|
||||
local bIsToolCompatible = false
|
||||
|
||||
if TOOLS[i].sFamily == 'MORTISE' then
|
||||
if ToolSearchParameters.bAllowTopHead and not ToolSearchParameters.bAllowBottomHead then
|
||||
bIsToolCompatible = TOOLS[i].SetupInfo.bIsTopHead
|
||||
elseif ToolSearchParameters.bAllowBottomHead and not ToolSearchParameters.bAllowTopHead then
|
||||
bIsToolCompatible = TOOLS[i].SetupInfo.bIsBottomHead
|
||||
end
|
||||
end
|
||||
|
||||
-- TODO nei confronti tra valori gestire tolleranze
|
||||
if bIsToolCompatible then
|
||||
if ToolSearchParameters.dElevation > 10 * GEO.EPS_SMALL and ToolSearchParameters.bExtendWithCornerRadius then
|
||||
ToolSearchParameters.dElevation = ToolSearchParameters.dElevation + TOOLS[i].dCornerRadius
|
||||
end
|
||||
-- TODO gestire accorciamento massimo materiale per inclinazione
|
||||
local dCurrentResidualDepth = ToolSearchParameters.dElevation - TOOLS[i].dMaxDepth
|
||||
-- se non ancora trovato, oppure se completo e il migliore fino ad ora non è completo: corrente è il migliore
|
||||
if not nBestToolIndex or ( dBestToolResidualDepth > 0 and dCurrentResidualDepth <= 0) then
|
||||
nBestToolIndex = i
|
||||
dBestToolResidualDepth = dCurrentResidualDepth
|
||||
-- altrimenti scelgo il migliore
|
||||
else
|
||||
-- se entrambi completi
|
||||
if dBestToolResidualDepth <= 0 and dCurrentResidualDepth <= 0 then
|
||||
-- scelgo utensile con rapporto lunghezza / diametro minore
|
||||
if ( TOOLS[i].dLength / pow( TOOLS[i].dDiameter, 1.5)) < ( TOOLS[nBestToolIndex].dLength / pow( TOOLS[nBestToolIndex].dDiameter, 1.5)) then
|
||||
nBestToolIndex = i
|
||||
dBestToolResidualDepth = dCurrentResidualDepth
|
||||
end
|
||||
-- se entrambi incompleti
|
||||
elseif dBestToolResidualDepth > 0 and dCurrentResidualDepth > 0 then
|
||||
--scelgo quello che lavora di più
|
||||
if dCurrentResidualDepth > dBestToolResidualDepth then
|
||||
nBestToolIndex = i
|
||||
dBestToolResidualDepth = dCurrentResidualDepth
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
ToolInfo.nToolIndex = nBestToolIndex
|
||||
|
||||
return ToolInfo
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
|
||||
@@ -32,7 +32,7 @@ local function IsTopologyOk( Proc)
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
function STR0002.Make( AddMachining, Proc, Part, CustomParameters)
|
||||
function STR0002.Make( bAddMachining, Proc, Part, CustomParameters)
|
||||
-- carico parametri de default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
|
||||
local StrategyLib = {}
|
||||
StrategyLib.Config = require( 'STR0002\\STR0002Config')
|
||||
@@ -65,17 +65,17 @@ function STR0002.Make( AddMachining, Proc, Part, CustomParameters)
|
||||
ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
||||
|
||||
if ToolInfo.nToolIndex and TOOLS[ToolInfo.nToolIndex].sName then
|
||||
if ToolInfo.dMaxMatReduction < 0 then
|
||||
if ToolInfo.dResidualDepth > 0 then
|
||||
Strategy.RatingResult.sStatus = 'Not-Completed'
|
||||
else
|
||||
Strategy.RatingResult.sStatus = 'Completed'
|
||||
end
|
||||
Strategy.RatingResult.dCompletionIndex = min( 100, ( ( Proc.MainFaces.BottomFace.dElevation + ToolInfo.dMaxMatReduction) / Proc.MainFaces.BottomFace.dElevation) * 100)
|
||||
Strategy.RatingResult.dCompletionIndex = min( 100, ( ( Proc.MainFaces.BottomFace.dElevation - ToolInfo.dResidualDepth) / Proc.MainFaces.BottomFace.dElevation) * 100)
|
||||
Strategy.RatingResult.dRating = FeatureData.GetFeatureRating( 'Mill', Strategy.RatingResult.dCompletionIndex)
|
||||
Strategy.RatingResult.sInfo = ''
|
||||
|
||||
-- se richiesto applico lavorazione
|
||||
if AddMachining then
|
||||
if bAddMachining then
|
||||
-- TODO gestione spezzatura da completare
|
||||
-- le lunghezza richiede spezzatura
|
||||
if ( Proc.b3Box:getDimX() > BeamData.LONGCUT_MAXLEN) or ( Proc.b3Box:getDimX() > 0.7 * Part.b3Solid:getDimX() and Proc.b3Box:getDimX() > BeamData.LONGCUT_ENDLEN) then
|
||||
@@ -99,7 +99,7 @@ function STR0002.Make( AddMachining, Proc, Part, CustomParameters)
|
||||
local dNewRest = Proc.b3Box:getDimX()
|
||||
-- creo primo spezzone sulla sinistra
|
||||
if bStartLeft then
|
||||
local AddId = EgtCopyGlob( Proc.iod, nAddGrpId) or GDB_ID.NULL
|
||||
local AddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
|
||||
dNewMinX = max( ( Proc.b3Box:getMin():getX() + TOOLS[ToolInfo.nToolIndex].dDiameter * 2), Part.b3Solid:getMin():getX() + BeamData.LONGCUT_ENDLEN)
|
||||
local ptOn = Point3d( dNewMinX, 0, 0)
|
||||
dNewRest = abs( dNewMaxX - dNewMinX)
|
||||
|
||||
@@ -0,0 +1,771 @@
|
||||
-- Strategia: STR0003
|
||||
-- Descrizione
|
||||
-- Lama + motosega per slot
|
||||
-- Feature: tipo lapjoint
|
||||
|
||||
-- carico librerie
|
||||
local BeamLib = require( 'BeamLib')
|
||||
local BeamData = require( 'BeamData')
|
||||
local MachiningLib = require( 'MachiningLib')
|
||||
local FeatureData = require( 'FeatureData')
|
||||
|
||||
-- Tabella per definizione modulo
|
||||
local STR0003 = {}
|
||||
local Strategy = {}
|
||||
local Blade = {}
|
||||
local Chainsaw = {}
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
local function IsTopologyOk( Proc)
|
||||
if Proc.Topology.sName == 'Pocket-5-Blind' or
|
||||
Proc.Topology.sName == 'Groove-3-Through' or
|
||||
Proc.Topology.sName == 'Groove-4-Blind' or
|
||||
Proc.Topology.sName == 'Tunnel-4-Through' then
|
||||
|
||||
return true
|
||||
else
|
||||
return false
|
||||
end
|
||||
end
|
||||
|
||||
-- TODO da eliminare
|
||||
function GetToolFromMachining( sMachiningName)
|
||||
local Tool = {}
|
||||
if EgtMdbSetCurrMachining( sMachiningName) then
|
||||
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
||||
if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
|
||||
Tool.Name = EgtTdbGetCurrToolParam( MCH_TP.NAME)
|
||||
Tool.IsCCW = ( EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) < 0)
|
||||
Tool.Type = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
|
||||
Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0
|
||||
-- lama
|
||||
if Tool.Type == MCH_TY.SAW_STD or Tool.Type == MCH_TY.SAW_FLAT then
|
||||
Tool.Thickness = EgtTdbGetCurrToolParam(MCH_TP.THICK) or 0
|
||||
Tool.MaxDepth = EgtTdbGetCurrToolMaxDepth() or 0
|
||||
Tool.SideStep = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDESTEP', 'd')
|
||||
-- sega a catena
|
||||
elseif Tool.Type == MCH_TY.MORTISE_STD then
|
||||
Tool.Length = EgtTdbGetCurrToolParam( MCH_TP.LEN) or 0
|
||||
Tool.MaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or 0
|
||||
Tool.Width = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0
|
||||
Tool.Thickness = EgtTdbGetCurrToolParam( MCH_TP.THICK) or 0
|
||||
Tool.CornerRadius = EgtTdbGetCurrToolParam( MCH_TP.CORNRAD) or 0
|
||||
-- altri utensili al momento non previsti
|
||||
else
|
||||
error( 'Wrong tool type')
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return Tool
|
||||
end
|
||||
|
||||
|
||||
local function CalculateLeadInOut( Machining, EdgeToMachine)
|
||||
-- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom)
|
||||
|
||||
-- si determina l'eventuale riduzione da applicare in caso di inizio o fine chiusi
|
||||
local bIsMortising = ( Machining.nType == MCH_OY.MORTISING)
|
||||
local dAddLengthToReduce = 0
|
||||
if bIsMortising then
|
||||
dAddLengthToReduce = TOOLS[Machining.nToolIndex].dDiameter / 2
|
||||
else
|
||||
dAddLengthToReduce = sqrt( Machining.dDepthToMachine * TOOLS[Machining.nToolIndex].dDiameter - Machining.dDepthToMachine * Machining.dDepthToMachine)
|
||||
end
|
||||
|
||||
if Machining.bInvert then
|
||||
Machining.bIsStartClosed, Machining.bIsEndClosed = Machining.bIsEndClosed, Machining.bIsStartClosed
|
||||
end
|
||||
|
||||
local LeadIn = {}
|
||||
local LeadOut = {}
|
||||
LeadIn.dStartAddLength = 0
|
||||
LeadOut.dEndAddLength = 0
|
||||
if not bIsMortising then
|
||||
LeadIn.nType = MCH_MILL_LI.LINEAR
|
||||
LeadOut.nType = MCH_MILL_LI.LINEAR
|
||||
LeadIn.dTangentDistance = 0
|
||||
LeadOut.dTangentDistance = 0
|
||||
if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
|
||||
LeadIn.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC
|
||||
LeadOut.dPerpDistance = EdgeToMachine.dElevation + BeamData.CUT_SIC
|
||||
else
|
||||
LeadIn.dPerpDistance = BeamData.CUT_SIC
|
||||
LeadOut.dPerpDistance = BeamData.CUT_SIC
|
||||
end
|
||||
LeadIn.dElevation = 0
|
||||
LeadOut.dElevation = 0
|
||||
LeadIn.dCompLength = 0
|
||||
LeadOut.dCompLength = 0
|
||||
if Machining.bIsStartClosed and Machining.bIsEndClosed then
|
||||
LeadIn.dStartAddLength = -dAddLengthToReduce
|
||||
LeadOut.dEndAddLength = -dAddLengthToReduce
|
||||
elseif Machining.bIsStartClosed then
|
||||
LeadIn.dStartAddLength = -dAddLengthToReduce
|
||||
-- eventuale correzione per accorciamento maggiore di larghezza tasca
|
||||
LeadOut.dEndAddLength = max( -LeadIn.dStartAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
|
||||
elseif Machining.bIsEndClosed then
|
||||
LeadOut.dEndAddLength = -dAddLengthToReduce
|
||||
-- eventuale correzione per accorciamento maggiore di larghezza tasca
|
||||
LeadIn.dStartAddLength = max( -LeadOut.dEndAddLength - EdgeToMachine.dLength + 10 * BeamData.CUT_EXTRA, BeamData.CUT_EXTRA)
|
||||
else
|
||||
LeadIn.dStartAddLength = BeamData.CUT_EXTRA
|
||||
LeadOut.dEndAddLength = BeamData.CUT_EXTRA
|
||||
end
|
||||
else
|
||||
if Machining.bIsStartClosed then
|
||||
LeadIn.dStartAddLength = -dAddLengthToReduce
|
||||
else
|
||||
LeadIn.dStartAddLength = BeamData.CUT_EXTRA
|
||||
end
|
||||
if Machining.bIsEndClosed then
|
||||
LeadOut.dEndAddLength = -dAddLengthToReduce
|
||||
else
|
||||
LeadOut.dEndAddLength = BeamData.CUT_EXTRA
|
||||
end
|
||||
end
|
||||
|
||||
return LeadIn, LeadOut
|
||||
end
|
||||
|
||||
|
||||
local function AddNewMachining( Machining, b3Raw)
|
||||
local sErr = ''
|
||||
local nOperationId = EgtAddMachining( Machining.sOperationName, Machining.Nsame)
|
||||
if not nOperationId then
|
||||
sErr = 'Error adding machining ' .. Machining.sOperationName .. '-' .. Machining.sName
|
||||
EgtOutLog( sErr)
|
||||
return false, sErr
|
||||
end
|
||||
|
||||
-- impostazione parametri lavorazione
|
||||
local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
||||
EgtSetMachiningGeometry( Machining.Geometry)
|
||||
EgtSetMachiningParam( MCH_MP.FACEUSE, Machining.nFaceuse)
|
||||
EgtSetMachiningParam( MCH_MP.SCC, Machining.nSCC)
|
||||
EgtSetMachiningParam( MCH_MP.INVERT, Machining.bInvert)
|
||||
EgtSetMachiningParam( MCH_MP.WORKSIDE, Machining.nWorkside)
|
||||
EgtSetMachiningParam( MCH_MP.TOOLINVERT, Machining.bToolInvert)
|
||||
EgtSetMachiningParam( MCH_MP.OFFSR, Machining.dRadialOffset)
|
||||
EgtSetMachiningParam( MCH_MP.OFFSL, Machining.dLongitudinalOffset)
|
||||
if Machining.Type ~= MCH_OY.MORTISING then
|
||||
EgtSetMachiningParam( MCH_MP.LEADINTYPE, Machining.LeadIn.nType)
|
||||
EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, Machining.LeadOut.nType)
|
||||
EgtSetMachiningParam( MCH_MP.LITANG, Machining.LeadIn.dTangentDistance)
|
||||
EgtSetMachiningParam( MCH_MP.LOTANG, Machining.LeadOut.dTangentDistance)
|
||||
EgtSetMachiningParam( MCH_MP.LIPERP, Machining.LeadIn.dPerpDistance)
|
||||
EgtSetMachiningParam( MCH_MP.LOPERP, Machining.LeadOut.dPerpDistance)
|
||||
EgtSetMachiningParam( MCH_MP.LIELEV, Machining.LeadIn.dElevation)
|
||||
EgtSetMachiningParam( MCH_MP.LOELEV, Machining.LeadOut.dElevation)
|
||||
EgtSetMachiningParam( MCH_MP.LICOMPLEN, Machining.LeadIn.dCompLength)
|
||||
EgtSetMachiningParam( MCH_MP.LOCOMPLEN, Machining.LeadOut.dCompLength)
|
||||
end
|
||||
EgtSetMachiningParam( MCH_MP.STARTADDLEN, Machining.LeadIn.dStartAddLength)
|
||||
EgtSetMachiningParam( MCH_MP.ENDADDLEN, Machining.LeadOut.dEndAddLength)
|
||||
if Machining.Steps then
|
||||
if Machining.Steps.nStepType then
|
||||
EgtSetMachiningParam( MCH_MP.STEPTYPE, Machining.Steps.nStepType)
|
||||
end
|
||||
if Machining.Steps.dStepLength then
|
||||
EgtSetMachiningParam( MCH_MP.STEP, Machining.Steps.dStepLength)
|
||||
end
|
||||
end
|
||||
EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BeamLib.GetBlockedAxis( Machining.sName, Machining.BlockedAxis.sOrientation, b3Raw, Machining.BlockedAxis.vtN, Machining.BlockedAxis.vtOut))
|
||||
if Machining.nType == MCH_OY.MORTISING then
|
||||
EgtSetMachiningParam( MCH_MP.INITANGS, BeamLib.GetChainSawInitAngs( Machining.SuggestedAngles.vtN, Machining.SuggestedAngles.vtOrtho, Machining.SuggestedAngles.nIndex))
|
||||
end
|
||||
EgtSetMachiningParam( MCH_MP.OVERL, Machining.dOverlap)
|
||||
EgtSetMachiningParam( MCH_MP.STARTPOS, max( Machining.dStartSafetyLength, EgtGetMachiningParam( MCH_MP.STARTPOS)))
|
||||
if Machining.dMaxElev then
|
||||
sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', Machining.dMaxElev)
|
||||
end
|
||||
EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes)
|
||||
|
||||
local bIsApplyOk = MachiningLib.ApplyMachining( true, false)
|
||||
if not bIsApplyOk then
|
||||
local nErr
|
||||
nErr, sErr = EgtGetLastMachMgrError()
|
||||
-- se mortasatura e l'errore è compatibile (Axes values not calculable) si prova con l'altra configurazione dell'asse bloccato
|
||||
-- TODO valutare se c'è modo di capire preventivamente la configurazione dell'asse bloccato e quindi rimuovere questa parte di codice
|
||||
if Machining.nType == MCH_OY.MORTISING and nErr == 2507 then
|
||||
if Machining.BlockedAxis.sOrientation == 'perpendicular' then
|
||||
Machining.BlockedAxis.sOrientation = 'parallel'
|
||||
else
|
||||
Machining.BlockedAxis.sOrientation = 'perpendicular'
|
||||
end
|
||||
EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BeamLib.GetBlockedAxis( Machining.sName, Machining.BlockedAxis.sOrientation, b3Raw, Machining.BlockedAxis.vtN, Machining.BlockedAxis.vtOut))
|
||||
if Machining.SuggestedAngles.nIndex == 1 then
|
||||
Machining.SuggestedAngles.nIndex = 2
|
||||
else
|
||||
Machining.SuggestedAngles.nIndex = 1
|
||||
end
|
||||
EgtSetMachiningParam( MCH_MP.INITANGS, BeamLib.GetChainSawInitAngs( Machining.SuggestedAngles.vtN, Machining.SuggestedAngles.vtOrtho, Machining.SuggestedAngles.nIndex))
|
||||
sErr = ''
|
||||
bIsApplyOk = EgtApplyMachining( true, false)
|
||||
end
|
||||
if not bIsApplyOk then
|
||||
nErr, sErr = EgtGetLastMachMgrError()
|
||||
EgtSetOperationMode( nOperationId, false)
|
||||
return false, sErr
|
||||
end
|
||||
end
|
||||
|
||||
return true, sErr
|
||||
end
|
||||
|
||||
|
||||
function Blade.GetSCC( vtMachiningDirection)
|
||||
-- TODO implementare SCC come per FacesBySaw
|
||||
local nSCC = MCH_SCC.NONE
|
||||
if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then
|
||||
nSCC = MCH_SCC.ADIR_ZP
|
||||
elseif AreOppositeVectorApprox( vtMachiningDirection, Z_AX()) then
|
||||
nSCC = MCH_SCC.ADIR_ZM
|
||||
elseif AreSameVectorApprox( vtMachiningDirection, Y_AX()) then
|
||||
nSCC = MCH_SCC.ADIR_YP
|
||||
elseif AreOppositeVectorApprox( vtMachiningDirection, Y_AX()) then
|
||||
nSCC = MCH_SCC.ADIR_YM
|
||||
elseif AreSameVectorApprox( vtMachiningDirection, X_AX()) then
|
||||
nSCC = MCH_SCC.ADIR_XP
|
||||
elseif AreOppositeVectorApprox( vtMachiningDirection, X_AX()) then
|
||||
nSCC = MCH_SCC.ADIR_XM
|
||||
end
|
||||
|
||||
return nSCC
|
||||
end
|
||||
|
||||
|
||||
function Blade.CalculateMachiningParameters( Proc, FaceToMachine, EdgeToMachine)
|
||||
local Cutting = {}
|
||||
Cutting.bCanApply = true
|
||||
Cutting.sMessage = ''
|
||||
Cutting.idProc = Proc.id
|
||||
local dResidualDepth = 0
|
||||
|
||||
local dPocketHeight = 0
|
||||
if Proc.Topology.sFamily == 'Tunnel' then
|
||||
dPocketHeight = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.dHeight
|
||||
else
|
||||
if FaceToMachine.Type == 'Long' then
|
||||
dPocketHeight = Proc.MainFaces.BottomFace.MainEdges.SideEdges[1].dLength
|
||||
elseif FaceToMachine.Type == 'Side' then
|
||||
dPocketHeight = Proc.MainFaces.BottomFace.MainEdges.LongEdges[1].dLength
|
||||
end
|
||||
end
|
||||
|
||||
-- ricerca utensile
|
||||
local ToolSearchParameters = {}
|
||||
ToolSearchParameters.dElevation = abs( EdgeToMachine.dElevation)
|
||||
ToolSearchParameters.vtToolDirection = EdgeToMachine.vtToolDirection
|
||||
ToolSearchParameters.bAllowTopHead = true
|
||||
ToolSearchParameters.bAllowBottomHead = false
|
||||
ToolSearchParameters.bForceLongcutBlade = Strategy.Parameters.bForceLongcutBlade
|
||||
local ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
|
||||
Cutting.nToolIndex = ToolInfo.nToolIndex
|
||||
Cutting.nType = MCH_OY.MILLING
|
||||
if not TOOLS[Cutting.nToolIndex].sName then
|
||||
Cutting.sMessage = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - saw blade not found'
|
||||
Cutting.bCanApply = false
|
||||
EgtOutLog( Cutting.sMessage)
|
||||
return Cutting, EdgeToMachine.dElevation
|
||||
end
|
||||
|
||||
-- verifica dimensioni tasca compatibili
|
||||
-- se tasca meno spessa della lama la strategia non è applicabile
|
||||
if TOOLS[Cutting.nToolIndex].dThickness > dPocketHeight + 10 * GEO.EPS_SMALL then
|
||||
Cutting.sMessage = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - pocket too narrow for saw blade thickness'
|
||||
Cutting.bCanApply = false
|
||||
EgtOutLog( Cutting.sMessage)
|
||||
return Cutting, EdgeToMachine.dElevation
|
||||
end
|
||||
if #( Proc.MainFaces.SideFaces) > 1 then
|
||||
-- se tasca più stretta della lama la strategia non è applicabile
|
||||
if TOOLS[Cutting.nToolIndex].dDiameter > EdgeToMachine.dLength + 10 * GEO.EPS_SMALL then
|
||||
Cutting.sMessage = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - pocket too narrow for saw blade diameter'
|
||||
Cutting.bCanApply = false
|
||||
EgtOutLog( Cutting.sMessage)
|
||||
return Cutting, EdgeToMachine.dElevation
|
||||
end
|
||||
end
|
||||
|
||||
-- parametri della lavorazione
|
||||
-- inizio e fine aperti o chiusi
|
||||
Cutting.bIsStartClosed = not EdgeToMachine.bIsStartOpen
|
||||
Cutting.bIsEndClosed = not EdgeToMachine.bIsEndOpen
|
||||
-- lato di lavoro e inversioni
|
||||
if TOOLS[Cutting.nToolIndex].bIsCCW then
|
||||
Cutting.nWorkside = MCH_MILL_WS.RIGHT
|
||||
Cutting.bInvert = true
|
||||
else
|
||||
Cutting.nWorkside = MCH_MILL_WS.LEFT
|
||||
Cutting.bInvert = false
|
||||
end
|
||||
if EdgeToMachine.dElevation < -10 * GEO.EPS_SMALL then
|
||||
Cutting.bInvert = not Cutting.bInvert
|
||||
end
|
||||
-- TODO gestire lama da sotto e lama downUp
|
||||
if FaceToMachine.vtN:getZ() < - 10 * GEO.EPS_SMALL then
|
||||
Cutting.bToolInvert = true
|
||||
Cutting.bInvert = not Cutting.bInvert
|
||||
else
|
||||
Cutting.bToolInvert = false
|
||||
end
|
||||
-- profondità e offset radiale
|
||||
if TOOLS[Cutting.nToolIndex].dMaxDepth > abs( EdgeToMachine.dElevation) - 10 * GEO.EPS_SMALL then
|
||||
-- TODO la depth dovrebbe essere quella del machining
|
||||
Cutting.dDepthToMachine = abs( EdgeToMachine.dElevation)
|
||||
if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
|
||||
Cutting.dRadialOffset = 0
|
||||
else
|
||||
Cutting.dRadialOffset = EdgeToMachine.dElevation
|
||||
end
|
||||
else
|
||||
Cutting.dDepthToMachine = TOOLS[Cutting.nToolIndex].dMaxDepth - 1
|
||||
dResidualDepth = EdgeToMachine.dElevation - Cutting.dDepthToMachine
|
||||
if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
|
||||
Cutting.dRadialOffset = EdgeToMachine.dElevation - Cutting.dDepthToMachine
|
||||
else
|
||||
Cutting.dRadialOffset = -Cutting.dDepthToMachine
|
||||
end
|
||||
if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL and Strategy.Parameters.bApplyOnlyBlade then
|
||||
Cutting.sMessage = 'Feature '.. Proc.idFeature .. ' : sawblade elevation (' .. EgtNumToString( EdgeToMachine.dElevation, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Cutting.dDepthToMachine, 1) .. ')'
|
||||
EgtOutLog( Cutting.sMessage)
|
||||
end
|
||||
end
|
||||
-- step verticale e offset longitudinale
|
||||
Cutting.Steps = MachiningLib.GetMachiningSteps( dPocketHeight, TOOLS[Cutting.nToolIndex].dThickness)
|
||||
Cutting.Steps.StepType = MCH_MILL_ST.ONEWAY
|
||||
Cutting.dMaxElev = Cutting.Steps.dStepLength * Cutting.Steps.nCount - 10 * GEO.EPS_SMALL
|
||||
if Cutting.bToolInvert and Cutting.Steps.nCount > 1 then
|
||||
Cutting.dLongitudinalOffset = - dPocketHeight
|
||||
else
|
||||
Cutting.dLongitudinalOffset = 0
|
||||
end
|
||||
-- distanza di sicurezza
|
||||
Cutting.dStartSafetyLength = 10
|
||||
-- overlap
|
||||
Cutting.dOverlap = 0
|
||||
-- faceuse
|
||||
if EdgeToMachine.dElevation > - 10 * GEO.EPS_SMALL then
|
||||
Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( EdgeToMachine.vtToolDirection)
|
||||
else
|
||||
Cutting.nFaceuse = BeamLib.GetNearestOrthoOpposite( -EdgeToMachine.vtToolDirection)
|
||||
end
|
||||
-- SCC
|
||||
Cutting.nSCC = Blade.GetSCC( EdgeToMachine.vtToolDirection)
|
||||
-- asse bloccato
|
||||
Cutting.BlockedAxis = {}
|
||||
Cutting.BlockedAxis.sOrientation = 'perpendicular'
|
||||
Cutting.BlockedAxis.vtN = FaceToMachine.vtN
|
||||
Cutting.BlockedAxis.vtOut = EgtIf( FaceToMachine.vtN:getX() > 0, X_AX(), -X_AX())
|
||||
-- approccio e retrazione
|
||||
Cutting.LeadIn, Cutting.LeadOut = CalculateLeadInOut( Cutting, EdgeToMachine)
|
||||
-- eventuale step orizzontale
|
||||
Cutting.HorizontalSteps = {}
|
||||
if TOOLS[Cutting.nToolIndex].dSideStep then
|
||||
Cutting.HorizontalSteps = MachiningLib.GetMachiningSteps( Cutting.dDepthToMachine, TOOLS[Cutting.nToolIndex].dSideStep)
|
||||
else
|
||||
Cutting.HorizontalSteps.nCount = 1
|
||||
Cutting.HorizontalSteps.dStepLength = 0
|
||||
end
|
||||
-- geometria
|
||||
Cutting.Geometry = {{Proc.id, FaceToMachine.id}}
|
||||
-- nome operazione
|
||||
Cutting.sOperationName = 'Cut_' .. ( EgtGetName( Cutting.idProc) or tostring( Cutting.idProc)) .. '_' .. tostring( FaceToMachine.id + 1)
|
||||
|
||||
-- eventuale avviso di danneggiamento pezzo successivo
|
||||
-- TODO da sostituire con check se si riesce a separare e il grezzo dietro è lungo a sufficienza
|
||||
local dOffsideLength = max( Cutting.LeadIn.dStartAddLength, Cutting.LeadOut.dEndAddLength) + TOOLS[Cutting.nToolIndex].dDiameter / 2 + 10 * GEO.EPS_SMALL
|
||||
if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.DistanceToNextPart < dOffsideLength) then
|
||||
local sDamageNextPieceMessage = 'Feature '.. Proc.idFeature .. ' : sawblade can damage next piece.'
|
||||
if #Cutting.sMessage > 0 then
|
||||
Cutting.sMessage = Cutting.sMessage .. '\n' .. sDamageNextPieceMessage
|
||||
else
|
||||
Cutting.sMessage = sDamageNextPieceMessage
|
||||
end
|
||||
EgtOutLog( sDamageNextPieceMessage)
|
||||
end
|
||||
|
||||
return Cutting, dResidualDepth
|
||||
end
|
||||
|
||||
|
||||
function Blade.AddMachiningAllSteps( Cutting, b3Raw)
|
||||
local bIsCuttingOk = false
|
||||
local sCuttingApplyMessage = ''
|
||||
|
||||
local dOriginalRadialOffset = Cutting.dRadialOffset
|
||||
local dOriginalLeadInPerpDistance = Cutting.LeadIn.dPerpDistance
|
||||
local dOriginalLeadOutPerpDistance = Cutting.LeadOut.dPerpDistance
|
||||
for i = Cutting.HorizontalSteps.nCount, 1, -1 do
|
||||
Cutting.dRadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.dStepLength * ( i - 1)
|
||||
-- update distanza perpendicolare attacco per contemplare l'offset applicato
|
||||
Cutting.LeadIn.dPerpDistance = dOriginalLeadInPerpDistance - Cutting.dRadialOffset
|
||||
Cutting.LeadOut.dPerpDistance = dOriginalLeadOutPerpDistance - Cutting.dRadialOffset
|
||||
-- applicazione lavorazione
|
||||
bIsCuttingOk, sCuttingApplyMessage = AddNewMachining( Cutting, b3Raw)
|
||||
-- update messaggi
|
||||
if sCuttingApplyMessage and #sCuttingApplyMessage > 0 then
|
||||
sCuttingApplyMessage = sCuttingApplyMessage .. 'Apply : ' .. sCuttingApplyMessage .. '\n'
|
||||
end
|
||||
end
|
||||
|
||||
return bIsCuttingOk, sCuttingApplyMessage
|
||||
end
|
||||
|
||||
|
||||
function Chainsaw.CalculateMachiningParameters( Proc, FaceToMachine, EdgeToMachine)
|
||||
local Mortising = {}
|
||||
Mortising.bCanApply = true
|
||||
Mortising.sMessage = ''
|
||||
Mortising.idProc = Proc.id
|
||||
-- OneSide | OneSideAndExtend | BothSides | BothSidesAndExtend
|
||||
local sMortisingType
|
||||
local dResidualDepth = 0
|
||||
|
||||
local dPocketHeight = 0
|
||||
if Proc.Topology.sFamily == 'Tunnel' then
|
||||
dPocketHeight = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.dHeight
|
||||
else
|
||||
if FaceToMachine.Type == 'Long' then
|
||||
dPocketHeight = Proc.MainFaces.BottomFace.MainEdges.SideEdges[1].dLength
|
||||
elseif FaceToMachine.Type == 'Side' then
|
||||
dPocketHeight = Proc.MainFaces.BottomFace.MainEdges.LongEdges[1].dLength
|
||||
end
|
||||
end
|
||||
|
||||
-- ricerca utensile
|
||||
local ToolSearchParameters = {}
|
||||
local ToolInfo = {}
|
||||
ToolSearchParameters.vtToolDirection = EdgeToMachine.vtToolDirection
|
||||
ToolSearchParameters.bAllowTopHead = true
|
||||
ToolSearchParameters.bAllowBottomHead = false
|
||||
if Proc.Topology.sFamily == 'Tunnel' then
|
||||
sMortisingType = 'OneSideAndExtend'
|
||||
ToolSearchParameters.bExtendWithCornerRadius = true
|
||||
ToolSearchParameters.dElevation = abs( EdgeToMachine.dElevation) + BeamData.CUT_EXTRA
|
||||
ToolInfo = MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
|
||||
if ToolInfo.dResidualDepth > 10 * GEO.EPS_SMALL then
|
||||
sMortisingType = 'BothSidesAndExtend'
|
||||
ToolSearchParameters.dElevation = abs( EdgeToMachine.dElevation) / 2 + BeamData.CUT_EXTRA_MIN
|
||||
ToolInfo = MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
|
||||
end
|
||||
elseif EdgeToMachine.sType == 'Side' and #( Proc.MainFaces.SideFaces) == 0 then
|
||||
sMortisingType = 'BothSidesAndExtend'
|
||||
ToolSearchParameters.bExtendWithCornerRadius = true
|
||||
ToolSearchParameters.dElevation = abs( EdgeToMachine.dElevation) / 2 + BeamData.CUT_EXTRA_MIN
|
||||
ToolInfo = MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
|
||||
else
|
||||
sMortisingType = 'OneSide'
|
||||
ToolSearchParameters.bExtendWithCornerRadius = false
|
||||
ToolSearchParameters.dElevation = abs( EdgeToMachine.dElevation) + BeamData.CUT_EXTRA
|
||||
ToolInfo = MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
|
||||
end
|
||||
if ToolInfo.dResidualDepth > 10 * GEO.EPS_SMALL then
|
||||
if sMortisingType == 'BothSidesAndExtend' then
|
||||
sMortisingType = 'BothSides'
|
||||
elseif sMortisingType == 'OneSideAndExtend' then
|
||||
sMortisingType = 'OneSide'
|
||||
end
|
||||
ToolSearchParameters.bExtendWithCornerRadius = false
|
||||
ToolSearchParameters.dElevation = nil
|
||||
ToolInfo = MachiningLib.FindChainSaw( Proc, ToolSearchParameters)
|
||||
end
|
||||
Mortising.nToolIndex = ToolInfo.nToolIndex
|
||||
Mortising.nType = MCH_OY.MORTISING
|
||||
if not TOOLS[Mortising.nToolIndex].sName then
|
||||
Mortising.sMessage = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - chainsaw not found'
|
||||
Mortising.bCanApply = false
|
||||
EgtOutLog( Mortising.sMessage)
|
||||
return Mortising, EdgeToMachine.dElevation
|
||||
end
|
||||
|
||||
-- verifica dimensioni tasca compatibili
|
||||
-- se tasca meno spessa della sega a catena la strategia non è applicabile
|
||||
if TOOLS[Mortising.nToolIndex].dThickness > dPocketHeight + 10 * GEO.EPS_SMALL then
|
||||
Mortising.sMessage = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - pocket too narrow for chainsaw thickness'
|
||||
Mortising.bCanApply = false
|
||||
EgtOutLog( Mortising.sMessage)
|
||||
return Mortising, EdgeToMachine.dElevation
|
||||
end
|
||||
if #( Proc.MainFaces.SideFaces) > 1 then
|
||||
-- se tasca più stretta della sega a catena la strategia non è applicabile
|
||||
if TOOLS[Mortising.nToolIndex].dWidth > EdgeToMachine.dLength + 10 * GEO.EPS_SMALL then
|
||||
Mortising.sMessage = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - pocket too narrow for chainsaw width'
|
||||
Mortising.bCanApply = false
|
||||
EgtOutLog( Mortising.sMessage)
|
||||
return Mortising, EdgeToMachine.dElevation
|
||||
end
|
||||
end
|
||||
|
||||
-- parametri della lavorazione
|
||||
-- inizio e fine aperti o chiusi
|
||||
Mortising.bIsStartClosed = not EdgeToMachine.bIsStartOpen
|
||||
Mortising.bIsEndClosed = not EdgeToMachine.bIsEndOpen
|
||||
-- lato di lavoro e inversioni
|
||||
Mortising.bInvert = false
|
||||
if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
|
||||
Mortising.nWorkside = MCH_MILL_WS.RIGHT
|
||||
Mortising.bToolInvert = false
|
||||
else
|
||||
Mortising.nWorkside = MCH_MILL_WS.LEFT
|
||||
Mortising.bToolInvert = true
|
||||
end
|
||||
-- profondità e offset longitudinale
|
||||
if sMortisingType == 'OneSide' then
|
||||
Mortising.dDepthToMachine = abs( EdgeToMachine.dElevation)
|
||||
elseif sMortisingType == 'OneSideAndExtend' then
|
||||
Mortising.dDepthToMachine = abs( EdgeToMachine.dElevation) + TOOLS[Mortising.nToolIndex].dCornerRadius + BeamData.CUT_EXTRA_MIN
|
||||
elseif sMortisingType == 'BothSides' then
|
||||
Mortising.dDepthToMachine = abs( EdgeToMachine.dElevation) / 2
|
||||
elseif sMortisingType == 'BothSidesAndExtend' then
|
||||
Mortising.dDepthToMachine = abs( EdgeToMachine.dElevation) / 2 + TOOLS[Mortising.nToolIndex].dCornerRadius + BeamData.CUT_EXTRA_MIN
|
||||
end
|
||||
if TOOLS[Mortising.nToolIndex].dMaxMat > Mortising.dDepthToMachine - 10 * GEO.EPS_SMALL then
|
||||
if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
|
||||
Mortising.dLongitudinalOffset = 0
|
||||
else
|
||||
Mortising.dLongitudinalOffset = abs( EdgeToMachine.dElevation) - Mortising.dDepthToMachine
|
||||
end
|
||||
else
|
||||
Mortising.dDepthToMachine = TOOLS[Mortising.nToolIndex].dMaxMat - 1
|
||||
dResidualDepth = EdgeToMachine.dElevation - Mortising.dDepthToMachine
|
||||
if EdgeToMachine.dElevation > -10 * GEO.EPS_SMALL then
|
||||
Mortising.dLongitudinalOffset = EdgeToMachine.dElevation - Mortising.dDepthToMachine
|
||||
else
|
||||
Mortising.dLongitudinalOffset = 0
|
||||
end
|
||||
Mortising.sMessage = 'Feature '.. Proc.idFeature .. ' : chainsaw elevation (' .. EgtNumToString( EdgeToMachine.dElevation, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Mortising.dDepthToMachine, 1) .. ')'
|
||||
EgtOutLog( Mortising.sMessage)
|
||||
end
|
||||
-- offset radiale
|
||||
Mortising.dRadialOffset = 0
|
||||
-- distanza di sicurezza
|
||||
Mortising.dStartSafetyLength = EdgeToMachine.dElevation
|
||||
-- overlap
|
||||
Mortising.dOverlap = 0
|
||||
-- faceuse
|
||||
if EdgeToMachine.dElevation > - 10 * GEO.EPS_SMALL then
|
||||
Mortising.nFaceuse = BeamLib.GetNearestParalOpposite( EdgeToMachine.vtToolDirection)
|
||||
else
|
||||
Mortising.nFaceuse = BeamLib.GetNearestParalOpposite( -EdgeToMachine.vtToolDirection)
|
||||
end
|
||||
-- SCC
|
||||
Mortising.SCC = MCH_SCC.NONE
|
||||
-- asse bloccato e angoli suggeriti
|
||||
Mortising.BlockedAxis = {}
|
||||
Mortising.BlockedAxis.sOrientation = 'perpendicular'
|
||||
Mortising.BlockedAxis.vtN = FaceToMachine.vtN
|
||||
Mortising.SuggestedAngles = {}
|
||||
Mortising.SuggestedAngles.nIndex = 1
|
||||
Mortising.SuggestedAngles.vtN = FaceToMachine.vtN
|
||||
Mortising.SuggestedAngles.vtOrthO = EdgeToMachine.vtToolDirection
|
||||
-- approccio e retrazione
|
||||
Mortising.LeadIn, Mortising.LeadOut = CalculateLeadInOut( Mortising, EdgeToMachine)
|
||||
-- eventuale step verticale
|
||||
Mortising.VerticalSteps = MachiningLib.GetMachiningSteps( dPocketHeight, TOOLS[Mortising.nToolIndex].dThickness)
|
||||
-- geometria
|
||||
Mortising.Geometry = {{Proc.id, FaceToMachine.id}}
|
||||
-- nome operazione
|
||||
Mortising.sOperationName = 'Chainsaw_' .. ( EgtGetName( Mortising.idProc) or tostring( Mortising.idProc)) .. '_' .. tostring( FaceToMachine.id + 1)
|
||||
|
||||
-- eventuale avviso di danneggiamento pezzo successivo
|
||||
local dOffsideLength = max( Mortising.LeadIn.dStartAddLength, Mortising.LeadOut.dEndAddLength) + TOOLS[Mortising.nToolIndex].dWidth / 2 + 10 * GEO.EPS_SMALL
|
||||
if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.DistanceToNextPart < dOffsideLength) then
|
||||
local sDamageNextPieceMessage = 'Feature '.. Proc.idFeature .. ' : chainsaw can damage next piece.'
|
||||
if #Mortising.sMessage > 0 then
|
||||
Mortising.sMessage = Mortising.sMessage .. '\n' .. sDamageNextPieceMessage
|
||||
else
|
||||
Mortising.sMessage = sDamageNextPieceMessage
|
||||
end
|
||||
EgtOutLog( sDamageNextPieceMessage)
|
||||
end
|
||||
|
||||
return Mortising, dResidualDepth
|
||||
end
|
||||
|
||||
|
||||
function Chainsaw.AddMachiningAllSteps( Mortising, b3Raw)
|
||||
local bIsMortisingOk = false
|
||||
local sMortisingApplyMessage = ''
|
||||
|
||||
local dOriginalRadialOffsetMortising = Mortising.dRadialOffset
|
||||
for i = Mortising.VerticalSteps.nCount, 1, -1 do
|
||||
Mortising.dRadialOffset = dOriginalRadialOffsetMortising + Mortising.VerticalSteps.dStepLength * ( i - 1)
|
||||
-- applicazione lavorazione
|
||||
bIsMortisingOk, sMortisingApplyMessage = AddNewMachining( Mortising, b3Raw)
|
||||
-- update messaggi
|
||||
if sMortisingApplyMessage and #sMortisingApplyMessage > 0 then
|
||||
Mortising.sMessage = Mortising.sMessage .. '\n' .. 'Apply : ' .. sMortisingApplyMessage
|
||||
end
|
||||
end
|
||||
|
||||
return bIsMortisingOk, sMortisingApplyMessage
|
||||
end
|
||||
|
||||
|
||||
function STR0003.Make( bAddMachining, Proc, Part, CustomParameters)
|
||||
-- TODO da implementare gestione feature lunghe e spezzatura
|
||||
-- carico parametri da default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
|
||||
local StrategyLib = {}
|
||||
StrategyLib.Config = require( 'STR0003\\STR0003Config')
|
||||
Strategy.sName = StrategyLib.Config.sStrategyId
|
||||
CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
|
||||
Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
|
||||
Strategy.Result = {}
|
||||
Blade.Result = {}
|
||||
Chainsaw.Result = {}
|
||||
|
||||
local b3Raw = EgtGetRawPartBBox( Part.idRaw)
|
||||
local dResidualDepth = 0
|
||||
|
||||
if not IsTopologyOk( Proc) then
|
||||
local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not implemented'
|
||||
EgtOutLog( sErr)
|
||||
return false, sErr
|
||||
end
|
||||
|
||||
-- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto)
|
||||
-- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto
|
||||
if Proc.AffectedFaces.Bottom and ( Proc.Fct > 3 or not Proc.AffectedFaces.Top) then
|
||||
local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. Strategy.sName .. ' not applicable - pocket on bottom face'
|
||||
EgtOutLog( sErr)
|
||||
return false, sErr
|
||||
end
|
||||
|
||||
-- lama
|
||||
-- lavorazione di lama - fondo della tasca o fino a massimo materiale se tunnel
|
||||
table.insert( Blade.Result, {})
|
||||
local Cutting = {}
|
||||
if Proc.Topology.sFamily == 'Tunnel' then
|
||||
Cutting, dResidualDepth = Blade.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1])
|
||||
Blade.Result[#Blade.Result].sType = 'Tunnel'
|
||||
else
|
||||
Cutting, dResidualDepth = Blade.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge)
|
||||
Blade.Result[#Blade.Result].sType = 'Bottom'
|
||||
end
|
||||
Blade.Result[#Blade.Result].bCanApply = Cutting.bCanApply
|
||||
Blade.Result[#Blade.Result].sMessage = Cutting.sMessage
|
||||
if bAddMachining and Cutting.bCanApply then
|
||||
Blade.Result[#Blade.Result].bIsApplyOk, Blade.Result[#Blade.Result].sApplyMessage = Blade.AddMachiningAllSteps( Cutting, b3Raw)
|
||||
end
|
||||
local dBottomDepthToMachine = dResidualDepth
|
||||
-- lato opposto del tunnel
|
||||
if Proc.Topology.sFamily == 'Tunnel' then
|
||||
table.insert( Blade.Result, {})
|
||||
Cutting = Blade.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2])
|
||||
Blade.Result[#Blade.Result].sType = 'Tunnel'
|
||||
Blade.Result[#Blade.Result].bCanApply = Cutting.bCanApply
|
||||
Blade.Result[#Blade.Result].sMessage = Cutting.sMessage
|
||||
if bAddMachining and Cutting.bCanApply then
|
||||
Blade.Result[#Blade.Result].bIsApplyOk, Blade.Result[#Blade.Result].sApplyMessage = Blade.AddMachiningAllSteps( Cutting, b3Raw)
|
||||
end
|
||||
else
|
||||
-- se la lama non è arrivata sul fondo e c'è almeno un lato aperto va lavorato
|
||||
if dResidualDepth > 10 * GEO.EPS_SMALL then
|
||||
table.insert( Blade.Result, {})
|
||||
-- eventuale lavorazione di lama - lato della tasca da cui inizia la lavorazione
|
||||
if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.IsStartOpen then
|
||||
Cutting = Blade.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1])
|
||||
Blade.Result[#Blade.Result].sType = 'Side'
|
||||
Blade.Result[#Blade.Result].bCanApply = Cutting.bCanApply
|
||||
Blade.Result[#Blade.Result].sMessage = Cutting.sMessage
|
||||
if bAddMachining and Cutting.bCanApply then
|
||||
Blade.Result[#Blade.Result].bIsApplyOk, Blade.Result[#Blade.Result].sApplyMessage = Blade.AddMachiningAllSteps( Cutting, b3Raw)
|
||||
end
|
||||
end
|
||||
-- eventuale lavorazione di lama - lato della tasca in cui finisce la lavorazione
|
||||
if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.IsEndOpen then
|
||||
Cutting = Blade.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces, Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[2])
|
||||
Blade.Result[#Blade.Result].sType = 'Side'
|
||||
Blade.Result[#Blade.Result].bCanApply = Cutting.bCanApply
|
||||
Blade.Result[#Blade.Result].sMessage = Cutting.sMessage
|
||||
if bAddMachining and Cutting.bCanApply then
|
||||
Blade.Result[#Blade.Result].bIsApplyOk, Blade.Result[#Blade.Result].sApplyMessage = Blade.AddMachiningAllSteps( Cutting, b3Raw)
|
||||
end
|
||||
end
|
||||
-- la lama è arrivata sul fondo e tasca passante, non servono ulteriori lavorazioni
|
||||
elseif #( Proc.MainFaces.SideFaces) == 0 then
|
||||
Strategy.Parameters.bApplyOnlyBlade = true
|
||||
end
|
||||
end
|
||||
|
||||
if Strategy.Parameters.bApplyOnlyBlade then
|
||||
-- TODO da rivedere
|
||||
Strategy.Result.sInfo = Cutting.Message
|
||||
Strategy.Result.bIsApplyOk = true
|
||||
if dResidualDepth > 10 * GEO.EPS_SMALL then
|
||||
Strategy.Result.sStatus = 'Not-Completed'
|
||||
else
|
||||
Strategy.Result.sStatus = 'Completed'
|
||||
end
|
||||
return Strategy.Result
|
||||
end
|
||||
|
||||
-- sega a catena
|
||||
-- parametri lavorazione con sega a catena - fondo della tasca o tunnel
|
||||
local Mortising = {}
|
||||
local dResidualDepth = 0
|
||||
if Proc.Topology == 'Tunnel' then
|
||||
Mortising, dResidualDepth = Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1])
|
||||
else
|
||||
Mortising = Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge)
|
||||
-- si lavora solo quanto non lavorato dalla lama
|
||||
Mortising.MaxElev = dBottomDepthToMachine + BeamData.CUT_EXTRA
|
||||
end
|
||||
local bIsMortisingOk = false
|
||||
if bAddMachining and Mortising.bCanApply then
|
||||
bIsMortisingOk, Mortising.Message = Chainsaw.AddMachiningAllSteps( Mortising, b3Raw)
|
||||
end
|
||||
-- lato opposto del tunnel
|
||||
if Proc.Topology == 'Tunnel' and ( dResidualDepth > 10 * GEO.EPS_SMALL) then
|
||||
Mortising = Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[2])
|
||||
bIsMortisingOk = false
|
||||
if bAddMachining and Mortising.bCanApply then
|
||||
bIsMortisingOk, Mortising.Message = Chainsaw.AddMachiningAllSteps( Mortising, b3Raw)
|
||||
end
|
||||
if not bIsMortisingOk then
|
||||
return bIsMortisingOk, Mortising.Message
|
||||
end
|
||||
else
|
||||
-- se la sega a catena non è arrivata sul fondo e c'è almeno un lato aperto va lavorato
|
||||
if Mortising.LongitudinalOffset > 10 * GEO.EPS_SMALL then
|
||||
-- eventuale lavorazione di sega a catena - lato della tasca da cui inizia la lavorazione
|
||||
if Proc.MainFaces.LongFaces[1].MainEdges.BottomEdge.IsStartOpen then
|
||||
Mortising = Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].MainEdges.SideEdges[1])
|
||||
bIsMortisingOk = false
|
||||
if bAddMachining and Mortising.bCanApply then
|
||||
bIsMortisingOk, Mortising.Message = Chainsaw.AddMachiningAllSteps( Mortising, b3Raw)
|
||||
end
|
||||
if not bIsMortisingOk then
|
||||
return bIsMortisingOk, Mortising.Message
|
||||
end
|
||||
end
|
||||
-- eventuale lavorazione di sega a catena - lato della tasca in cui finisce la lavorazione
|
||||
if Proc.MainFaces.LongFace[1].MainEdges.BottomEdge.IsEndOpen then
|
||||
Mortising = Chainsaw.CalculateMachiningParameters( Proc, Proc.MainFaces.LongFaces[1], Proc.MainFaces.LongFaces[1].Edges.SideEdges[2])
|
||||
bIsMortisingOk = false
|
||||
if bAddMachining and Mortising.bCanApply then
|
||||
bIsMortisingOk, Mortising.Message = Chainsaw.AddMachiningAllSteps( Mortising, b3Raw)
|
||||
end
|
||||
if not bIsMortisingOk then
|
||||
return bIsMortisingOk, Mortising.Message
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
local sFinalMessage = ''
|
||||
if #Cutting.Message > 0 or #Mortising.Message > 0 then
|
||||
sFinalMessage = Cutting.Message .. '\n' .. Mortising.Message
|
||||
end
|
||||
|
||||
return bIsMortisingOk, sFinalMessage
|
||||
end
|
||||
|
||||
-------------------------------------------------------------------------------------------------------------
|
||||
|
||||
return STR0003
|
||||
@@ -0,0 +1,11 @@
|
||||
-- Parametri configurabili da cliente per strategia: STR0001
|
||||
|
||||
local STR0003Data = {
|
||||
sStrategyId = 'STR0003',
|
||||
Parameters = {
|
||||
{ sName = 'bApplyOnlyBlade', sValue = 'false', sDescriptionShort = 'Blade only', sDescriptionLong = 'Machining with blade only and avoid chainsaw', sType = 'b', idMessage = ''},
|
||||
{ sName = 'bForceLongcutBlade', sValue = 'false', sDescriptionShort = 'Force ripping blade', sDescriptionLong = 'Force the use of ripping blade, designed for cuts parallel to the grain', sType = 'b', idMessage = ''}
|
||||
}
|
||||
}
|
||||
|
||||
return STR0003Data
|
||||
+29
-14
@@ -2,6 +2,7 @@
|
||||
[Comments]
|
||||
STR0001 = Tenone a coda di rondine. Lama + fresa a coda di rondine
|
||||
STR0002 = Topologia tipo LapJoint. Svuotatura con fresa
|
||||
STR0003 = Topologia tipo LapJoint. Lama + motosega
|
||||
|
||||
[Strategies]
|
||||
; Processing , Gruppo , Topologia , Strategie
|
||||
@@ -16,29 +17,41 @@ STR0002 = Topologia tipo LapJoint. Svuotatura con fresa
|
||||
; Feature : Saw Cut
|
||||
13,0,Feature,
|
||||
; Feature : Slot
|
||||
16,0,Pocket-5-Blind,STR0002
|
||||
16,0,Groove-4-Blind,STR0002
|
||||
16,0,Pocket-5-Blind,STR0002,STR0003
|
||||
16,0,Groove-4-Blind,STR0002,STR0003
|
||||
16,0,Groove-3-Through,STR0002,STR0003
|
||||
16,0,Tunnel-4-Through,STR0003
|
||||
; Feature : Front Slot
|
||||
17,0,Pocket-5-Blind,STR0002
|
||||
17,0,Groove-4-Blind,STR0002
|
||||
17,0,Pocket-5-Blind,STR0002,STR0003
|
||||
17,0,Groove-4-Blind,STR0002,STR0003
|
||||
17,0,Groove-3-Through,STR0002,STR0003
|
||||
17,0,Tunnel-4-Through,STR0003
|
||||
; Feature : Birds Mouth
|
||||
20,0,Feature,
|
||||
; Feature : Hip or Valley Rafter Notch
|
||||
25,0,Feature,
|
||||
; Feature : Ridge Lap
|
||||
30,1,Pocket-5-Blind,STR0002
|
||||
30,1,Groove-4-Blind,STR0002
|
||||
30,1,Pocket-5-Blind,STR0002,STR0003
|
||||
30,1,Groove-4-Blind,STR0002,STR0003
|
||||
30,1,Groove-3-Through,STR0002,STR0003
|
||||
30,1,Tunnel-4-Through,STR0003
|
||||
; Feature : Lap Joint
|
||||
30,0,Pocket-5-Blind,STR0002
|
||||
30,0,Groove-4-Blind,STR0002
|
||||
30,0,Pocket-5-Blind,STR0002,STR0003
|
||||
30,0,Groove-4-Blind,STR0002,STR0003
|
||||
30,0,Groove-3-Through,STR0002,STR0003
|
||||
30,0,Tunnel-4-Through,STR0003
|
||||
; Feature : Notch/Rabbet
|
||||
32,0,Pocket-5-Blind,STR0002
|
||||
32,0,Groove-4-Blind,STR0002
|
||||
32,0,Pocket-5-Blind,STR0002,STR0003
|
||||
32,0,Groove-4-Blind,STR0002,STR0003
|
||||
32,0,Groove-3-Through,STR0002,STR0003
|
||||
32,0,Tunnel-4-Through,STR0003
|
||||
; Feature : Block Haus
|
||||
33,0,Feature,
|
||||
; Feature : Notch
|
||||
34,0,Pocket-5-Blind,STR0002
|
||||
34,0,Groove-4-Blind,STR0002
|
||||
34,0,Pocket-5-Blind,STR0002,STR0003
|
||||
34,0,Groove-4-Blind,STR0002,STR0003
|
||||
34,0,Groove-3-Through,STR0002,STR0003
|
||||
34,0,Tunnel-4-Through,STR0003
|
||||
; Feature : French Ridge Lap
|
||||
35,1,Feature,
|
||||
; Feature : Chamfer
|
||||
@@ -48,8 +61,10 @@ STR0002 = Topologia tipo LapJoint. Svuotatura con fresa
|
||||
; Feature : Block Haus Front
|
||||
38,0,Feature,
|
||||
; Feature : Pocket
|
||||
39,0,Pocket-5-Blind,STR0002
|
||||
39,0,Groove-4-Blind,STR0002
|
||||
39,0,Pocket-5-Blind,STR0002,STR0003
|
||||
39,0,Groove-4-Blind,STR0002,STR0003
|
||||
39,0,Groove-3-Through,STR0002,STR0003
|
||||
39,0,Tunnel-4-Through,STR0003
|
||||
; Feature : Drilling
|
||||
40,0,Feature,
|
||||
; Feature : Tenon
|
||||
|
||||
Reference in New Issue
Block a user