luca.mazzoleni
881 lines
41 KiB
Lua
881 lines
41 KiB
Lua
-- Strategia: STR0015
|
|
-- Descrizione
|
|
-- Fresatura di contorno
|
|
-- Feature tipo Profilo arcuato, Convesso, Concavo, Arco
|
|
|
|
|
|
-- carico librerie
|
|
local BeamLib = require( 'BeamLib')
|
|
local BeamData = require( 'BeamDataNew')
|
|
local MachiningLib = require( 'MachiningLib')
|
|
local FeatureLib = require( 'FeatureLib')
|
|
local FaceData = require( 'FaceData')
|
|
local ID = require( 'Identity')
|
|
|
|
-- strategie di base
|
|
local BladeToWaste = require('BLADETOWASTE')
|
|
local FaceByBlade = require('FACEBYBLADE')
|
|
local FaceByMill = require('FACEBYMILL')
|
|
|
|
-- Tabella per definizione modulo
|
|
local STR0015 = {}
|
|
local Strategy = {}
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetEdgeToMachine( Proc, idFace, vtEdge)
|
|
local Edge
|
|
local dBestEdgeAngle = 999
|
|
for i = 1, #Proc.Faces[idFace].Edges do
|
|
local dAngle = abs( GetAngle( Proc.Faces[idFace].Edges[i].vtN, vtEdge) or 999)
|
|
if dAngle < dBestEdgeAngle then
|
|
dBestEdgeAngle = dAngle
|
|
Edge = Proc.Faces[idFace].Edges[i]
|
|
end
|
|
end
|
|
return Edge
|
|
end
|
|
|
|
|
|
-- TODO funzione recuperata da beam vecchio, verificare se possibile migliorare
|
|
---------------------------------------------------------------------
|
|
local function GetSawCutData( Proc, AuxId, vtNF, vtN)
|
|
local ptStart, vtNP
|
|
|
|
if ID.IsHeadConcaveProfile( Proc) or ID.IsHeadConvexProfile( Proc) or ID.IsHeadProfile( Proc) or ID.IsFrontProfile( Proc) then
|
|
vtNP = Vector3d( vtN)
|
|
-- comincio con la normale a 45deg
|
|
for i = 1, 3 do
|
|
if vtNP[i] > GEO.EPS_SMALL then
|
|
vtNP[i] = 1
|
|
elseif vtNP[i] < -GEO.EPS_SMALL then
|
|
vtNP[i] = -1
|
|
end
|
|
end
|
|
vtNP:normalize()
|
|
-- assegno un punto di passaggio
|
|
ptStart = EgtMP( AuxId, GDB_ID.ROOT)
|
|
local frOCS = Frame3d( ptStart, vtNP) ;
|
|
local b3Box = EgtGetBBoxRef( AuxId, GDB_BB.STANDARD, frOCS)
|
|
ptStart = ptStart + vtNP * ( b3Box:getMax():getZ() + 10.0)
|
|
elseif ID.IsHeadCamberedProfile( Proc) then
|
|
vtNP = Vector3d( vtNF)
|
|
-- comincio con la normale a 45deg
|
|
for i = 1, 3 do
|
|
if vtNP[i] > GEO.EPS_SMALL then
|
|
vtNP[i] = 1
|
|
elseif vtNP[i] < -GEO.EPS_SMALL then
|
|
vtNP[i] = -1
|
|
end
|
|
end
|
|
vtNP:normalize()
|
|
-- assegno un punto di passaggio
|
|
ptStart = EgtSP( AuxId, GDB_ID.ROOT) + vtNP * 5.0
|
|
-- determino asse di rotazione
|
|
local vtRot = - Y_AX()
|
|
if vtNF:getX() < 0 then vtRot = - vtRot end
|
|
if vtNF:getZ() < -0.1 then
|
|
vtRot = - vtRot
|
|
elseif vtNF:getY() < -0.1 then
|
|
vtRot:rotate( X_AX(), 90)
|
|
elseif vtNF:getY() > 0.1 then
|
|
vtRot:rotate( X_AX(), -90)
|
|
end
|
|
-- miglioro l'inclinazione (ripartendo da faccia perpendicolare asse trave)
|
|
vtNP[2] = 0 vtNP[3] = 0
|
|
local dRot = 45
|
|
for i = 1, 4 do
|
|
local vtNP2 = Vector3d( vtNP)
|
|
vtNP2:rotate( vtRot, dRot)
|
|
local frRef = Frame3d( ptStart, vtNP2)
|
|
local b3Box = EgtGetBBoxRef( AuxId, GDB_BB.STANDARD, frRef)
|
|
if b3Box:getMax():getZ() < -3 then
|
|
vtNP = Vector3d( vtNP2)
|
|
end
|
|
dRot = dRot / 2
|
|
end
|
|
end
|
|
-- restituisco i dati del piano
|
|
return ptStart, vtNP
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetRoughStrategy( Proc, Part, bSaveAddedGeometries)
|
|
local Machining = {}
|
|
local Result = {}
|
|
|
|
-- ====== Taglio di sgrossatura generale su tutto il profilo ======
|
|
local vtNF = EgtSurfTmFacetNormVersor( Proc.id, Proc.nFct-1, GDB_ID.ROOT)
|
|
local nMidFacet = Proc.nFct // 2 -- faccia a metà circa
|
|
local vtN = EgtSurfTmFacetNormVersor( Proc.id, nMidFacet, GDB_ID.ROOT)
|
|
|
|
local idAddGroup
|
|
if bSaveAddedGeometries then
|
|
idAddGroup = BeamLib.GetAddGroup( Part.id)
|
|
else
|
|
idAddGroup = Part.idTempGroup
|
|
end
|
|
-- aggiungo piano di sgrossatura e lo lavoro
|
|
local ptStart, vtNP = GetSawCutData( Proc, Proc.idAddAuxGeom, vtNF, vtN)
|
|
local AddId = EgtSurfTmPlaneInBBox( idAddGroup, ptStart, vtNP, Part.b3Part, GDB_RT.GLOB)
|
|
-- se la faccia è stata creata
|
|
if AddId then
|
|
|
|
-- creo piano di taglio sulla testa del tenone
|
|
local OptionalParameters = { dMaxWasteVolume = Strategy.Parameters.dMaxWasteVolume,
|
|
dMaxWasteLength = Strategy.Parameters.dMaxWasteLength,
|
|
bReduceBladePath = Strategy.Parameters.bReduceBladePath
|
|
}
|
|
Machining, Result = BladeToWaste.Make( AddId, Part, OptionalParameters)
|
|
|
|
-- se non ci sono lavorazioni, provo con fresa
|
|
if not Machining or #Machining == 0 then
|
|
Machining.bCuttingWithMill = true
|
|
-- === ricerca utensile per svuotare taglio iniziale, se taglio non possibile ===
|
|
if not( Proc.AffectedFaces.bLeft) or Strategy.bCanMoveAfterSplit then
|
|
ToolSearchParameters = {}
|
|
|
|
-- TODO SISTEMARE!!! qui la svuotatura non deve limitare l'elevazione se aperta da tutti i lati. In futuro si deve passare 0 come elevazione
|
|
ToolSearchParameters.dElevation = EgtSurfTmFacetElevationInBBox( AddId, 0, Part.b3Part, true, GDB_ID.ROOT)
|
|
|
|
ToolSearchParameters.vtToolDirection = vtNP
|
|
ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sPocketingList, 'Pocketing')
|
|
Machining.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
|
|
-- TODO anche il test sul ResidualDepth va tolto
|
|
if Machining.ToolInfo.nToolIndex and ( Machining.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL) then
|
|
Machining.bIsApplicable = true
|
|
local ParametersMRR = {}
|
|
ParametersMRR.nToolIndex = Machining.ToolInfo.nToolIndex
|
|
Result.dMRR = MachiningLib.GetToolMRR( ParametersMRR)
|
|
Result.sStatus = 'Completed'
|
|
Machining.Steps = {}
|
|
Machining.LeadIn = {}
|
|
Machining.nType = MCH_MY.POCKETING
|
|
Machining.nSubType = MCH_POCK_SUB.SPIRALIN
|
|
Machining.LeadIn.nType = MCH_POCK_LI.ZIGZAG
|
|
Machining.Steps.dStep = TOOLS[Machining.ToolInfo.nToolIndex].dStep
|
|
Machining.Steps.dSideStep = TOOLS[Machining.ToolInfo.nToolIndex].dSideStep
|
|
Machining.nToolIndex = Machining.ToolInfo.nToolIndex
|
|
Machining.LeadIn.dTangentDistance = TOOLS[Machining.ToolInfo.nToolIndex].dDiameter/2
|
|
Machining.LeadIn.dElevation = TOOLS[Machining.ToolInfo.nToolIndex].dDiameter/2
|
|
Machining.sDepth = 0
|
|
Machining.Geometry = {{ AddId, 0}}
|
|
Machining.vtToolDirection = vtNF
|
|
if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
|
|
Machining.sStage = 'AfterTail'
|
|
end
|
|
-- tempo di svuotatura
|
|
Result.dTimeToMachine = MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Machining, Part)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return Machining, Result
|
|
end
|
|
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetEdgeWithCornerStrategy( Proc, Part)
|
|
local Machining = {}
|
|
local Result = { dCompletionPercentage = 100}
|
|
|
|
local nFirstFacet = 0 -- faccia iniziale
|
|
local nLastFacet = Proc.nFct - 1 -- faccia finale
|
|
-- verifico se necessari ripassi agli estremi negli angoli
|
|
local _, _, _, dFirstAng = EgtSurfTmFacetsContact( Proc.id, nFirstFacet, nFirstFacet + 1, GDB_ID.ROOT)
|
|
local bFirstTrim = ( dFirstAng and dFirstAng < -30)
|
|
local _, _, _, dLastAng = EgtSurfTmFacetsContact( Proc.id, nLastFacet, nLastFacet - 1, GDB_ID.ROOT)
|
|
local bLastTrim = ( dLastAng and dLastAng < -30)
|
|
local nMidFacet = ( nLastFacet + 1) // 2 -- faccia a metà circa
|
|
local vtN = EgtSurfTmFacetNormVersor( Proc.id, nMidFacet, GDB_ID.ROOT)
|
|
|
|
|
|
-- se non ci sono angoli da pulire si esce subito
|
|
if Strategy.Parameters.sConcaveFaceStrategy == 'NONE' or ( not bFirstTrim and not bLastTrim) then
|
|
return nil, nil
|
|
end
|
|
|
|
local FacesToGet = {}
|
|
if bFirstTrim then
|
|
table.insert( FacesToGet, nFirstFacet)
|
|
table.insert( FacesToGet, nFirstFacet+1)
|
|
end
|
|
if bLastTrim then
|
|
table.insert( FacesToGet, nLastFacet - 1)
|
|
table.insert( FacesToGet, nLastFacet)
|
|
end
|
|
-- ricavo info facce da lavorare
|
|
Proc.Faces = FaceData.GetFacesInfo( Proc, Part, FacesToGet)
|
|
|
|
-- direzioni di lavorazione
|
|
local vtCutDir1
|
|
-- se è diretta verso alto o basso
|
|
if abs( vtN:getZ()) > abs( vtN:getY()) then
|
|
if vtN:getZ() > 0 then
|
|
vtCutDir1 = Z_AX()
|
|
else
|
|
vtCutDir1 = -Z_AX()
|
|
end
|
|
-- altrimenti è di fianco
|
|
else
|
|
if vtN:getY() > 0 then
|
|
vtCutDir1 = Y_AX()
|
|
else
|
|
vtCutDir1 = -Y_AX()
|
|
end
|
|
end
|
|
|
|
local vtCutDir2
|
|
if vtN:getX() > 0 then
|
|
vtCutDir2 = X_AX()
|
|
else
|
|
vtCutDir2 = -X_AX()
|
|
end
|
|
|
|
local nMachiningsToAdd
|
|
|
|
-- AUTO = preferisce lama. Se non è possibile prende fresa
|
|
-- BLADE_FORCED = solo lama, altriemnti non applica nulla (potrebbe essere necessario un ribaltamento)
|
|
-- MILL_FORCED = solo fresa, altriemnti non applica nulla (potrebbe essere necessario un ribaltamento)
|
|
if Strategy.Parameters.sConcaveFaceStrategy == 'AUTO' or Strategy.Parameters.sConcaveFaceStrategy == 'BLADE_FORCED' then
|
|
|
|
nMachiningsToAdd = 0
|
|
|
|
-- TODO c'è una funzione che ritorni l'edge di connessione tra una faccia e un'altra?
|
|
-- lavorazione faccia 1 spigolo finale
|
|
if bLastTrim then
|
|
nMachiningsToAdd = nMachiningsToAdd + 1
|
|
local EdgeToMachine = GetEdgeToMachine( Proc, nLastFacet+1, vtCutDir1)
|
|
local Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[nLastFacet+1], EdgeToMachine)
|
|
if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
|
|
Cutting.sStage = 'AfterTail'
|
|
end
|
|
if Cutting.bIsApplicable then
|
|
table.insert( Machining, Cutting)
|
|
end
|
|
end
|
|
|
|
-- lavorazione faccia 1 spigolo iniziale
|
|
if bFirstTrim then
|
|
nMachiningsToAdd = nMachiningsToAdd + 1
|
|
local EdgeToMachine = GetEdgeToMachine( Proc, nFirstFacet+2, vtCutDir1)
|
|
local Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[nFirstFacet+2], EdgeToMachine)
|
|
if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
|
|
Cutting.sStage = 'AfterTail'
|
|
end
|
|
if Cutting.bIsApplicable then
|
|
table.insert( Machining, Cutting)
|
|
end
|
|
end
|
|
|
|
-- lavorazione faccia 2 spigolo finale
|
|
if bLastTrim then
|
|
nMachiningsToAdd = nMachiningsToAdd + 1
|
|
EdgeToMachine = GetEdgeToMachine( Proc, nLastFacet, vtCutDir2)
|
|
Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[nLastFacet], EdgeToMachine)
|
|
if Cutting.bIsApplicable then
|
|
table.insert( Machining, Cutting)
|
|
end
|
|
end
|
|
|
|
-- lavorazione faccia 2 spigolo iniziale
|
|
if bFirstTrim then
|
|
nMachiningsToAdd = nMachiningsToAdd + 1
|
|
local EdgeToMachine = GetEdgeToMachine( Proc, nFirstFacet+1, vtCutDir2)
|
|
local Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[nFirstFacet+1], EdgeToMachine)
|
|
if Cutting.bIsApplicable then
|
|
table.insert( Machining, Cutting)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se non ci sono lavorazioni provo a pulire spigoli con fresa, a patto che non sia stato forzato con lama
|
|
if ( not nMachiningsToAdd or ( #Machining < nMachiningsToAdd)) and Strategy.Parameters.sConcaveFaceStrategy ~= 'BLADE_FORCED' then
|
|
|
|
Machining = {}
|
|
nMachiningsToAdd = 0
|
|
|
|
-- TODO c'è una funzione che ritorni l'edge di connessione tra una faccia e un'altra?
|
|
-- lavorazione faccia 1 spigolo iniziale
|
|
if bFirstTrim then
|
|
nMachiningsToAdd = nMachiningsToAdd + 1
|
|
local EdgeToMachine = GetEdgeToMachine( Proc, nFirstFacet+2, vtCutDir1)
|
|
local Milling = FaceByMill.Make( Proc, Part, Proc.Faces[nFirstFacet+2], EdgeToMachine)
|
|
if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
|
|
Milling.sStage = 'AfterTail'
|
|
end
|
|
if Milling.bIsApplicable then
|
|
table.insert( Machining, Milling)
|
|
end
|
|
end
|
|
|
|
-- lavorazione faccia 2 spigolo finale
|
|
if bLastTrim then
|
|
nMachiningsToAdd = nMachiningsToAdd + 1
|
|
EdgeToMachine = GetEdgeToMachine( Proc, nLastFacet, vtCutDir2)
|
|
local Milling = FaceByMill.Make( Proc, Part, Proc.Faces[nLastFacet], EdgeToMachine)
|
|
if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
|
|
Milling.sStage = 'AfterTail'
|
|
end
|
|
if Milling.bIsApplicable then
|
|
table.insert( Machining, Milling)
|
|
end
|
|
end
|
|
end
|
|
|
|
if nMachiningsToAdd and ( #Machining < nMachiningsToAdd) then
|
|
Result = { dCompletionPercentage = ( #Machining / nMachiningsToAdd)}
|
|
end
|
|
|
|
return Machining, Result
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetChamferStrategy( Proc, Part)
|
|
local Machining = {}
|
|
local Result = {}
|
|
local ToolSearchParameters = {}
|
|
local dExtraDepth = 2
|
|
local vtExtr = EgtCurveExtrusion( Proc.idAddAuxGeom, GDB_RT.GLOB)
|
|
local bIsHorizontal = abs( vtExtr:getZ()) < 10 * GEO.EPS_SMALL
|
|
local bToolInvert = ( vtExtr:getZ() < -0.1)
|
|
|
|
if Strategy.Parameters.dDepthChamfer > 100 * GEO.EPS_SMALL then
|
|
-- controllo conformità affondamento smussi
|
|
Strategy.Parameters.dDepthChamfer = EgtClamp( Strategy.Parameters.dDepthChamfer, 0.1, 5)
|
|
|
|
-- si prapara tabella con parametri di base comuni a tutte le lavorazioni
|
|
local BasicMach = MachiningLib.InitMachiningParameters( MCH_MY.MILLING)
|
|
BasicMach.Geometry = {{ Proc.idAddAuxGeom, -1}}
|
|
BasicMach.nType = MCH_MY.MILLING
|
|
BasicMach.sDepth = Strategy.Parameters.dDepthChamfer + dExtraDepth
|
|
-- LeadIn / LeadOut
|
|
BasicMach.LeadIn.nType = MCH_MILL_LI.NONE
|
|
BasicMach.LeadOut.nType = MCH_MILL_LI.NONE
|
|
BasicMach.LeadIn.dStartAddLength = 5
|
|
BasicMach.LeadOut.dEndAddLength = 5
|
|
if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
|
|
BasicMach.sStage = 'AfterTail'
|
|
end
|
|
BasicMach.ptEdge1 = EgtSP( Proc.idAddAuxGeom, GDB_ID.ROOT)
|
|
BasicMach.ptEdge2 = EgtEP( Proc.idAddAuxGeom, GDB_ID.ROOT)
|
|
BasicMach.dEdgeLength = EgtCurveLength( Proc.idAddAuxGeom)
|
|
BasicMach.vtEdgeDirection = EgtSV( Proc.idAddAuxGeom, GDB_ID.ROOT) + EgtMV( Proc.idAddAuxGeom, GDB_ID.ROOT) + EgtEV( Proc.idAddAuxGeom, GDB_ID.ROOT)
|
|
BasicMach.dLengthOnX = Proc.b3Box:getDimX()
|
|
-- parametri di ricerca utensile comuni a tutte le lavorazioni
|
|
ToolSearchParameters.sMillShape = 'VMILL'
|
|
ToolSearchParameters.dElevation = Strategy.Parameters.dDepthChamfer
|
|
ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sMillingList, 'MillingSmooth')
|
|
|
|
-- se lavorazione orizzontale
|
|
if bIsHorizontal then
|
|
local Milling = {}
|
|
ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, -vtExtr, vtExtr)
|
|
Milling.ToolInfo = {}
|
|
Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
-- se trovato utensile adatto
|
|
if Milling.ToolInfo.nToolIndex then
|
|
Milling.vtToolDirection = ToolSearchParameters.vtToolDirection
|
|
|
|
Milling.nToolIndex = Milling.ToolInfo.nToolIndex
|
|
Milling.dRadialOffset = dExtraDepth * cos( TOOLS[Milling.nToolIndex].dSideAngle)
|
|
|
|
Milling.bInvert = EgtIf( TOOLS[Milling.nToolIndex].bIsCCW, false, true)
|
|
Milling.nWorkside = EgtIf( TOOLS[Milling.nToolIndex].bIsCCW, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
|
|
Milling = BeamLib.MergeTables( BasicMach, Milling)
|
|
table.insert( Machining, Milling)
|
|
|
|
local Milling2 = BeamLib.TableCopyDeep( Milling)
|
|
Milling2.bToolInvert = true
|
|
Milling2.bInvert = EgtIf( TOOLS[Milling2.nToolIndex].bIsCCW, true, false)
|
|
Milling2.nWorkside = EgtIf( TOOLS[Milling2.nToolIndex].bIsCCW, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
|
|
|
|
table.insert( Machining, Milling2)
|
|
end
|
|
-- se lavorazione verticale
|
|
else
|
|
-- si cerca utensile 1
|
|
local Milling = {}
|
|
ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, -vtExtr, vtExtr)
|
|
Milling.ToolInfo = {}
|
|
Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
Milling.vtToolDirection = ToolSearchParameters.vtToolDirection
|
|
|
|
-- si cerca utensile 2
|
|
local Milling2 = {}
|
|
ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, vtExtr, -vtExtr)
|
|
Milling2.ToolInfo = {}
|
|
Milling2.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
Milling2.vtToolDirection = ToolSearchParameters.vtToolDirection
|
|
Milling2.bToolInvert = true
|
|
|
|
-- se trovato utensile 1 adatto
|
|
if Milling.ToolInfo.nToolIndex then
|
|
|
|
Milling.nToolIndex = Milling.ToolInfo.nToolIndex
|
|
Milling.dRadialOffset = dExtraDepth * cos( TOOLS[Milling.nToolIndex].dSideAngle)
|
|
|
|
Milling.bInvert = EgtIf( TOOLS[Milling.nToolIndex].bIsCCW, false, true)
|
|
Milling.nWorkside = EgtIf( TOOLS[Milling.nToolIndex].bIsCCW, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
|
|
Milling = BeamLib.MergeTables( BasicMach, Milling)
|
|
table.insert( Machining, Milling)
|
|
end
|
|
|
|
-- se trovato utensile 2 adatto
|
|
if Milling2.ToolInfo.nToolIndex then
|
|
|
|
Milling2.nToolIndex = Milling2.ToolInfo.nToolIndex
|
|
Milling2.dRadialOffset = dExtraDepth * cos( TOOLS[Milling2.nToolIndex].dSideAngle)
|
|
|
|
Milling2.bToolInvert = true
|
|
Milling2.bInvert = EgtIf( TOOLS[Milling2.nToolIndex].bIsCCW, true, false)
|
|
Milling2.nWorkside = EgtIf( TOOLS[Milling2.nToolIndex].bIsCCW, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
|
|
Milling2 = BeamLib.MergeTables( BasicMach, Milling2)
|
|
table.insert( Machining, Milling2)
|
|
end
|
|
end
|
|
end
|
|
|
|
return Machining, Result
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetArcStrategy( Proc, Part)
|
|
local Machining = {}
|
|
local Result = { dCompletionPercentage = 100}
|
|
local ToolSearchParameters = {}
|
|
|
|
-- recupero i dati della curva e del profilo
|
|
local dDepth = abs( EgtCurveThickness( Proc.idAddAuxGeom))
|
|
local vtExtr = EgtCurveExtrusion( Proc.idAddAuxGeom, GDB_RT.GLOB)
|
|
local bToolInvert = ( vtExtr:getZ() < -0.1)
|
|
local bIsHorizontal = abs( vtExtr:getZ()) < 10 * GEO.EPS_SMALL
|
|
local bIsFeatureDown = Proc.AffectedFaces.bBottom and not Proc.AffectedFaces.bTop
|
|
local bIsFeatureBack = Proc.AffectedFaces.bBack and not Proc.AffectedFaces.bFront
|
|
local bForceStrip = Strategy.Parameters.bForceStrip
|
|
local dDimStrip = EgtIf( Strategy.Parameters.dStripWidth < 100 * GEO.EPS_SMALL, nil, Strategy.Parameters.dStripWidth)
|
|
local sMaxDepth = dDepth * 2
|
|
|
|
local bExecStrip = false
|
|
-- se la lavorazione si trova nella parte inferiore o in battuta dietro, il codolo va sempre lasciato
|
|
if ID.IsRoundArch( Proc) and ( bIsFeatureDown or bIsFeatureBack or bForceStrip) then
|
|
if bIsFeatureDown or bIsFeatureBack then
|
|
dDimStrip = dDimStrip or max( BeamData.DIM_STRIP or 5, 5)
|
|
else
|
|
dDimStrip = dDimStrip or max( BeamData.DIM_STRIP_SMALL or 5, 1)
|
|
end
|
|
bExecStrip = true
|
|
end
|
|
if not bExecStrip then
|
|
dDimStrip = 0
|
|
end
|
|
|
|
-- la passata di finitura c'è sempre
|
|
local nPassages = 1
|
|
-- si verifica se fare passaggio di sgrossatura con fresa
|
|
if not bExecStrip and Strategy.Parameters.dOverMaterial > 100 * GEO.EPS_SMALL then
|
|
nPassages = 2
|
|
end
|
|
|
|
-- ciclo su numero passate (2 in caso di sgrossatura + finitura)
|
|
for nCycle = nPassages, 1, -1 do
|
|
local nMaxDiamMill = EgtIf( nCycle == 1, Strategy.Parameters.dMaxCornerRadius * 2, nil)
|
|
local sTypeTool = EgtIf( nCycle == 1 and nPassages == 2, 'MillingFinish', 'Milling')
|
|
-- se lavorazione orizzontale
|
|
if bIsHorizontal then
|
|
local bDouble
|
|
local Milling = MachiningLib.InitMachiningParameters( MCH_MY.MILLING)
|
|
ToolSearchParameters = {}
|
|
ToolSearchParameters.sMillShape = 'STANDARD'
|
|
ToolSearchParameters.dElevation = EgtIf( bExecStrip, ( dDepth - dDimStrip) / 2, dDepth + BeamData.MILL_OVERLAP)
|
|
ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, -vtExtr, vtExtr)
|
|
ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sMillingList, sTypeTool)
|
|
ToolSearchParameters.dMaxToolDiameter = nMaxDiamMill
|
|
Milling.ToolInfo = {}
|
|
Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
-- se posso lavorare in una passata, ma utensile trovato non completa la lavorazione,
|
|
-- allora provo a cercare utensile con massimo materiale sufficiente per fare le due passate, magari trova un utensile più prestante
|
|
if Milling.ToolInfo.nToolIndex then
|
|
if Milling.ToolInfo.dResidualDepth > 10 * GEO.EPS_SMALL and not bExecStrip then
|
|
bDouble = true
|
|
ToolSearchParameters.dElevation = ( dDepth + BeamData.MILL_OVERLAP) / 2
|
|
Milling.ToolInfo = {}
|
|
Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
end
|
|
Milling.vtToolDirection = ToolSearchParameters.vtToolDirection
|
|
|
|
if nCycle == 2 then
|
|
Milling.dRadialOffset = Strategy.Parameters.dOverMaterial
|
|
end
|
|
|
|
-- se non completo
|
|
if Milling.ToolInfo.dResidualDepth > 10 * GEO.EPS_SMALL then
|
|
sMaxDepth = ToolSearchParameters.dElevation - Milling.ToolInfo.dResidualDepth
|
|
-- si salva percentuala lavorata
|
|
Result.dCompletionPercentage = 100 - ceil( ( Milling.ToolInfo.dResidualDepth / ToolSearchParameters.dElevation) * 100)
|
|
end
|
|
if bDouble or bExecStrip then
|
|
if bDouble then
|
|
Milling.sDepth = min( sMaxDepth, ( dDepth + BeamData.MILL_OVERLAP) / 2)
|
|
else
|
|
Milling.sDepth = min( sMaxDepth, ( dDepth - dDimStrip) / 2)
|
|
end
|
|
table.insert( Machining, Milling)
|
|
local Milling2 = BeamLib.TableCopyDeep( Milling)
|
|
Milling2.bOtherDirection = true
|
|
table.insert( Machining, Milling2)
|
|
else
|
|
Milling.sDepth = min( sMaxDepth, dDepth + BeamData.MILL_OVERLAP)
|
|
table.insert( Machining, Milling)
|
|
end
|
|
end
|
|
-- se lavorazione verticale
|
|
else
|
|
ToolSearchParameters = {}
|
|
ToolSearchParameters.sMillShape = 'STANDARD'
|
|
ToolSearchParameters.dElevation = dDepth + BeamData.MILL_OVERLAP
|
|
ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sMillingList, sTypeTool)
|
|
ToolSearchParameters.dMaxToolDiameter = nMaxDiamMill
|
|
|
|
-- si cerca utensile 1
|
|
local Milling = MachiningLib.InitMachiningParameters( MCH_MY.MILLING)
|
|
ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, -vtExtr, vtExtr)
|
|
Milling.ToolInfo = {}
|
|
Milling.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
if nCycle == 2 then
|
|
Milling.dRadialOffset = Strategy.Parameters.dOverMaterial
|
|
end
|
|
Milling.vtToolDirection = ToolSearchParameters.vtToolDirection
|
|
Milling.bOtherDirection = bToolInvert
|
|
|
|
|
|
-- si cerca utensile 2
|
|
local Milling2 = MachiningLib.InitMachiningParameters( MCH_MY.MILLING)
|
|
ToolSearchParameters.vtToolDirection = EgtIf( bToolInvert, vtExtr, -vtExtr)
|
|
Milling2.ToolInfo = {}
|
|
Milling2.ToolInfo = MachiningLib.FindMill( Proc, ToolSearchParameters)
|
|
if nCycle == 2 then
|
|
Milling2.dRadialOffset = Strategy.Parameters.dOverMaterial
|
|
end
|
|
Milling2.vtToolDirection = ToolSearchParameters.vtToolDirection
|
|
Milling2.bOtherDirection = bToolInvert
|
|
|
|
-- se serve codolo
|
|
if bExecStrip then
|
|
local sDepthMachined = 0
|
|
-- se a disposizione entrambi gli utensili
|
|
if Milling.ToolInfo.nToolIndex and Milling2.ToolInfo.nToolIndex then
|
|
local dExtraDepth = ( dDepth - dDimStrip - ( Milling.ToolInfo.dResidualDepth + Milling2.ToolInfo.dResidualDepth)) / 2
|
|
Milling.sDepth = dDepth - Milling.ToolInfo.dResidualDepth - dExtraDepth
|
|
Milling2.sDepth = dDepth - Milling2.ToolInfo.dResidualDepth - dExtraDepth
|
|
sDepthMachined = Milling.sDepth + Milling2.sDepth
|
|
table.insert( Machining, Milling)
|
|
table.insert( Machining, Milling2)
|
|
-- se disponibile solo primo utensile
|
|
elseif Milling.ToolInfo.nToolIndex then
|
|
sMaxDepth = ToolSearchParameters.dElevation - Milling.ToolInfo.dResidualDepth
|
|
Milling.sDepth = min( sMaxDepth, dDepth - dDimStrip)
|
|
table.insert( Machining, Milling)
|
|
sDepthMachined = Milling.sDepth
|
|
-- se disponibile solo secondo utensile
|
|
elseif Milling2.ToolInfo.nToolIndex then
|
|
sMaxDepth = ToolSearchParameters.dElevation - Milling2.ToolInfo.dResidualDepth
|
|
Milling2.sDepth = min( sMaxDepth, dDepth - dDimStrip)
|
|
table.insert( Machining, Milling2)
|
|
sDepthMachined = Milling2.sDepth
|
|
-- nessun utensile disponibile
|
|
else
|
|
-- non si fa nulla
|
|
end
|
|
Result.dCompletionPercentage = min( ( sDepthMachined * 100) / ( dDepth - dDimStrip), 100)
|
|
-- altrimenti senza codolo
|
|
else
|
|
local sDepthMachined = 0
|
|
local dExtraDepth = ( dDepth - BeamData.MILL_OVERLAP - ( Milling.ToolInfo.dResidualDepth + Milling2.ToolInfo.dResidualDepth)) / 2
|
|
-- se utensile 1 esegue completamente (con almeno 1mm extra)
|
|
if Milling.ToolInfo.nToolIndex and Milling.ToolInfo.dResidualDepth < 1000 * GEO.EPS_SMALL then
|
|
sMaxDepth = ToolSearchParameters.dElevation - Milling.ToolInfo.dResidualDepth
|
|
Milling.sDepth = min( sMaxDepth, dDepth + BeamData.MILL_OVERLAP)
|
|
table.insert( Machining, Milling)
|
|
sDepthMachined = Milling.sDepth
|
|
-- se utensile 2 esegue completamente (con almeno 1mm extra)
|
|
elseif Milling2.ToolInfo.nToolIndex and Milling2.ToolInfo.dResidualDepth < 1000 * GEO.EPS_SMALL then
|
|
sMaxDepth = ToolSearchParameters.dElevation - Milling2.ToolInfo.dResidualDepth
|
|
Milling2.sDepth = min( sMaxDepth, dDepth + BeamData.MILL_OVERLAP)
|
|
table.insert( Machining, Milling2)
|
|
sDepthMachined = Milling2.sDepth
|
|
-- se possono lavorare entrambi
|
|
elseif Milling.ToolInfo.nToolIndex and Milling2.ToolInfo.nToolIndex then
|
|
Milling.sDepth = dDepth - Milling.ToolInfo.dResidualDepth - dExtraDepth
|
|
Milling2.sDepth = dDepth - Milling2.ToolInfo.dResidualDepth - dExtraDepth
|
|
table.insert( Machining, Milling)
|
|
table.insert( Machining, Milling2)
|
|
sDepthMachined = Milling.sDepth + Milling2.sDepth
|
|
-- se utensile 1 non completo
|
|
elseif Milling.ToolInfo.nToolIndex then
|
|
Milling.sDepth = ToolSearchParameters.dElevation - Milling.ToolInfo.dResidualDepth
|
|
table.insert( Machining, Milling)
|
|
sDepthMachined = Milling.sDepth
|
|
-- se utensile 2 non completo
|
|
elseif Milling2.ToolInfo.nToolIndex then
|
|
Milling2.sDepth = ToolSearchParameters.dElevation - Milling2.ToolInfo.dResidualDepth
|
|
table.insert( Machining, Milling2)
|
|
sDepthMachined = Milling2.sDepth
|
|
end
|
|
Result.dCompletionPercentage = min( ( sDepthMachined * 100) / ( dDepth - dDimStrip), 100)
|
|
end
|
|
end
|
|
end
|
|
|
|
Machining.bIsApplicable = #Machining > 0
|
|
|
|
return Machining, Result
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
local function GetFeatureResult( Proc)
|
|
local Result = { sStatus = 'Completed', dCompletionPercentage = 100, sInfo = ''}
|
|
local dPercentageChamfer = 10
|
|
local dPercentageEdgeCorner = 10
|
|
local dPercentageProfile = 80
|
|
|
|
-- se non ci sono lavorazioni di smusso
|
|
if not Strategy.Chamfer.Machinings or #Strategy.Chamfer.Machinings < 2 then
|
|
-- se esclusivo, non applicabile
|
|
if Strategy.Parameters.bOnlyChamfer then
|
|
Result = FeatureLib.GetStrategyResultNotApplicable( 'Not possible to machine chamfer only, tool not found!')
|
|
Result.dCompletionPercentage = 0
|
|
-- se non esclusivo, non completo
|
|
elseif Strategy.Parameters.dDepthChamfer > 100 * GEO.EPS_SMALL then
|
|
Result.dCompletionPercentage = Result.dCompletionPercentage - dPercentageChamfer -- gli smussi incidono per il 10%
|
|
dPercentageChamfer = 0
|
|
Result.sInfo = '- Chamfer not executed, tool not found!\n'
|
|
end
|
|
end
|
|
|
|
-- se richieste anche le altre lavorazioni
|
|
if not Strategy.Parameters.bOnlyChamfer then
|
|
-- per tutti tranne che per feature RoundArc
|
|
if not ID.IsRoundArch( Proc) and not ID.IsFreeContour( Proc) then
|
|
-- se sgrossatura da eseguire
|
|
if Strategy.Parameters.bExecRough then
|
|
if not Strategy.RoughCut.Machinings or #Strategy.RoughCut.Machinings == 0 then
|
|
Result.dCompletionPercentage = Result.dCompletionPercentage -- non incide sulla percentuale lavorata, solo messaggio che manca
|
|
Result.sInfo = Result.sInfo .. '- Roughing not executed\n'
|
|
end
|
|
end
|
|
-- se lavorazioni corner
|
|
if Strategy.EdgeWithCorner.Machinings and #Strategy.EdgeWithCorner.Machinings == 0 then
|
|
Result.dCompletionPercentage = Result.dCompletionPercentage - dPercentageEdgeCorner -- la pulizia dei corner incide per il 10%
|
|
dPercentageEdgeCorner = 0
|
|
Result.sInfo = Result.sInfo .. '- Corner not executed, material left\n'
|
|
end
|
|
end
|
|
|
|
-- lavorazione del profilo
|
|
if not Strategy.Profile.Machinings or #Strategy.Profile.Machinings == 0 then
|
|
Result.sInfo = Result.sInfo .. '- Profile not executed, tool not found!\n'
|
|
else
|
|
local dTotalPercentage = dPercentageProfile + dPercentageEdgeCorner + dPercentageChamfer
|
|
Result.dCompletionPercentage = Result.dCompletionPercentage - ( ( ( 100 - Strategy.Profile.Result.dCompletionPercentage) * dTotalPercentage) / 100)
|
|
end
|
|
end
|
|
|
|
-- si setta lo stato in base alla percentuale di completamento
|
|
if Result.dCompletionPercentage == 100 then
|
|
Result.sStatus = "Completed"
|
|
elseif Result.dCompletionPercentage == 0 then
|
|
Result.sStatus = "Not-Applicable"
|
|
else
|
|
Result.sStatus = "Not-Completed"
|
|
local dPercentageLeft = ceil( 100 - Result.dCompletionPercentage)
|
|
Result.sInfo = Result.sInfo .. '- Not Complete : left ' .. tostring( dPercentageLeft) .. '%\n'
|
|
end
|
|
Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( Result.dCompletionPercentage)
|
|
Result.dMRR = 1
|
|
-- se tutte le lavorazioni sono state eseguite, è la massima qualità che si possa ottenere, altrimenti qualità più bassa
|
|
if Result.sInfo == '' then
|
|
Result.dQuality = FeatureLib.GetStrategyQuality( 'BEST')
|
|
else
|
|
Result.dQuality = FeatureLib.GetStrategyQuality( 'MILL')
|
|
end
|
|
|
|
return Result
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
function STR0015.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 = STRATEGIES_CONFIG[CustomParameters.sStrategyId]
|
|
Strategy.sName = StrategyLib.Config.sStrategyId
|
|
Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( Proc, Part, CustomParameters, StrategyLib.Config)
|
|
Strategy.Chamfer = {}
|
|
Strategy.Chamfer.Machinings = {}
|
|
Strategy.Chamfer.Result = {}
|
|
Strategy.Result = {}
|
|
|
|
local bAreAllMachiningsAdded = true
|
|
|
|
-- verifico se la lavorazione può essere spostata dopo taglio di coda
|
|
local dLengthOnX = Proc.b3Box:getDimX()
|
|
Strategy.bCanMoveAfterSplit = MachiningLib.CanMoveAfterSplitcut( dLengthOnX, Part)
|
|
|
|
-- recupero e verifico l'entità curva
|
|
local idAux = EgtGetInfo( Proc.id, 'AUXID', 'i')
|
|
if idAux then idAux = idAux + Proc.id end
|
|
if not idAux or ( EgtGetType( idAux) & GDB_FY.GEO_CURVE) == 0 then
|
|
local sErr = 'Error on process ' .. tostring( Proc.id) .. ' missing profile geometry'
|
|
EgtOutLog( sErr)
|
|
return false, sErr
|
|
end
|
|
Proc.idAddAuxGeom = idAux
|
|
|
|
-- lavorazione smussi
|
|
Strategy.Chamfer.Machinings, Strategy.Chamfer.Result = GetChamferStrategy( Proc, Part)
|
|
|
|
-- se non bisogna fare solo gli smussi, si calcolano le altre lavorazioni
|
|
if not Strategy.Parameters.bOnlyChamfer then
|
|
-- per tutti tranne che per feature RoundArc
|
|
if not ID.IsRoundArch( Proc) and not ID.IsFreeContour( Proc) then
|
|
-- lavorazione taglio per sgrossare
|
|
if Strategy.Parameters.bExecRough then
|
|
Strategy.RoughCut = {}
|
|
Strategy.RoughCut.Machinings = {}
|
|
Strategy.RoughCut.Result = {}
|
|
Strategy.RoughCut.Machinings, Strategy.RoughCut.Result = GetRoughStrategy( Proc, Part, bAddMachining)
|
|
end
|
|
-- lavorazione degli estremi con angoli interni
|
|
Strategy.EdgeWithCorner = {}
|
|
Strategy.EdgeWithCorner.Machinings = {}
|
|
Strategy.EdgeWithCorner.Result = {}
|
|
Strategy.EdgeWithCorner.Machinings, Strategy.EdgeWithCorner.Result = GetEdgeWithCornerStrategy( Proc, Part)
|
|
end
|
|
|
|
-- lavorazione profilo (a meno che non si facciano solo smussi)
|
|
Strategy.Profile = {}
|
|
Strategy.Profile.Machinings = {}
|
|
Strategy.Profile.Result = {}
|
|
Strategy.Profile.Machinings, Strategy.Profile.Result = GetArcStrategy( Proc, Part)
|
|
end
|
|
|
|
Strategy.Result = GetFeatureResult( Proc)
|
|
|
|
if bAddMachining and Strategy.Result.sStatus ~= 'Not-Applicable' then
|
|
-- eventuali punti di spezzatura
|
|
local FeatureSplittingPoints = FeatureLib.GetFeatureSplittingPoints( Proc, Part)
|
|
|
|
-- lavorazione degli smussi
|
|
if Strategy.Chamfer.Machinings then
|
|
for i = 1, #Strategy.Chamfer.Machinings do
|
|
local MachiningToSplit = {}
|
|
table.insert( MachiningToSplit, Strategy.Chamfer.Machinings[i])
|
|
local MachiningResult = MachiningLib.GetSplitMachinings( MachiningToSplit, FeatureSplittingPoints, Part)
|
|
-- aggiunge lavorazione
|
|
for j = 1, #MachiningResult do
|
|
bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, MachiningResult[j])
|
|
end
|
|
end
|
|
end
|
|
|
|
-- per tutti tranne che per feature RoundArc
|
|
if not ID.IsRoundArch( Proc) and not ID.IsFreeContour( Proc) then
|
|
-- lavorazione di sgrezzatura di lama
|
|
if Strategy.Parameters.bExecRough and Strategy.RoughCut.Machinings then
|
|
-- se cutting da fare come svuotatura
|
|
if Strategy.RoughCut.Machinings.bCuttingWithMill then
|
|
bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, Strategy.RoughCut.Machinings)
|
|
-- taglio di lama
|
|
else
|
|
for i = 1, #Strategy.RoughCut.Machinings do
|
|
if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
|
|
Strategy.RoughCut.Machinings[i].sStage = 'AfterTail'
|
|
end
|
|
local bIsMachiningAdded = MachiningLib.AddMachinings( Proc, Strategy.RoughCut.Machinings[i])
|
|
if not bIsMachiningAdded then
|
|
bAreAllMachiningsAdded = false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- lavorazione degli angoli interni
|
|
if Strategy.EdgeWithCorner.Machinings then
|
|
for i = 1, #Strategy.EdgeWithCorner.Machinings do
|
|
local bIsMachiningAdded = MachiningLib.AddMachinings( Proc, Strategy.EdgeWithCorner.Machinings[i])
|
|
if not bIsMachiningAdded then
|
|
bAreAllMachiningsAdded = false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- lavorazione del profilo
|
|
if Strategy.Profile.Machinings then
|
|
for i = 1, #Strategy.Profile.Machinings do
|
|
|
|
Strategy.Profile.Machinings[i].Geometry = {{ Proc.idAddAuxGeom, -1}}
|
|
Strategy.Profile.Machinings[i].nToolIndex = Strategy.Profile.Machinings[i].ToolInfo.nToolIndex
|
|
Strategy.Profile.Machinings[i].nType = MCH_MY.MILLING
|
|
Strategy.Profile.Machinings[i].Steps = MachiningLib.GetMachiningSteps( false, tonumber( Strategy.Profile.Machinings[i].sDepth), TOOLS[Strategy.Profile.Machinings[i].nToolIndex].dStep)
|
|
Strategy.Profile.Machinings[i].Steps.nStepType = MCH_MILL_ST.ONEWAY
|
|
|
|
-- LeadIn / LeadOut
|
|
Strategy.Profile.Machinings[i].LeadIn.nType = MCH_MILL_LI.TANGENT
|
|
Strategy.Profile.Machinings[i].LeadOut.nType = MCH_MILL_LI.TANGENT
|
|
Strategy.Profile.Machinings[i].LeadIn.dTangentDistance = TOOLS[Strategy.Profile.Machinings[i].ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
|
|
Strategy.Profile.Machinings[i].LeadIn.dPerpDistance = 0
|
|
Strategy.Profile.Machinings[i].LeadIn.dStartAddLength = 0
|
|
Strategy.Profile.Machinings[i].LeadOut.dTangentDistance = TOOLS[Strategy.Profile.Machinings[i].ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
|
|
Strategy.Profile.Machinings[i].LeadOut.dPerpDistance = 0
|
|
Strategy.Profile.Machinings[i].LeadOut.dEndAddLength = 0
|
|
|
|
if Proc.AffectedFaces.bLeft and Strategy.bCanMoveAfterSplit then
|
|
Strategy.Profile.Machinings[i].sStage = 'AfterTail'
|
|
end
|
|
|
|
-- preparo attacco/uscita in caso di spezzatura arco
|
|
Strategy.Profile.Machinings[i].LeadInForSplit = BeamLib.TableCopyDeep( Strategy.Profile.Machinings[i].LeadIn)
|
|
Strategy.Profile.Machinings[i].LeadOutForSplit = BeamLib.TableCopyDeep( Strategy.Profile.Machinings[i].LeadOut)
|
|
Strategy.Profile.Machinings[i].LeadInForSplit.nType = MCH_MILL_LI.LINEAR
|
|
Strategy.Profile.Machinings[i].LeadOutForSplit.nType = MCH_MILL_LI.LINEAR
|
|
Strategy.Profile.Machinings[i].LeadInForSplit.dTangentDistance = 0
|
|
Strategy.Profile.Machinings[i].LeadInForSplit.dPerpDistance = TOOLS[Strategy.Profile.Machinings[i].ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
|
|
Strategy.Profile.Machinings[i].LeadOutForSplit.dTangentDistance = 0
|
|
Strategy.Profile.Machinings[i].LeadOutForSplit.dPerpDistance = TOOLS[Strategy.Profile.Machinings[i].ToolInfo.nToolIndex].dDiameter / 2 + BeamData.COLL_SIC
|
|
|
|
-- sistemo il lato e la direzione di lavoro
|
|
if Strategy.Profile.Machinings[i].bOtherDirection then
|
|
Strategy.Profile.Machinings[i].bToolInvert = true
|
|
Strategy.Profile.Machinings[i].bInvert = EgtIf( TOOLS[Strategy.Profile.Machinings[i].ToolInfo.nToolIndex].bIsCCW, true, false)
|
|
Strategy.Profile.Machinings[i].nWorkside = EgtIf( TOOLS[Strategy.Profile.Machinings[i].ToolInfo.nToolIndex].bIsCCW, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
|
|
else
|
|
Strategy.Profile.Machinings[i].bInvert = EgtIf( TOOLS[Strategy.Profile.Machinings[i].ToolInfo.nToolIndex].bIsCCW, false, true)
|
|
Strategy.Profile.Machinings[i].nWorkside = EgtIf( TOOLS[Strategy.Profile.Machinings[i].ToolInfo.nToolIndex].bIsCCW, MCH_MILL_WS.RIGHT, MCH_MILL_WS.LEFT)
|
|
end
|
|
Strategy.Profile.Machinings[i].ptEdge1 = EgtSP( Proc.idAddAuxGeom, GDB_ID.ROOT)
|
|
Strategy.Profile.Machinings[i].ptEdge2 = EgtEP( Proc.idAddAuxGeom, GDB_ID.ROOT)
|
|
Strategy.Profile.Machinings[i].dEdgeLength = EgtCurveLength( Proc.idAddAuxGeom)
|
|
Strategy.Profile.Machinings[i].vtEdgeDirection = EgtSV( Proc.idAddAuxGeom, GDB_ID.ROOT) + EgtMV( Proc.idAddAuxGeom, GDB_ID.ROOT) + EgtEV( Proc.idAddAuxGeom, GDB_ID.ROOT)
|
|
Strategy.Profile.Machinings[i].dLengthOnX = Proc.b3Box:getDimX()
|
|
|
|
local MachiningToSplit = {}
|
|
table.insert( MachiningToSplit, Strategy.Profile.Machinings[i])
|
|
local MachiningResult = MachiningLib.GetSplitMachinings( MachiningToSplit, FeatureSplittingPoints, Part)
|
|
-- aggiunge lavorazione
|
|
for j = 1, #MachiningResult do
|
|
bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, MachiningResult[j])
|
|
end
|
|
end
|
|
end
|
|
|
|
else
|
|
bAreAllMachiningsAdded = false
|
|
end
|
|
|
|
return bAreAllMachiningsAdded, Strategy.Result
|
|
end
|
|
|
|
-------------------------------------------------------------------------------------------------------------
|
|
|
|
return STR0015 |