andrea.villa
d58be78868
- HEADCUT derivata da SPLITCUT. Da verificare se mantenere separate o fondere in un'unica strategia
425 lines
19 KiB
Lua
425 lines
19 KiB
Lua
-- Strategia: SPLITCUT
|
|
-- Descrizione
|
|
-- Taglio di separazione
|
|
-- Feature: SplitCut
|
|
|
|
-- carico librerie
|
|
local BeamLib = require( 'BeamLib')
|
|
local BeamData = require( 'BeamData')
|
|
local MachiningLib = require( 'MachiningLib')
|
|
local FeatureLib = require( 'FeatureLib')
|
|
-- strategie di base
|
|
local FaceByBlade = require('FACEBYBLADE')
|
|
|
|
-- Tabella per definizione modulo
|
|
local SPLITCUT = {}
|
|
local Strategy = {}
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function LoadStrategyParameters( CustomParameters)
|
|
local StrategyLib = {}
|
|
StrategyLib.Config = require( 'SPLITCUT\\SPLITCUTConfig')
|
|
Strategy.sName = StrategyLib.Config.sStrategyId
|
|
CustomParameters = BeamLib.GetUpdateCustomParameters( CustomParameters, StrategyLib.Config.Parameters)
|
|
Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( CustomParameters)
|
|
Strategy.Result = {}
|
|
Strategy.Machining = {}
|
|
Strategy.Result.sInfo = ''
|
|
return Strategy
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function CalculateLeadInOut( Machining, EdgeToMachine)
|
|
|
|
local LeadIn = {}
|
|
local LeadOut = {}
|
|
LeadIn.dStartAddLength = 0
|
|
LeadOut.dEndAddLength = 0
|
|
LeadIn.nType = MCH_MILL_LI.LINEAR
|
|
LeadOut.nType = MCH_MILL_LI.LINEAR
|
|
LeadIn.dTangentDistance = 0
|
|
LeadOut.dTangentDistance = 0
|
|
-- elevazione sempre in negativo
|
|
if EdgeToMachine.Elev < 10 * GEO.EPS_SMALL then
|
|
LeadIn.dPerpDistance = BeamData.CUT_SIC - EdgeToMachine.Elev
|
|
LeadOut.dPerpDistance = BeamData.CUT_SIC - EdgeToMachine.Elev
|
|
else
|
|
LeadIn.dPerpDistance = BeamData.CUT_SIC
|
|
LeadOut.dPerpDistance = BeamData.CUT_SIC
|
|
end
|
|
LeadIn.dElevation = 0
|
|
LeadOut.dElevation = 0
|
|
LeadIn.dCompLength = 0
|
|
LeadOut.dCompLength = 0
|
|
LeadIn.dStartAddLength = BeamData.CUT_EXTRA
|
|
LeadOut.dEndAddLength = BeamData.CUT_EXTRA
|
|
|
|
return LeadIn, LeadOut
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function MakeChamfer()
|
|
-- TODO funzionalità da aggiungere
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetEdgeToMachine( Proc, vtEdge)
|
|
local Edge
|
|
for i = 1, #Proc.Faces[1].Edges do
|
|
if AreSameVectorApprox( Proc.Faces[1].Edges[i].Norm, vtEdge) then
|
|
Edge = Proc.Faces[1].Edges[i]
|
|
end
|
|
end
|
|
return Edge
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetSplitStrategy( Proc, Part)
|
|
-- se non sono stati caricati i parametri, si ricaricano
|
|
if not Strategy.Parameters then
|
|
Strategy = LoadStrategyParameters()
|
|
end
|
|
|
|
-- separazione solo se esiste grezzo successivo con pezzi o scaricabile
|
|
local nNextRawId = EgtGetNextRawPart( Part.idRaw)
|
|
Strategy.bSplit = ( nNextRawId and ( EgtGetPartInRawPartCount( nNextRawId) > 0 or EgtGetRawPartBBox( nNextRawId):getDimX() >= BeamData.dMinRaw))
|
|
|
|
-- imposto paraemtri di ricerca utensile in base a topologia
|
|
local Machining = {}
|
|
-- sTypeMachining = BladeSideSingle\ BladeSideDouble\ BladeHorizontalSingle\ BladeHorizontalDouble\ ChainSawHorizontal\ ChainSawSideSingle\ ChainSawSideDouble\ ChainSawPlusBlade\ Mill\ None
|
|
Machining.sTypeMachining = 'None'
|
|
local Splitting = {}
|
|
local ToolSearchParameters = {}
|
|
ToolSearchParameters.vtToolDirection = Proc.Faces[1].vtN
|
|
|
|
|
|
-- ===== RICERCA UTENSILE =====
|
|
-- cerco lama sopra
|
|
Splitting.bIsApplicable = false
|
|
ToolSearchParameters.bAllowTopHead = true
|
|
ToolSearchParameters.bAllowBottomHead = false
|
|
Splitting.ToolInfo = {}
|
|
Splitting.ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
|
|
if Splitting.ToolInfo.nToolIndex then
|
|
Splitting.bIsApplicable = true
|
|
local ParametersMRR = {}
|
|
ParametersMRR.nToolIndex = Splitting.ToolInfo.nToolIndex
|
|
Splitting.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
|
|
end
|
|
table.insert( Machining, Splitting)
|
|
|
|
-- cerco lama sotto
|
|
Splitting = {}
|
|
Splitting.bIsApplicable = false
|
|
ToolSearchParameters.bAllowTopHead = false
|
|
ToolSearchParameters.bAllowBottomHead = true
|
|
Splitting.ToolInfo = {}
|
|
Splitting.ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
|
|
if Splitting.ToolInfo.nToolIndex then
|
|
Splitting.bIsApplicable = true
|
|
local ParametersMRR = {}
|
|
ParametersMRR.nToolIndex = Splitting.ToolInfo.nToolIndex
|
|
Splitting.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
|
|
end
|
|
table.insert( Machining, Splitting)
|
|
|
|
-- cerco motosega
|
|
Splitting = {}
|
|
Splitting.bIsApplicable = false
|
|
table.insert( Machining, Splitting)
|
|
|
|
-- cerco fresa
|
|
Splitting = {}
|
|
Splitting.bIsApplicable = false
|
|
table.insert( Machining, Splitting)
|
|
|
|
-- ===== SCELTA LAVORAZIONI =====
|
|
-- forzature da parametri
|
|
if Strategy.Parameters.bForceChainSaw then
|
|
Machining[1].bIsApplicable = false
|
|
Machining[2].bIsApplicable = false
|
|
end
|
|
|
|
-- setto valori di default. Impossibile che taglio di separazione sia incompleto
|
|
Strategy.Result.sStatus = 'Completed'
|
|
Strategy.Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( 100)
|
|
Strategy.Result.dMRR = 1
|
|
|
|
-- correzioni sul massimo materiale lama, considerando ingombri vari
|
|
local dMaxMatBladeSideSingle
|
|
local dMaxMatBladeSideDouble
|
|
local dMaxMatBladeHorizontalSingle
|
|
local dMaxMatBladeHorizontalDouble
|
|
if Machining[1].bIsApplicable then
|
|
local dMaxMat = TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial
|
|
local dRadius = TOOLS[Machining[1].ToolInfo.nToolIndex].dDiameter / 2
|
|
local sHead = TOOLS[Machining[1].ToolInfo.nToolIndex].sHead
|
|
-- se taglio di fianco disponibile, si controlla il massimo materiale reale. Per pezzi alti, bisogna controllare anche l'ingombro asse Z nelle 4 direzioni.
|
|
if Part.dHeight < BeamData.MIN_DIM_HBEAM then
|
|
dMaxMat = min( dMaxMat, BeamData.MAX_DIM_HTCUT)
|
|
dMaxMatBladeSideSingle = dMaxMat
|
|
dMaxMatBladeSideDouble = dMaxMat * 2
|
|
else
|
|
if BeamData.GetMaxMatReductionBladeCut then
|
|
dMaxMatBladeSideSingle = min( max( dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, Y_AX()), dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, -Y_AX())),
|
|
TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial)
|
|
dMaxMatBladeSideDouble = dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, Y_AX()) + dRadius - BeamData.GetMaxMatReductionBladeCut( sHead, -Y_AX())
|
|
else
|
|
dMaxMatBladeSideSingle = abs( BeamData.MAX_DIM_HTCUT_HBEAM)
|
|
dMaxMatBladeSideDouble = abs( BeamData.MAX_DIM_HTCUT_HBEAM) * 2
|
|
end
|
|
end
|
|
-- se taglio orizzontale
|
|
if BeamData.GetMaxMatReductionBladeCut then
|
|
dMaxMatBladeHorizontalSingle = min( TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial, dRadius - BeamData.GetMaxMatReductionBladeCut( TOOLS[Machining[1].ToolInfo.nToolIndex].sHead, -Z_AX()))
|
|
else
|
|
dMaxMatBladeHorizontalSingle = TOOLS[Machining[1].ToolInfo.nToolIndex].dMaxMaterial
|
|
end
|
|
end
|
|
if Machining[2].bIsApplicable then
|
|
if BeamData.GetMaxMatReductionBladeCut then
|
|
local dRadius = TOOLS[Machining[2].ToolInfo.nToolIndex].dDiameter / 2
|
|
dMaxMatBladeHorizontalDouble = min( TOOLS[Machining[2].ToolInfo.nToolIndex].dMaxMaterial, dRadius - BeamData.GetMaxMatReductionBladeCut( TOOLS[Machining[2].ToolInfo.nToolIndex].sHead, Z_AX()))
|
|
else
|
|
dMaxMatBladeHorizontalDouble = TOOLS[Machining[2].ToolInfo.nToolIndex].dMaxMaterial
|
|
end
|
|
end
|
|
|
|
-- TODO considerare di tagliare con il massimo materiale possibile per non salire troppo in Z (macchine tipo PF), oppure non scendere troppo (tipo Kairos)
|
|
-- BladeSideSingle (taglio di lama singolo di fianco)
|
|
if Machining[1].bIsApplicable and ( dMaxMatBladeSideSingle - BeamData.CUT_EXTRA) > Part.dWidth + 10 * GEO.EPS_SMALL then
|
|
Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
|
|
Machining.sTypeMachining = 'BladeSideSingle'
|
|
Machining[2].bIsApplicable = false
|
|
Machining[3].bIsApplicable = false
|
|
Machining[4].bIsApplicable = false
|
|
return Machining
|
|
-- TODO considerare di tagliare con il massimo materiale possibile per non salire troppo in Z (macchine tipo PF), oppure non scendere troppo (tipo Kairos)
|
|
-- BladeSideDouble (taglio di lama doppio di fianco)
|
|
elseif Machining[1].bIsApplicable and ( dMaxMatBladeSideDouble - BeamData.CUT_EXTRA) > Part.dWidth + 10 * GEO.EPS_SMALL then
|
|
Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
|
|
Strategy.Result.dMRR = Strategy.Result.dMRR/2
|
|
Machining.sTypeMachining = 'BladeSideDouble'
|
|
Machining[2].bIsApplicable = false
|
|
Machining[3].bIsApplicable = false
|
|
Machining[4].bIsApplicable = false
|
|
return Machining
|
|
-- BladeHorizontalSingle (taglio di lama singolo orizzontale)
|
|
elseif Machining[1].bIsApplicable and ( dMaxMatBladeHorizontalSingle - BeamData.CUT_EXTRA) > Part.dHeight + 10 * GEO.EPS_SMALL then
|
|
Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
|
|
Machining.sTypeMachining = 'BladeHorizontalSingle'
|
|
Machining[2].bIsApplicable = false
|
|
Machining[3].bIsApplicable = false
|
|
Machining[4].bIsApplicable = false
|
|
return Machining
|
|
-- BladeHorizontalDouble (taglio di lama doppio orizzontale)
|
|
elseif Machining[1].bIsApplicable and Machining[2].bIsApplicable and
|
|
( dMaxMatBladeHorizontalSingle + dMaxMatBladeHorizontalDouble - BeamData.CUT_EXTRA) > Part.dHeight + 10 * GEO.EPS_SMALL then
|
|
Strategy.Result.nQuality = FeatureLib.GetFeatureQuality( 'Blade')
|
|
Strategy.Result.dMRR = Strategy.Result.dMRR/2
|
|
Machining.sTypeMachining = 'BladeHorizontalDouble'
|
|
Machining[1].ToolInfo.dMaxMatBladeFromTop = dMaxMatBladeHorizontalSingle
|
|
Machining[2].ToolInfo.dMaxMatBladeFromDown = dMaxMatBladeHorizontalDouble
|
|
Machining[3].bIsApplicable = false
|
|
Machining[4].bIsApplicable = false
|
|
return Machining
|
|
|
|
-- TODO : casi con motosega da completare
|
|
-- ChainSawHorizontal (motosega)
|
|
-- ChainSawSideSingle (motosega)
|
|
-- ChainSawSideDouble (motosega)
|
|
-- ChainSawPlusBlade (motosega più lama orizzontale)
|
|
-- Mill (svuotatura)
|
|
end
|
|
|
|
-- se non ho trovato neanche una lavorazione completa, non posso separare
|
|
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 = 'Split not possible'
|
|
end
|
|
|
|
return Machining
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function SPLITCUT.Make( bAddMachining, Proc, Part, CustomParameters)
|
|
Strategy = LoadStrategyParameters( CustomParameters)
|
|
local bAreAllMachiningsAdded = true
|
|
local Splitting = {}
|
|
local AuxiliaryData = {}
|
|
|
|
Strategy.sSplitStrategy = GetSplitStrategy( Proc, Part)
|
|
if bAddMachining then
|
|
-- inserimento smussi su spigoli del taglio
|
|
if Strategy.Parameters.bMakeChamfer then
|
|
MakeChamfer()
|
|
end
|
|
|
|
local OptionalParameters = {}
|
|
-- applico le lavorazioni
|
|
----------------------------------------------------------------------------------
|
|
if Strategy.sSplitStrategy.sTypeMachining == 'BladeSideSingle' then
|
|
OptionalParameters = {}
|
|
OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
|
|
OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_BACK
|
|
OptionalParameters.sDepth = 0
|
|
|
|
-- TODO gestire lavorazione a cubetti
|
|
|
|
if Strategy.bSplit then
|
|
OptionalParameters.sUserNotes = 'Split;'
|
|
else
|
|
OptionalParameters.sUserNotes = 'Cut;'
|
|
end
|
|
AuxiliaryData.bAddNewPhase = true
|
|
|
|
local EdgeToMachine = GetEdgeToMachine( Proc, -Y_AX())
|
|
-- approccio e retrazione
|
|
OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
|
|
Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
|
|
MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
|
|
----------------------------------------------------------------------------------
|
|
elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeSideDouble' then
|
|
OptionalParameters = {}
|
|
OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
|
|
-- Taglio lato frontale
|
|
OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_BACK
|
|
OptionalParameters.sDepth = 0
|
|
OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
|
|
|
|
-- TODO gestire lavorazione a cubetti
|
|
|
|
if Strategy.bSplit then
|
|
OptionalParameters.sUserNotes = 'PreSplit;'
|
|
else
|
|
OptionalParameters.sUserNotes = 'PreCut;'
|
|
end
|
|
|
|
local EdgeToMachine = GetEdgeToMachine( Proc, -Y_AX())
|
|
-- approccio e retrazione
|
|
OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
|
|
Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
|
|
MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
|
|
|
|
-- Taglio lato dietro
|
|
OptionalParameters = {}
|
|
Splitting = {}
|
|
AuxiliaryData = {}
|
|
OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
|
|
OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_FRONT
|
|
OptionalParameters.sDepth = 0
|
|
OptionalParameters.dRadialOffset = ( Part.dWidth - BeamData.CUT_EXTRA) / 2
|
|
|
|
-- TODO gestire lavorazione a cubetti
|
|
|
|
if Strategy.bSplit then
|
|
OptionalParameters.sUserNotes = 'Split;'
|
|
else
|
|
OptionalParameters.sUserNotes = 'Cut;'
|
|
end
|
|
AuxiliaryData.bAddNewPhase = true
|
|
|
|
EdgeToMachine = GetEdgeToMachine( Proc, Y_AX())
|
|
-- approccio e retrazione
|
|
OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
|
|
Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
|
|
MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
|
|
----------------------------------------------------------------------------------
|
|
elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeHorizontalSingle' then
|
|
OptionalParameters = {}
|
|
OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
|
|
OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
|
|
OptionalParameters.sDepth = 0
|
|
OptionalParameters.dRadialOffset = -BeamData.CUT_EXTRA
|
|
|
|
-- TODO gestire lavorazione a cubetti
|
|
|
|
if Strategy.bSplit then
|
|
OptionalParameters.sUserNotes = 'Split;'
|
|
else
|
|
OptionalParameters.sUserNotes = 'Cut;'
|
|
end
|
|
AuxiliaryData.bAddNewPhase = true
|
|
|
|
local EdgeToMachine = GetEdgeToMachine( Proc, Z_AX())
|
|
-- approccio e retrazione
|
|
OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
|
|
Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
|
|
MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
|
|
----------------------------------------------------------------------------------
|
|
elseif Strategy.sSplitStrategy.sTypeMachining == 'BladeHorizontalDouble' then
|
|
OptionalParameters = {}
|
|
OptionalParameters.nToolIndex = Strategy.sSplitStrategy[1].ToolInfo.nToolIndex
|
|
-- Taglio lato frontale
|
|
OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_DOWN
|
|
OptionalParameters.sDepth = 0
|
|
local dExtraMaxMat = ( Strategy.sSplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + Strategy.sSplitStrategy[2].ToolInfo.dMaxMatBladeFromDown - Part.dHeight - BeamData.CUT_EXTRA) / 2
|
|
OptionalParameters.dRadialOffset = Part.dHeight - Strategy.sSplitStrategy[1].ToolInfo.dMaxMatBladeFromTop + dExtraMaxMat
|
|
|
|
-- TODO gestire lavorazione a cubetti
|
|
|
|
if Strategy.bSplit then
|
|
OptionalParameters.sUserNotes = 'PreSplit;'
|
|
else
|
|
OptionalParameters.sUserNotes = 'PreCut;'
|
|
end
|
|
|
|
local EdgeToMachine = GetEdgeToMachine( Proc, Z_AX())
|
|
-- approccio e retrazione
|
|
OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
|
|
Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
|
|
MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
|
|
|
|
-- Taglio lato dietro
|
|
OptionalParameters = {}
|
|
Splitting = {}
|
|
AuxiliaryData = {}
|
|
OptionalParameters.nToolIndex = Strategy.sSplitStrategy[2].ToolInfo.nToolIndex
|
|
OptionalParameters.nFaceuse = MCH_MILL_FU.ORTHO_TOP
|
|
OptionalParameters.sDepth = 0
|
|
OptionalParameters.dRadialOffset = Part.dHeight - Strategy.sSplitStrategy[2].ToolInfo.dMaxMatBladeFromDown + dExtraMaxMat
|
|
|
|
-- TODO gestire lavorazione a cubetti
|
|
|
|
if Strategy.bSplit then
|
|
OptionalParameters.sUserNotes = 'Split;'
|
|
else
|
|
OptionalParameters.sUserNotes = 'Cut;'
|
|
end
|
|
AuxiliaryData.bAddNewPhase = true
|
|
|
|
EdgeToMachine = GetEdgeToMachine( Proc, -Z_AX())
|
|
-- approccio e retrazione
|
|
OptionalParameters.LeadIn, OptionalParameters.LeadOut = CalculateLeadInOut( Splitting, EdgeToMachine)
|
|
Splitting = FaceByBlade.Make( Proc, Part, Proc.Faces[1].id, EdgeToMachine, OptionalParameters)
|
|
MachiningLib.AddNewMachining( Proc, Splitting, AuxiliaryData)
|
|
----------------------------------------------------------------------------------
|
|
elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawHorizontal' then
|
|
; -- TODO
|
|
----------------------------------------------------------------------------------
|
|
elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawSideSingle' then
|
|
; -- TODO
|
|
----------------------------------------------------------------------------------
|
|
elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawSideDouble' then
|
|
; -- TODO
|
|
----------------------------------------------------------------------------------
|
|
elseif Strategy.sSplitStrategy.sTypeMachining == 'ChainSawPlusBlade' then
|
|
; -- TODO
|
|
----------------------------------------------------------------------------------
|
|
elseif Strategy.sSplitStrategy.sTypeMachining == 'Mill' then
|
|
; -- TODO
|
|
----------------------------------------------------------------------------------
|
|
end
|
|
|
|
return bAreAllMachiningsAdded, Strategy.Result
|
|
else
|
|
return nil, Strategy.Result
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
|
|
return SPLITCUT |