andrea.villa
574 lines
28 KiB
Lua
574 lines
28 KiB
Lua
-- Strategia: STR0002
|
|
-- Descrizione
|
|
-- Svuotatura tasca
|
|
-- Feature tipo LapJpint
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-- TODO
|
|
-- 1 - Controllare lavorazioni in caso di feature lunga spezzata
|
|
-- 2 - Inserire antischeggia (fresa o lama)
|
|
-- 3 - Modalità svuotatura con fresa grande e spigoli con fresa piccola
|
|
-- 4 - Smusso a V
|
|
-- 5 - Finitura con motosega (se la fresa non completa)
|
|
-------------------------------------------------------------------------------------------------------------
|
|
-------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
-- carico librerie
|
|
local BeamLib = require( 'BeamLib')
|
|
local BeamData = require( 'BeamData')
|
|
local MachiningLib = require( 'MachiningLib')
|
|
local FeatureData = require( 'FeatureData')
|
|
|
|
-- Tabella per definizione modulo
|
|
local STR0002 = {}
|
|
local Strategy = {}
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function IsTopologyOk( Proc)
|
|
if Proc.Topology.sName == 'Pocket-5-Blind' or
|
|
Proc.Topology.sName == 'Tunnel-4-Through' or
|
|
Proc.Topology.sName == 'Groove-4-Blind' or
|
|
Proc.Topology.sName == 'Groove-3-Through' or
|
|
Proc.Topology.sName == 'Groove-3-Blind' or
|
|
Proc.Topology.sName == 'Rabbet-2-Through' then
|
|
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function CalcMachinedPercentage( Proc, Machining)
|
|
-- se non ci sono lavorazioni esco subito
|
|
if Machining.sTypeMachining == 'None' then
|
|
return 0
|
|
end
|
|
|
|
local dTotalPercentage = 0
|
|
local dPercentageBottom = 0
|
|
|
|
if Machining[1].bIsApplicable then
|
|
dTotalPercentage = ( Machining[1].dElevation - Machining[1].ToolInfo.dResidualDepth) / Machining[1].dElevation
|
|
dPercentageBottom = dTotalPercentage
|
|
end
|
|
if Machining[2].bIsApplicable then
|
|
local dAbsPercentage = ( Machining[2].dElevation - Machining[2].ToolInfo.dResidualDepth) / Machining[2].dElevation
|
|
dTotalPercentage = dTotalPercentage + ( 1 - dTotalPercentage) * dAbsPercentage
|
|
end
|
|
if Machining[3].bIsApplicable then
|
|
local dAbsPercentage
|
|
if Machining[3].bMachAppliedToTunnelFace then
|
|
dAbsPercentage = ( Machining[3].dElevation - Machining[3].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation) / Machining[3].dElevation
|
|
else
|
|
dAbsPercentage = ( Machining[3].dElevation - Machining[3].ToolInfo.dResidualDepth) / Machining[3].dElevation
|
|
end
|
|
dTotalPercentage = dTotalPercentage + ( 1 - dPercentageBottom) * dAbsPercentage
|
|
end
|
|
if Machining[4].bIsApplicable then
|
|
local dAbsPercentage
|
|
if Machining[3].bMachAppliedToTunnelFace then
|
|
dAbsPercentage = ( Machining[4].dElevation - Machining[4].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation) / Machining[4].dElevation
|
|
else
|
|
dAbsPercentage = ( Machining[4].dElevation - Machining[4].ToolInfo.dResidualDepth) / Machining[4].dElevation
|
|
end
|
|
dTotalPercentage = dTotalPercentage + ( 1 - dPercentageBottom) * dAbsPercentage
|
|
end
|
|
|
|
return dTotalPercentage * 100
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetBestPocketingStrategy( Proc)
|
|
-- imposto parametri di ricerca utensile in base a topologia
|
|
local Machining = {}
|
|
local Milling = {}
|
|
local ToolSearchParameters = {}
|
|
ToolSearchParameters.sMillShape = 'STANDARD'
|
|
Machining.sTypeMachining = 'None' -- Bottom-Side1-Side2\ Bottom-Side1\ Bottom-Side2\ Side1-Side2\ Bottom\ Side1 \ Side2 \ None
|
|
Strategy.Result.nQuality = FeatureData.GetFeatureQuality( 'Mill')
|
|
|
|
-- caso speciale Tunnel che non ha faccia bottom
|
|
if Proc.Topology.sName == 'Tunnel-4-Through' then
|
|
local dFaceHeight = Proc.MainFaces.SideFaces[1].MainEdges.OppositeEdges[1].dLength
|
|
local dFaceWidth = Proc.MainFaces.LongFaces[1].MainEdges.OppositeEdges[1].dLength
|
|
ToolSearchParameters.sType = 'MILL_STD'
|
|
ToolSearchParameters.dMaxToolDiameter = min( Strategy.Parameters.dMaxCornerRadius * 2, dFaceHeight, dFaceWidth)
|
|
-- imposto dati per cercare la fresa migliore
|
|
elseif Proc.Topology.sName == 'Pocket-5-Blind' then
|
|
local dFaceWidth = Proc.MainFaces.BottomFaces[1].MainEdges.LongEdges[1].dLength
|
|
local dFaceHeight = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
|
|
ToolSearchParameters.sType = 'MILL_STD'
|
|
ToolSearchParameters.dMaxToolDiameter = min( Strategy.Parameters.dMaxCornerRadius * 2, dFaceHeight, dFaceWidth)
|
|
-- cerco fresa che può anche non lavorare di testa
|
|
elseif Proc.Topology.sName == 'Groove-4-Blind' then
|
|
local dFaceWidth = Proc.MainFaces.BottomFaces[2].MainEdges.BottomEdge.dLength
|
|
ToolSearchParameters.sType = 'MILL_NOTIP'
|
|
ToolSearchParameters.dMaxToolDiameter = min( Strategy.Parameters.dMaxCornerRadius * 2, dFaceWidth)
|
|
elseif Proc.Topology.sName == 'Groove-3-Through' then
|
|
local dFaceWidth = Proc.MainFaces.BottomFaces[1].MainEdges.SideEdges[1].dLength
|
|
ToolSearchParameters.sType = 'MILL_NOTIP'
|
|
ToolSearchParameters.dMaxToolDiameter = dFaceWidth
|
|
elseif Proc.Topology.sName == 'Groove-3-Blind' then
|
|
ToolSearchParameters.sType = 'MILL_NOTIP'
|
|
ToolSearchParameters.dMaxToolDiameter = Strategy.Parameters.dMaxCornerRadius * 2
|
|
elseif Proc.Topology.sName == 'Rabbet-2-Through' then
|
|
ToolSearchParameters.sType = 'MILL_NOTIP'
|
|
ToolSearchParameters.dMaxToolDiameter = 9999
|
|
else
|
|
return nil
|
|
end
|
|
|
|
-- ===== RICERCA UTENSILE =====
|
|
-- cerco utensile per lavorare faccia Bottom
|
|
Milling.bIsApplicable = false
|
|
if Proc.Topology.sName ~= 'Tunnel-4-Through' then
|
|
ToolSearchParameters.dElevation = Proc.MainFaces.BottomFaces[1].dElevation
|
|
ToolSearchParameters.vtToolDirection = Proc.MainFaces.BottomFaces[1].vtN
|
|
Milling.idFaceToMachine = Proc.MainFaces.BottomFaces[1].id
|
|
Milling.idProc = Proc.id
|
|
Milling.vtFaceNormal = Proc.MainFaces.BottomFaces[1].vtN
|
|
Milling.dElevation = Proc.MainFaces.BottomFaces[1].dElevation
|
|
Milling.ToolInfo = {}
|
|
Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
if Milling.ToolInfo.nToolIndex then
|
|
-- se utensile scelto è su aggregato, ricalcolo la qualità
|
|
if TOOLS[Milling.ToolInfo.nToolIndex].SetupInfo.bToolOnAggregate then
|
|
Strategy.Result.nQuality = FeatureData.GetFeatureQuality( 'MillOnAggregate')
|
|
end
|
|
Milling.bIsApplicable = true
|
|
local ParametersMRR = {}
|
|
ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
|
|
Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
|
|
end
|
|
end
|
|
table.insert( Machining, Milling)
|
|
|
|
-- caso speciale 'Rabbet-2-Through' seconda faccia principale
|
|
Milling = {}
|
|
Milling.bIsApplicable = false
|
|
if Proc.Topology.sName == 'Rabbet-2-Through' then
|
|
ToolSearchParameters.dElevation = Proc.MainFaces.LongFaces[1].dElevation
|
|
ToolSearchParameters.vtToolDirection = Proc.MainFaces.LongFaces[1].vtN
|
|
Milling.vtFaceNormal = Proc.MainFaces.LongFaces[1].vtN
|
|
Milling.idFaceToMachine = Proc.MainFaces.LongFaces[1].id
|
|
Milling.idProc = Proc.id
|
|
Milling.dElevation = Proc.MainFaces.LongFaces[1].dElevation
|
|
Milling.ToolInfo = {}
|
|
Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
if Milling.ToolInfo.nToolIndex then
|
|
Milling.bIsApplicable = true
|
|
local ParametersMRR = {}
|
|
ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
|
|
Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
|
|
end
|
|
end
|
|
table.insert( Machining, Milling)
|
|
|
|
-- cerco utensile per lavorare di fianco 1
|
|
Milling = {}
|
|
Milling.bIsApplicable = false
|
|
if Proc.Topology.sName ~= 'Pocket-5-Blind' then
|
|
if Proc.Topology.sName == 'Groove-4-Blind' then
|
|
ToolSearchParameters.dElevation = Proc.MainFaces.BottomFaces[2].dElevation
|
|
ToolSearchParameters.vtToolDirection = Proc.MainFaces.BottomFaces[2].vtN
|
|
Milling.vtFaceNormal = Proc.MainFaces.BottomFaces[2].vtN
|
|
Milling.idFaceToMachine = Proc.MainFaces.BottomFaces[2].id
|
|
Milling.idProc = Proc.id
|
|
Milling.dElevation = Proc.MainFaces.BottomFaces[2].dElevation
|
|
elseif Proc.Topology.sName == 'Groove-3-Blind' then
|
|
ToolSearchParameters.dElevation = Proc.MainFaces.LongFaces[1].dElevation
|
|
ToolSearchParameters.vtToolDirection = Proc.MainFaces.LongFaces[1].vtN
|
|
Milling.vtFaceNormal = Proc.MainFaces.LongFaces[1].vtN
|
|
Milling.idFaceToMachine = Proc.MainFaces.LongFaces[1].id
|
|
Milling.idProc = Proc.id
|
|
Milling.dElevation = Proc.MainFaces.LongFaces[1].dElevation
|
|
else -- 'Tunnel-4-Through', 'Groove-3-Through', 'Rabbet-2-Through'
|
|
-- se lavoro di fianco, devo comunque rispettare il raggio massimo
|
|
ToolSearchParameters.dMaxToolDiameter = min( ToolSearchParameters.dMaxToolDiameter, Strategy.Parameters.dMaxCornerRadius * 2)
|
|
ToolSearchParameters.dElevation = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP
|
|
ToolSearchParameters.vtToolDirection = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].vtN
|
|
Milling.vtFaceNormal = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].vtN
|
|
Milling.idFaceToMachine = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].id
|
|
Milling.idProc = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.id
|
|
Milling.dElevation = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP
|
|
Milling.bMachAppliedToTunnelFace = true
|
|
end
|
|
Milling.ToolInfo = {}
|
|
Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
if Milling.ToolInfo.nToolIndex then
|
|
Milling.bIsApplicable = true
|
|
local ParametersMRR = {}
|
|
ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
|
|
Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
|
|
end
|
|
end
|
|
table.insert( Machining, Milling)
|
|
|
|
-- cerco utensile per lavorare di fianco 2
|
|
Milling = {}
|
|
Milling.bIsApplicable = false
|
|
if Proc.Topology.sName ~= 'Pocket-5-Blind' and Proc.Topology.sName ~= 'Groove-4-Blind' then
|
|
if Proc.MainFaces.TunnelAddedFaces then -- Tunnel-4-Through, Groove-3-Through, Rabbet-2-Through
|
|
-- se lavoro di fianco, devo comunque rispettare il raggio massimo
|
|
ToolSearchParameters.dMaxToolDiameter = min( ToolSearchParameters.dMaxToolDiameter, Strategy.Parameters.dMaxCornerRadius * 2)
|
|
ToolSearchParameters.dElevation = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP
|
|
ToolSearchParameters.vtToolDirection = -Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].vtN
|
|
Milling.vtFaceNormal = -Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].vtN
|
|
Milling.idFaceToMachine = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].id
|
|
Milling.idProc = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.id
|
|
Milling.dElevation = ( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP
|
|
Milling.bToolInvert = true
|
|
Milling.bMachAppliedToTunnelFace = true
|
|
else -- 'Groove-3-Blind'
|
|
ToolSearchParameters.dElevation = Proc.MainFaces.SideFaces[1].dElevation
|
|
ToolSearchParameters.vtToolDirection = Proc.MainFaces.SideFaces[1].vtN
|
|
Milling.vtFaceNormal = Proc.MainFaces.SideFaces[1].vtN
|
|
Milling.idFaceToMachine = Proc.MainFaces.SideFaces[1].id
|
|
Milling.idProc = Proc.id
|
|
Milling.dElevation = Proc.MainFaces.SideFaces[1].dElevation
|
|
end
|
|
Milling.ToolInfo = {}
|
|
Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
if Milling.ToolInfo.nToolIndex then
|
|
Milling.bIsApplicable = true
|
|
local ParametersMRR = {}
|
|
ParametersMRR.nToolIndex = Milling.ToolInfo.nToolIndex
|
|
Milling.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
|
|
end
|
|
end
|
|
table.insert( Machining, Milling)
|
|
|
|
-- ===== SCELTA LAVORAZIONI =====
|
|
-- se bottom completa tutto
|
|
if Machining[1].bIsApplicable and Machining[1].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
|
|
Machining.sTypeMachining = 'Bottom'
|
|
Strategy.Result.sStatus = 'Completed'
|
|
Strategy.Result.nCompletionIndex = FeatureData.GetFeatureCompletionIndex( 100)
|
|
Strategy.Result.dMRR = Machining[1].dMRR
|
|
Machining[1].ToolInfo.dResidualDepth = 0
|
|
Machining[2].bIsApplicable = false
|
|
Machining[3].bIsApplicable = false
|
|
Machining[4].bIsApplicable = false
|
|
return Machining
|
|
-- caso speciale 'Rabbet-2-Through' che ha la sweconda faccia come se fosse una seconda bottom
|
|
elseif Proc.Topology.sName == 'Rabbet-2-Through' and Machining[2].bIsApplicable and Machining[2].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
|
|
Machining.sTypeMachining = 'Bottom2'
|
|
Strategy.Result.sStatus = 'Completed'
|
|
Strategy.Result.nCompletionIndex = FeatureData.GetFeatureCompletionIndex( 100)
|
|
Strategy.Result.dMRR = Machining[2].dMRR
|
|
Machining[2].ToolInfo.dResidualDepth = 0
|
|
Machining[1].bIsApplicable = false
|
|
Machining[3].bIsApplicable = false
|
|
Machining[4].bIsApplicable = false
|
|
return Machining
|
|
-- se la 3 completa tutto
|
|
elseif Machining[3].bIsApplicable and Machining[3].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
|
|
Machining.sTypeMachining = 'Side1'
|
|
Strategy.Result.sStatus = 'Completed'
|
|
Strategy.Result.nCompletionIndex = FeatureData.GetFeatureCompletionIndex( 100)
|
|
Strategy.Result.dMRR = Machining[3].dMRR
|
|
if Proc.MainFaces.TunnelAddedFaces then
|
|
Machining[3].ToolInfo.dResidualDepth = -( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP)
|
|
else
|
|
Machining[3].ToolInfo.dResidualDepth = 0
|
|
end
|
|
Machining[1].bIsApplicable = false
|
|
Machining[2].bIsApplicable = false
|
|
Machining[4].bIsApplicable = false
|
|
return Machining
|
|
-- se la 4 completa tutto
|
|
elseif Machining[4].bIsApplicable and Machining[4].ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
|
|
Machining.sTypeMachining = 'Side2'
|
|
Strategy.Result.sStatus = 'Completed'
|
|
Strategy.Result.nCompletionIndex = FeatureData.GetFeatureCompletionIndex( 100)
|
|
Strategy.Result.dMRR = Machining[4].dMRR
|
|
if Proc.MainFaces.TunnelAddedFaces then
|
|
Machining[4].ToolInfo.dResidualDepth = -( Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP)
|
|
else
|
|
Machining[4].ToolInfo.dResidualDepth = 0
|
|
end
|
|
Machining[1].bIsApplicable = false
|
|
Machining[2].bIsApplicable = false
|
|
Machining[3].bIsApplicable = false
|
|
return Machining
|
|
-- se tunnel 2+3 completa tutto
|
|
elseif Proc.MainFaces.TunnelAddedFaces and Machining[3].bIsApplicable and Machining[4].bIsApplicable and
|
|
Machining[3].ToolInfo.dResidualDepth + Machining[4].ToolInfo.dResidualDepth < (Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation * 2) + BeamData.MILL_OVERLAP then
|
|
Machining.sTypeMachining = 'Side1-Side2'
|
|
Strategy.Result.sStatus = 'Completed'
|
|
Machining[3].ToolInfo.dResidualDepth = Machining[3].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation
|
|
Machining[4].ToolInfo.dResidualDepth = -Machining[3].ToolInfo.dResidualDepth - BeamData.MILL_OVERLAP
|
|
Strategy.Result.nCompletionIndex = FeatureData.GetFeatureCompletionIndex( 100)
|
|
Strategy.Result.dMRR = ( Machining[3].dMRR + Machining[4].dMRR) / 2
|
|
Machining[1].bIsApplicable = false
|
|
Machining[2].bIsApplicable = false
|
|
return Machining
|
|
end
|
|
|
|
Strategy.Result.sStatus = 'Not-Completed'
|
|
Strategy.Result.dMRR = 0
|
|
if Machining[1].bIsApplicable then
|
|
Machining.sTypeMachining = 'Bottom'
|
|
Strategy.Result.dMRR = Machining[1].dMRR
|
|
end
|
|
if Machining[2].bIsApplicable then
|
|
Machining.sTypeMachining = EgtIf( Machining.sTypeMachining == 'None', 'Bottom2', Machining.sTypeMachining .. '-Bottom2')
|
|
Strategy.Result.dMRR = ( Strategy.Result.dMRR + Machining[2].dMRR) / EgtIf( Strategy.Result.dMRR == 0, 1, 2)
|
|
end
|
|
if Machining[3].bIsApplicable then
|
|
if Proc.MainFaces.TunnelAddedFaces then
|
|
Machining[3].ToolInfo.dResidualDepth = Machining[3].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP
|
|
end
|
|
Machining.sTypeMachining = EgtIf( Machining.sTypeMachining == 'None', 'Side1', Machining.sTypeMachining .. '-Side1')
|
|
Strategy.Result.dMRR = ( Strategy.Result.dMRR + Machining[3].dMRR) / EgtIf( Strategy.Result.dMRR == 0, 1, 2)
|
|
end
|
|
if Machining[4].bIsApplicable then
|
|
if Proc.MainFaces.TunnelAddedFaces then
|
|
Machining[4].ToolInfo.dResidualDepth = Machining[4].ToolInfo.dResidualDepth - Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.Faces[1].dElevation + BeamData.MILL_OVERLAP
|
|
end
|
|
Machining.sTypeMachining = EgtIf( Machining.sTypeMachining == 'None', 'Side2', Machining.sTypeMachining .. '-Side2')
|
|
Strategy.Result.dMRR = ( Strategy.Result.dMRR + Machining[4].dMRR) / EgtIf( Strategy.Result.dMRR == 0, 1, 2)
|
|
end
|
|
|
|
local dMachinedPrercentage = CalcMachinedPercentage( Proc, Machining)
|
|
Strategy.Result.nCompletionIndex = FeatureData.GetFeatureCompletionIndex( dMachinedPrercentage)
|
|
Strategy.Result.sInfo = 'Machining not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
|
|
|
|
-- se non ho trovato neanche una lavorazione
|
|
if Machining.sTypeMachining == 'None' then
|
|
Strategy.Result.sStatus = 'Not-Applicable'
|
|
Strategy.Result.nCompletionIndex = 0
|
|
Strategy.Result.dMRR = 0
|
|
Strategy.Result.nQuality = 0
|
|
Strategy.Result.sInfo = 'Mill not found'
|
|
end
|
|
|
|
return Machining
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function VerifySplitMachiningNeeded( Proc, Part)
|
|
local vAddId = {}
|
|
local vAddIdTunnel = {}
|
|
local bSplit
|
|
|
|
-- la lunghezza richiede spezzatura
|
|
if Proc.b3Box:getDimX() > BeamData.LONGCUT_MAXLEN or Proc.b3Box:getDimX() > 0.7 * Part.b3Solid:getDimX() then
|
|
bSplit = true
|
|
else
|
|
bSplit = false
|
|
end
|
|
|
|
-- la lunghezza richiede spezzatura
|
|
if ( bSplit) then
|
|
-- recupero gruppo per geometria aggiuntiva
|
|
local nAddGrpId = BeamLib.GetAddGroup( Part.id)
|
|
local bStartLeft, bStartRight
|
|
local nIdTunnel = nil
|
|
if Proc.MainFaces.TunnelAddedFaces then
|
|
nIdTunnel = Proc.MainFaces.TunnelAddedFaces.MiddleFaceTm.id
|
|
end
|
|
|
|
-- se feature inizia al di sotto del limite sinistro (coda)
|
|
if Proc.b3Box:getMin():getX() < Part.b3Solid:getMin():getX() + BeamData.LONGCUT_ENDLEN then
|
|
bStartLeft = true
|
|
end
|
|
-- se feature inizia al di sotto del limite destro (testa)
|
|
if Proc.b3Box:getMax():getX() > Part.b3Solid:getMax():getX() - BeamData.LONGCUT_ENDLEN then
|
|
bStartRight = true
|
|
end
|
|
|
|
-- recupero utensile con massimo diametro
|
|
local dMaxDiam = 30
|
|
for t = 1, #Strategy.Machining do
|
|
if Strategy.Machining[t].bIsApplicable then
|
|
dMaxDiam = min( dMaxDiam, TOOLS[Strategy.Machining[t].ToolInfo.nToolIndex].dDiameter)
|
|
end
|
|
end
|
|
-- salvo valori
|
|
local dNewMinX = Proc.b3Box:getMin():getX()
|
|
local dNewMaxX = Proc.b3Box:getMax():getX()
|
|
local dNewRest = Proc.b3Box:getDimX()
|
|
|
|
-- creo primo spezzone sulla sinistra
|
|
if bStartLeft then
|
|
local AddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
|
|
-- copio faccia tunnel
|
|
local AddIdTunnel = EgtCopyGlob( nIdTunnel, nAddGrpId) or GDB_ID.NULL
|
|
|
|
-- decido punto spezzatura verso la coda
|
|
if Proc.b3Box:getDimX() > BeamData.LONGCUT_ENDLEN * 2 then
|
|
dNewMinX = max( Part.b3Solid:getMin():getX() + BeamData.LONGCUT_ENDLEN, Proc.b3Box:getMin():getX() + dMaxDiam * 3)
|
|
else
|
|
-- se pezzo abbastanza piccolo, spezzo in mezzo al 'pezzo + grezzo restante'
|
|
if Part.dRestLength + Part.b3Solid:getDimX() < BeamData.dMinRaw * 1.5 then
|
|
dNewMinX = Part.b3Solid:getMax():getX() - ( ( Part.dRestLength + Part.b3Solid:getDimX()) / 2)
|
|
else
|
|
dNewMinX = max( Proc.b3Box:getMin():getX() + ( BeamData.dMinRaw)/2 + 150, Part.b3Solid:getMax():getX() - BeamData.LONGCUT_ENDLEN)
|
|
end
|
|
end
|
|
|
|
local ptOn = Point3d( dNewMinX, 0, 0)
|
|
dNewRest = abs( dNewMaxX - dNewMinX)
|
|
-- taglio della superficie lato sinistro
|
|
EgtCutSurfTmPlane( AddId, ptOn, X_AX(), true, GDB_RT.GLOB)
|
|
EgtCutSurfTmPlane( AddIdTunnel, ptOn, X_AX(), true, GDB_RT.GLOB)
|
|
-- eseguo inserimento
|
|
table.insert( vAddId, AddId)
|
|
table.insert( vAddIdTunnel, AddIdTunnel)
|
|
end
|
|
-- creo spezzone sulla destra
|
|
if bStartRight then
|
|
local AddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
|
|
-- copio faccia tunnel
|
|
local AddIdTunnel = EgtCopyGlob( nIdTunnel, nAddGrpId) or GDB_ID.NULL
|
|
dNewMaxX = min( ( Proc.b3Box:getMax():getX() - dMaxDiam * 3), Part.b3Solid:getMax():getX() - BeamData.LONGCUT_ENDLEN)
|
|
if dNewMaxX - dNewMinX < 500 * GEO.EPS_SMALL then
|
|
dNewMaxX = dNewMinX - BeamData.MILL_OVERLAP
|
|
dNewRest = 0
|
|
else
|
|
dNewRest = dNewMaxX - dNewMinX
|
|
end
|
|
local ptOn = Point3d( dNewMaxX, 0, 0)
|
|
-- taglio della superficie lato destro
|
|
EgtCutSurfTmPlane( AddId, ptOn, -X_AX(), true, GDB_RT.GLOB)
|
|
EgtCutSurfTmPlane( AddIdTunnel, ptOn, -X_AX(), true, GDB_RT.GLOB)
|
|
-- eseguo inserimento
|
|
table.insert( vAddId, 1, AddId)
|
|
table.insert( vAddIdTunnel, AddIdTunnel)
|
|
end
|
|
-- lavoro il restante
|
|
if dNewRest > 0 then
|
|
local nSplitParts = max( ceil( dNewRest / BeamData.LONGCUT_MAXLEN + 10 * GEO.EPS_SMALL), 1)
|
|
local dSplitPartsLen = dNewRest / nSplitParts
|
|
for i = 1, nSplitParts do
|
|
local AddId = EgtCopyGlob( Proc.id, nAddGrpId) or GDB_ID.NULL
|
|
-- copio faccia tunnel
|
|
local AddIdTunnel = EgtCopyGlob( nIdTunnel, nAddGrpId) or GDB_ID.NULL
|
|
local ptOn
|
|
-- se un solo spezzone, prendo punto massimo e minimo
|
|
if nSplitParts == 1 then
|
|
ptOn = Point3d( dNewMinX, 0, 0)
|
|
-- taglio della superficie lato sinistro
|
|
EgtCutSurfTmPlane( AddId, ptOn, -X_AX(), true, GDB_RT.GLOB)
|
|
EgtCutSurfTmPlane( AddIdTunnel, ptOn, -X_AX(), true, GDB_RT.GLOB)
|
|
ptOn = Point3d( dNewMaxX, 0, 0)
|
|
-- taglio della superficie lato destro
|
|
EgtCutSurfTmPlane( AddId, ptOn, X_AX(), true, GDB_RT.GLOB)
|
|
EgtCutSurfTmPlane( AddIdTunnel, ptOn, X_AX(), true, GDB_RT.GLOB)
|
|
else
|
|
-- eseguo trim sinistro
|
|
if i ~= 1 or bStartLeft then
|
|
ptOn = Point3d( dNewMinX, 0, 0)
|
|
-- taglio della superficie lato sinistro
|
|
EgtCutSurfTmPlane( AddId, ptOn, -X_AX(), true, GDB_RT.GLOB)
|
|
EgtCutSurfTmPlane( AddIdTunnel, ptOn, -X_AX(), true, GDB_RT.GLOB)
|
|
end
|
|
-- eseguo trim destro
|
|
dNewMaxX = dNewMinX + dSplitPartsLen
|
|
if i ~= nSplitParts or bStartRight then
|
|
ptOn = Point3d( dNewMaxX, 0, 0)
|
|
-- taglio della superficie lato destro
|
|
EgtCutSurfTmPlane( AddId, ptOn, X_AX(), true, GDB_RT.GLOB)
|
|
EgtCutSurfTmPlane( AddIdTunnel, ptOn, X_AX(), true, GDB_RT.GLOB)
|
|
end
|
|
-- il nuovo minimo è il punto massimo del precedente
|
|
dNewMinX = dNewMaxX
|
|
end
|
|
-- eseguo inserimento in modo da ordinare da X- a X+
|
|
table.insert( vAddId, EgtIf( #vAddId == 0 or not bStartRight, 1, 2), AddId)
|
|
table.insert( vAddIdTunnel, EgtIf( #vAddIdTunnel == 0 or not bStartRight, 1, 2), AddIdTunnel)
|
|
end
|
|
end
|
|
else
|
|
-- TODO se è sulla coda, messaggio che posso rovinare
|
|
table.insert( vAddId, Proc.id)
|
|
end
|
|
|
|
return vAddId, vAddIdTunnel
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
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')
|
|
Strategy.sName = StrategyLib.Config.sStrategyId
|
|
CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
|
|
Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
|
|
Strategy.Machining = {}
|
|
Strategy.Result = {}
|
|
|
|
if not IsTopologyOk( Proc) then
|
|
local sErr = 'Feature '.. Proc.idFeature .. ' : strategy ' .. StrategyLib.Config.sStrategyId .. ' not implemented'
|
|
EgtOutLog( sErr)
|
|
Strategy.Result.sStatus = 'Not-Applicable'
|
|
Strategy.Result.nCompletionIndex = 0
|
|
Strategy.Result.dMRR = 0
|
|
Strategy.Result.nQuality = 0
|
|
Strategy.Result.sInfo = sErr
|
|
return false, Strategy.Result
|
|
end
|
|
|
|
local bAreAllMachiningsAdded = true
|
|
local ToolInfo = {}
|
|
local Pocketing = {}
|
|
|
|
Strategy.Machining = GetBestPocketingStrategy( Proc)
|
|
|
|
if bAddMachining and Strategy.Result.sStatus ~= 'Not-Applicable' then
|
|
local vAddId, vAddIdTunnel = VerifySplitMachiningNeeded( Proc, Part)
|
|
|
|
-- si applicano le lavorazioni
|
|
for i = 1, #vAddId do
|
|
for j = 1, #Strategy.Machining do
|
|
if Strategy.Machining[j].bIsApplicable then
|
|
Pocketing = {}
|
|
Pocketing.Steps = {}
|
|
Pocketing.LeadIn = {}
|
|
Pocketing.nType = MCH_OY.POCKETING
|
|
Pocketing.nSubType = EgtIf( Proc.Topology.sName == 'Pocket-5-Blind', MCH_POCK_SUB.SPIRALOUT, MCH_POCK_SUB.SPIRALIN)
|
|
Pocketing.LeadIn.nType = MCH_POCK_LI.ZIGZAG
|
|
Pocketing.Steps.dStep = TOOLS[Strategy.Machining[j].ToolInfo.nToolIndex].dStep
|
|
Pocketing.Steps.dSideStep = TOOLS[Strategy.Machining[j].ToolInfo.nToolIndex].dSideStep
|
|
Pocketing.nToolIndex = Strategy.Machining[j].ToolInfo.nToolIndex
|
|
Pocketing.LeadIn.dTangentDistance = TOOLS[Strategy.Machining[j].ToolInfo.nToolIndex].dDiameter/2
|
|
Pocketing.LeadIn.dElevation = TOOLS[Strategy.Machining[j].ToolInfo.nToolIndex].dDiameter/2
|
|
Pocketing.sDepth = -Strategy.Machining[j].ToolInfo.dResidualDepth
|
|
-- il quarto ciclo è la lavorazione opposta sulla faccia Tunnel
|
|
if Strategy.Machining[j].bToolInvert then
|
|
Pocketing.bToolInvert = true
|
|
end
|
|
-- se ho una sola trimesh, sto lavorando la Proc direttamente e non ho spezzato. Applico direttamente alla geometria calcolata prima
|
|
if #vAddId == 1 then
|
|
Pocketing.Geometry = {{ Strategy.Machining[j].idProc, Strategy.Machining[j].idFaceToMachine}}
|
|
bAreAllMachiningsAdded = MachiningLib.AddNewMachining( Proc, Pocketing)
|
|
else
|
|
-- TODO settare parametro per indicare qual è lo spezzone che deve essere fatto dopo il taglio di separazione
|
|
for k = 1, Proc.nFct do
|
|
local vtNSplitFace
|
|
local dIdTm = EgtIf( Strategy.Machining[j].bMachAppliedToTunnelFace, vAddIdTunnel[i], vAddId[i])
|
|
_, vtNSplitFace = EgtSurfTmFacetCenter( dIdTm, k - 1, GDB_ID.ROOT)
|
|
if vtNSplitFace and AreSameVectorApprox( vtNSplitFace * EgtIf( Pocketing.bToolInvert, -1, 1), Strategy.Machining[j].vtFaceNormal) then
|
|
Pocketing.Geometry = {{ dIdTm, k - 1}}
|
|
bAreAllMachiningsAdded = bAreAllMachiningsAdded and MachiningLib.AddNewMachining( Proc, Pocketing)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
else
|
|
bAreAllMachiningsAdded = false
|
|
end
|
|
|
|
return bAreAllMachiningsAdded, Strategy.Result
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
|
|
return STR0002 |