Egalware/databeamnew
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'feature/BetterCuts' into develop

Browse Source
This commit is contained in:
luca.mazzoleni
2025-07-18 11:36:14 +02:00
parent a0d44ed1e4 f7a07e0cc1
commit 6b0714ca36
5 changed files with 336 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LuaLibs/BeamExec.lua
+2 -2
View File
@@ -516,9 +516,9 @@ function BeamExec.CalcMinUnloadableRaw( dRawW, dRawH)
else
BeamData.dMinRaw = BeamData.MINRAW_L
end
-- lettura minimo pezzo pinzabile
BeamData.dMinClampRaw = BeamData.LEN_VERY_SHORT_PART or 400
end
-- lettura minimo pezzo pinzabile
BeamData.dMinClampRaw = BeamData.LEN_VERY_SHORT_PART or 400
end
-------------------------------------------------------------------------------------------------------------
LuaLibs/FaceData.lua
+26
View File
@@ -219,6 +219,32 @@ function FaceData.IsFaceRectangular( Proc, idFace)
return bIsRectangular
end
-------------------------------------------------------------------------------------------------------------
function FaceData.IsFaceRhomboid( Proc, idFace)
local nAddGrpId = BeamLib.GetAddGroup( Proc.idPart)
local nContourId, nContourCnt = EgtExtractSurfTmFacetLoops( Proc.id, idFace, nAddGrpId)
if nContourCnt > 1 then
error( 'IsFaceRectangular : too many loops')
end
local bIsTrapezoid = EgtCurveIsATrapezoid( nContourId)
local bIsRhomboid = false
-- un parallelogramma è un trapezoide con i lati paralleli a due a due
if bIsTrapezoid
and AreOppositeVectorApprox( Proc.Faces[idFace + 1].Edges[1].vtN, Proc.Faces[idFace + 1].Edges[3].vtN)
and AreOppositeVectorApprox( Proc.Faces[idFace + 1].Edges[2].vtN, Proc.Faces[idFace + 1].Edges[4].vtN) then
bIsRhomboid = true
end
-- elimino curve create
for i = 1, nContourCnt do
EgtErase( nContourId + i - 1)
end
return bIsRhomboid
end
-------------------------------------------------------------------------------------------------------------
local function CompareEdgesBottomFace( EdgeA, EdgeB)
-- prima i lati con facce adiacenti
StrategyLibs/BLADETOWASTE.lua
+299 -120
View File
@@ -158,6 +158,26 @@ local function CompareEdgesTopHeadGuillotine( EdgeA, EdgeB)
end
-- si cerca il lato più verticale
local function CompareEdgesVertical( EdgeA, EdgeB)
if abs( EdgeA.vtN:getZ()) < abs( EdgeB.vtN:getZ()) - 10 * GEO.EPS_SMALL then return true end
if abs( EdgeA.vtN:getZ()) > abs( EdgeB.vtN:getZ()) + 10 * GEO.EPS_SMALL then return false end
return false
end
-- si cerca il lato orizzontale più in basso
local function CompareEdgesHorizontalBottom( EdgeA, EdgeB)
if EdgeA.vtN:getZ() > EdgeB.vtN:getZ() + 10 * GEO.EPS_SMALL then return true end
if EdgeA.vtN:getZ() < EdgeB.vtN:getZ() - 10 * GEO.EPS_SMALL then return false end
return false
end
local function CompareEdgesNoPreference( EdgeA, EdgeB)
-- prima i lati a minore elevazione
if EdgeA.dElevation < EdgeB.dElevation then
@@ -192,7 +212,6 @@ local function GetEdgeToMachine( Edges, vtNFace, sBladeType)
table.insert( EdgesSorted, Edges[i])
end
-- TODO separare Top e TopGuillotine; il Top deve tagliare dal basso all'alto e non scegliere il lato sotto
if ( sBladeType == 'Top') then
table.sort( EdgesSorted, CompareEdgesTopHead)
EdgeToMachine = EdgesSorted[1]
@@ -210,6 +229,13 @@ local function GetEdgeToMachine( Edges, vtNFace, sBladeType)
elseif sBladeType == 'TopGuillotine' then
table.sort( EdgesSorted, CompareEdgesTopHeadGuillotine)
EdgeToMachine = EdgesSorted[1]
elseif sBladeType == 'HorizontalBottom' then
table.sort( EdgesSorted, CompareEdgesHorizontalBottom)
EdgeToMachine = EdgesSorted[1]
elseif sBladeType == 'Vertical' then
table.sort( EdgesSorted, CompareEdgesVertical)
EdgeToMachine = EdgesSorted[1]
-- TODO non testato; non si dovrebbe mai entrare in questo caso
else
table.sort( EdgesSorted, CompareEdgesNoPreference)
EdgeToMachine = EdgesSorted[1]
@@ -222,6 +248,8 @@ end
local function GetBestBlade( Proc, Part, Face, OptionalParameters)
local nChosenToolIndex
local sChosenBladeType
local nToolIndexTop
local nToolIndexBottom
-- parametri opzionali e default
if not OptionalParameters then
@@ -230,34 +258,44 @@ local function GetBestBlade( Proc, Part, Face, OptionalParameters)
local dMinNzTopBladeIfEqual = OptionalParameters.dMinNzTopBlade or sin(-5)
local dMaxNyTopBlade = OptionalParameters.dMaxNyTopBlade or sin(1)
local dShortPartLength = OptionalParameters.dShortPartLength or BeamData.LEN_SHORT_PART
local dElevationTop = OptionalParameters.dElevationTopBlade
local dElevationBottom = OptionalParameters.dElevationBottomBlade
local dElevationTopDownUp = OptionalParameters.dElevationTopBladeDownUp or 0
-- ricerca lama testa sopra
local ToolSearchParameters = {}
ToolSearchParameters.vtN = Face.vtN
ToolSearchParameters.bAllowTopHead = true
ToolSearchParameters.bAllowBottomHead = false
ToolSearchParameters.bForceLongcutBlade = false
ToolSearchParameters.dElevation = dElevationTop
ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
local nToolIndexTop
if ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
nToolIndexTop = ToolInfo.nToolIndex
end
-- ricerca lama testa sotto
ToolSearchParameters = {}
ToolSearchParameters.vtN = Face.vtN
ToolSearchParameters.bAllowTopHead = false
ToolSearchParameters.bAllowBottomHead = true
ToolSearchParameters.bForceLongcutBlade = false
ToolSearchParameters.dElevation = dElevationBottom
ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
local nToolIndexBottom
if ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
nToolIndexBottom = ToolInfo.nToolIndex
local dElevationTop = OptionalParameters.dElevationTop
local dElevationBottom = OptionalParameters.dElevationBottom
local dElevationTopDownUp = OptionalParameters.dElevationTopDownUp or 0
-- se ho già l'utensile, devo solo discriminare se è lama sopra o sotto e verificare se ci arriva
if OptionalParameters.nToolIndex then
if TOOLS[OptionalParameters.nToolIndex].SetupInfo.HeadType.bTop then
if TOOLS[OptionalParameters.nToolIndex].dMaxMaterial > dElevationTop - 10 * GEO.EPS_SMALL then
nToolIndexTop = OptionalParameters.nToolIndex
end
elseif TOOLS[OptionalParameters.nToolIndex].SetupInfo.HeadType.bBottom then
if TOOLS[OptionalParameters.nToolIndex].dMaxMaterial > dElevationBottom - 10 * GEO.EPS_SMALL then
nToolIndexBottom = OptionalParameters.nToolIndex
end
end
-- non ho l'untensile, devo cercarlo e scegliere il migliore tra testa sopra e sotto
else
local ToolInfo
-- ricerca lama testa sopra
ToolInfo = MachiningLib.FindBlade( Proc, {
vtN = Face.vtN,
bAllowTopHead = true,
bAllowBottomHead = false,
dElevation = dElevationTop
})
if ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
nToolIndexTop = ToolInfo.nToolIndex
end
-- ricerca lama testa sotto
ToolInfo = MachiningLib.FindBlade( Proc, {
vtN = Face.vtN,
bAllowTopHead = false,
bAllowBottomHead = true,
dElevation = dElevationBottom
})
if ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
nToolIndexBottom = ToolInfo.nToolIndex
end
end
-- lama sopra e sotto
@@ -325,13 +363,180 @@ local function SetDiceFaceInfo( Proc, idDiceFace, bSaveAddedGeometries)
end
local function GetSingleCutStrategy( Proc, Part, OptionalParameters)
local FaceToMachine = Proc.Faces[1]
local sChosenBladeType
-- lati da lavorare in base al tipo di lama
local EdgeToMachineList = {
Top = GetEdgeToMachine(FaceToMachine.Edges, FaceToMachine.vtN, 'Top'),
Bottom = GetEdgeToMachine(FaceToMachine.Edges, FaceToMachine.vtN, 'Bottom'),
TopDownUp = GetEdgeToMachine(FaceToMachine.Edges, FaceToMachine.vtN, 'TopDownUp'),
TopGuillotine = GetEdgeToMachine(FaceToMachine.Edges, FaceToMachine.vtN, 'TopGuillotine')
}
-- parametri opzionali
OptionalParameters = OptionalParameters or {}
local nToolIndex = OptionalParameters.nToolIndex
local bReduceBladePath = OptionalParameters.bReduceBladePath
-- se nToolIndex è presente, GetBestBlade sceglierà solo il lato, altrimenti sceglierà lama e lato
local OptionalParametersGetBestBlade = {
dElevationTop = EdgeToMachineList.Top.dElevation + BeamData.CUT_EXTRA,
dElevationBottom = EdgeToMachineList.Bottom.dElevation + BeamData.CUT_EXTRA,
dElevationTopDownUp = EdgeToMachineList.TopDownUp.dElevation + BeamData.CUT_EXTRA,
nToolIndex = nToolIndex
}
nToolIndex, sChosenBladeType = GetBestBlade( Proc, Part, FaceToMachine, OptionalParametersGetBestBlade)
-- se possibile, upgrade del taglio tipo 'Top' a taglio a ghigliottina
if sChosenBladeType == 'Top' and bReduceBladePath and FaceData.IsFaceRectangular( Proc, FaceToMachine.id) then
-- ricerca lama migliore testa sopra
local ToolInfo = MachiningLib.FindBlade( Proc, {
vtN = Proc.Faces[1].vtN,
bAllowTopHead = true,
bAllowBottomHead = false
})
-- test fattibilità taglio a ghigliottina
if ToolInfo.nToolIndex then
local dRadialOffset = FaceByBlade.GetRadialOffsetForGuillotine( nToolIndex, EdgeToMachineList.TopGuillotine.dLength)
if ( TOOLS[ToolInfo.nToolIndex].dMaxMaterial - EdgeToMachineList.TopGuillotine.dElevation - BeamData.CUT_SIC) > dRadialOffset + 10 * GEO.EPS_SMALL then
nToolIndex = ToolInfo.nToolIndex
sChosenBladeType = 'TopGuillotine'
end
end
end
return nToolIndex, EdgeToMachineList[sChosenBladeType], sChosenBladeType
end
local function GetDualSideCutStrategy( Proc, OptionalParameters)
local FaceToMachine = Proc.Faces[1]
-- parametri opzionali
OptionalParameters = OptionalParameters or {}
local nToolIndex = OptionalParameters.nToolIndex
local CuttingParametersList
local EdgeToMachine
-- se possibile, si prova il doppio taglio orizzontale con mix testa sopra/sotto (questa modalità si esclude se l'utensile arriva dall'esterno)
-- TODO valutare se farlo anche doppio orizzontale solo con testa sopra, se la lama ha la corsa per andare sotto!
EdgeToMachine = GetEdgeToMachine( FaceToMachine.Edges, FaceToMachine.vtN, 'HorizontalBottom')
if not nToolIndex and AreSameOrOppositeVectorApprox( EdgeToMachine.vtN, Z_AX()) then
-- inizialmente si prova a lavorare in mezzeria
local dDepthToMachineTop = EdgeToMachine.dElevation / 2 + BeamData.CUT_EXTRA_MIN
local dDepthToMachineBottom = dDepthToMachineTop
-- ricerca lama testa sopra
local ToolInfoTopBlade = MachiningLib.FindBlade( Proc, {
vtN = FaceToMachine.vtN,
bAllowTopHead = true,
bAllowBottomHead = false,
dElevation = dDepthToMachineTop
})
-- ricerca lama testa sotto
local ToolInfoBottomBlade = MachiningLib.FindBlade( Proc, {
vtN = FaceToMachine.vtN,
bAllowTopHead = false,
bAllowBottomHead = true,
dElevation = dDepthToMachineBottom
})
local bIsTopLimited = ToolInfoTopBlade.dResidualDepth > 10 * GEO.EPS_SMALL
local bIsBottomLimited = ToolInfoBottomBlade.dResidualDepth > 10 * GEO.EPS_SMALL
-- testa sopra limitante
if bIsTopLimited and not bIsBottomLimited then
-- ricalcolo profondità di lavoro
dDepthToMachineTop = TOOLS[ToolInfoTopBlade.nToolIndex].dMaxMaterial
dDepthToMachineBottom = EdgeToMachine.dElevation - dDepthToMachineTop + BeamData.CUT_EXTRA_MIN
-- ricerca lama sotto con la nuova depth
ToolInfoBottomBlade = MachiningLib.FindBlade( Proc, {
vtN = FaceToMachine.vtN,
bAllowTopHead = false,
bAllowBottomHead = true,
dElevation = dDepthToMachineBottom
})
bIsBottomLimited = ToolInfoBottomBlade.dResidualDepth > 10 * GEO.EPS_SMALL
-- testa sotto limitante
elseif bIsBottomLimited and not bIsTopLimited then
-- ricalcolo profondità di lavoro
dDepthToMachineBottom = TOOLS[ToolInfoBottomBlade.nToolIndex].dMaxMaterial
dDepthToMachineTop = EdgeToMachine.dElevation - dDepthToMachineBottom + BeamData.CUT_EXTRA_MIN
-- ricerca lama sopra con la nuova depth
ToolInfoTopBlade = MachiningLib.FindBlade( Proc, {
vtN = FaceToMachine.vtN,
bAllowTopHead = true,
bAllowBottomHead = false,
dElevation = dDepthToMachineTop
})
bIsTopLimited = ToolInfoTopBlade.dResidualDepth > 10 * GEO.EPS_SMALL
end
-- se almeno una delle due lame ci arriva si assegnano utensili e profondità da ritornare
if not ( bIsTopLimited and bIsBottomLimited) and ToolInfoTopBlade.nToolIndex and ToolInfoBottomBlade.nToolIndex then
CuttingParametersList = {
{
nToolIndex = ToolInfoBottomBlade.nToolIndex,
dDepthToMachine = dDepthToMachineBottom
},
{
nToolIndex = ToolInfoTopBlade.nToolIndex,
dDepthToMachine = dDepthToMachineTop
}
}
return CuttingParametersList, EdgeToMachine
end
end
-- arrivati qui si prova il taglio doppio verticale (taglio doppio orizzontale non si può fare oppure non ci arriva)
EdgeToMachine = GetEdgeToMachine( FaceToMachine.Edges, FaceToMachine.vtN, 'Vertical')
local dDepthToMachine = EdgeToMachine.dElevation / 2 + BeamData.CUT_EXTRA_MIN
-- ricerca lama testa sopra
local ToolInfo = MachiningLib.FindBlade( Proc, {
vtN = FaceToMachine.vtN,
bAllowTopHead = true,
bAllowBottomHead = false,
dElevation = dDepthToMachine
})
-- se lama ci arriva si assegnano utensili e profondità da ritornare
if ToolInfo.nToolIndex and ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL then
CuttingParametersList = {
{
nToolIndex = ToolInfo.nToolIndex,
dDepthToMachine = dDepthToMachine
},
{
nToolIndex = ToolInfo.nToolIndex,
dDepthToMachine = dDepthToMachine
}
}
else
EdgeToMachine = nil
end
return CuttingParametersList, EdgeToMachine
end
local function CutWholeWaste( Proc, Part, OptionalParameters)
local Machinings = {}
local Cutting = {}
local Cutting = nil
local CuttingDouble = nil
local Result = {}
local EdgeToMachine = {}
local EdgeToMachine
local sChosenBladeType = ''
local dDepthToMachine = 0
local dCompletionPercentage = 0
-- controlli preventivi
@@ -349,87 +554,66 @@ local function CutWholeWaste( Proc, Part, OptionalParameters)
local dExtendAfterTail = OptionalParameters.dExtendAfterTail or 10000
local bReduceBladePath = OptionalParameters.bReduceBladePath or false
-- lato da lavorare in base al tipo di lama
local EdgeToMachineTopBlade = GetEdgeToMachine( Proc.Faces[1].Edges, Proc.Faces[1].vtN, 'Top')
local EdgeToMachineBottomBlade = GetEdgeToMachine( Proc.Faces[1].Edges, Proc.Faces[1].vtN, 'Bottom')
local EdgeToMachineTopBladeDownUp = GetEdgeToMachine( Proc.Faces[1].Edges, Proc.Faces[1].vtN, 'TopDownUp')
local EdgeToMachineTopBladeGuillotine = GetEdgeToMachine( Proc.Faces[1].Edges, Proc.Faces[1].vtN, 'TopGuillotine')
-- scelta lama da sopra o da sotto
-- si cerca di tagliare tutto da un lato
nToolIndex, EdgeToMachine, sChosenBladeType = GetSingleCutStrategy( Proc, Part, OptionalParameters)
-- se taglio da un lato ce la fa, si crea la lavorazione
if nToolIndex then
-- TODO se la lama arriva da fuori chi sceglie il lato????? Sarà da scegliere in base alla testa lama
nToolIndex = OptionalParameters.nToolIndex
else
local OptionalParametersGetBestBlade = { dElevationTop = EdgeToMachineTopBlade.dElevation + BeamData.CUT_EXTRA,
dElevationBottom = EdgeToMachineBottomBlade.dElevation + BeamData.CUT_EXTRA,
dElevationTopDownUp = EdgeToMachineTopBladeDownUp.dElevation + BeamData.CUT_EXTRA
}
nToolIndex, sChosenBladeType = GetBestBlade( Proc, Part, Proc.Faces[1], OptionalParametersGetBestBlade)
-- se possibile taglio a ghigliottina, si sceglie il lato adeguato
if sChosenBladeType == 'Top'
and bReduceBladePath
and FaceData.IsFaceRectangular( Proc, Proc.Faces[1].id) then
-- ricerca lama migliore testa sopra
local ToolSearchParameters = {}
ToolSearchParameters.vtN = Proc.Faces[1].vtN
ToolSearchParameters.bAllowTopHead = true
ToolSearchParameters.bAllowBottomHead = false
ToolSearchParameters.bForceLongcutBlade = false
ToolSearchParameters.dElevation = nil
local ToolInfo = MachiningLib.FindBlade( Proc, ToolSearchParameters)
-- test fattibilità taglio a ghigliottina
local dRadialOffset = FaceByBlade.GetRadialOffsetForGuillotine( nToolIndex, EdgeToMachineTopBladeGuillotine.dLength)
if ( TOOLS[ToolInfo.nToolIndex].dMaxMaterial - EdgeToMachineTopBladeGuillotine.dElevation - BeamData.CUT_SIC) > dRadialOffset + 10 * GEO.EPS_SMALL then
nToolIndex = ToolInfo.nToolIndex
sChosenBladeType = 'TopGuillotine'
end
end
end
-- utensile non trovato
if not nToolIndex then
Result = FeatureLib.GetStrategyResultNotApplicable( 'Blade not found')
return Machinings, Result
end
-- lato da lavorare definitivo
if sChosenBladeType == 'Top' then
EdgeToMachine = EdgeToMachineTopBlade
elseif sChosenBladeType == 'Bottom' then
EdgeToMachine = EdgeToMachineBottomBlade
elseif sChosenBladeType == 'TopDownUp' then
EdgeToMachine = EdgeToMachineTopBladeDownUp
elseif sChosenBladeType == 'TopGuillotine' then
EdgeToMachine = EdgeToMachineTopBladeGuillotine
end
dDepthToMachine = EdgeToMachine.dElevation + BeamData.CUT_EXTRA
local dResidualDepth = dDepthToMachine - TOOLS[nToolIndex].dMaxMaterial
-- TODO qui gestire il caso in cui si può tagliare da due lati (inizialmente solo se vtN:Y è ~= 0?). Andranno ricercati gli utensili di nuovo con l'elevazione a metà??
if dResidualDepth < 10 * GEO.EPS_SMALL then
local OptionalParametersFaceByBlade = { dDepthToMachine = dDepthToMachine,
nToolIndex = nToolIndex,
dExtendAfterTail = dExtendAfterTail,
bReduceBladePath = bReduceBladePath
}
local OptionalParametersFaceByBlade = {
dDepthToMachine = EdgeToMachine.dElevation + BeamData.CUT_EXTRA,
nToolIndex = nToolIndex,
dExtendAfterTail = dExtendAfterTail,
bReduceBladePath = bReduceBladePath
}
if sChosenBladeType == 'Top' or sChosenBladeType == 'Bottom' then
OptionalParametersFaceByBlade.OppositeToolDirectionMode = 'Optimized'
end
Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParametersFaceByBlade)
-- se taglio da un lato non ce la fa, si prova da due lati
-- TODO valutare se estendere ai non parallelogrammi
elseif FaceData.IsFaceRhomboid( Proc, Proc.Faces[1].id) then
local CuttingParametersList
CuttingParametersList, EdgeToMachine = GetDualSideCutStrategy( Proc, OptionalParameters)
if CuttingParametersList then
local OptionalParametersFaceByBlade = {
dDepthToMachine = CuttingParametersList[1].dDepthToMachine,
nToolIndex = CuttingParametersList[1].nToolIndex,
dExtendAfterTail = dExtendAfterTail,
bReduceBladePath = bReduceBladePath,
OppositeToolDirectionMode = 'Enabled'
}
local OptionalParametersFaceByBladeDouble = {
dDepthToMachine = CuttingParametersList[2].dDepthToMachine,
nToolIndex = CuttingParametersList[2].nToolIndex,
dExtendAfterTail = dExtendAfterTail,
bReduceBladePath = bReduceBladePath
}
Cutting = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParametersFaceByBlade)
CuttingDouble = FaceByBlade.Make( Proc, Part, Proc.Faces[1], EdgeToMachine, OptionalParametersFaceByBladeDouble)
end
end
if Cutting.bIsApplicable then
if Cutting and Cutting.bIsApplicable then
table.insert( Machinings, Cutting)
dCompletionPercentage = Cutting.dCompletionPercentage or dCompletionPercentage
if CuttingDouble and CuttingDouble.bIsApplicable then
table.insert( Machinings, CuttingDouble)
dCompletionPercentage = 0.5 * ( Cutting.dCompletionPercentage or dCompletionPercentage) + 0.5 * ( CuttingDouble.dCompletionPercentage or dCompletionPercentage)
end
end
-- risultati del calcolo
-- TODO funzione?
if Cutting.bIsApplicable then
if ( Cutting and Cutting.bIsApplicable) and ( not CuttingDouble or CuttingDouble.bIsApplicable) then
if dCompletionPercentage > 100 - 10 * GEO.EPS_SMALL then
Result.sStatus = 'Completed'
else
@@ -437,8 +621,8 @@ local function CutWholeWaste( Proc, Part, OptionalParameters)
end
Result.dCompletionPercentage = dCompletionPercentage
Result.nCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dCompletionPercentage)
Result.nQuality = TOOLS[nToolIndex].nQuality
Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( {Cutting})
Result.nQuality = FeatureLib.GetStrategyQuality( Machinings)
Result.dTimeToMachine = FeatureLib.GetStrategyTimeToMachine( Machinings)
Result.dMRR = ( FeatureInfo.dFeatureVolume / Result.dTimeToMachine) / pow( 10, 6)
else
Result = FeatureLib.GetStrategyResultNotApplicable()
@@ -585,11 +769,12 @@ local function CutWithDicing( Proc, Part, OptionalParameters)
local _, Edges = FaceData.GetEdgesInfo( vCuts[i][j], 0)
local EdgeToMachine = BeamLib.FindEdgeBestOrientedAsDirection( Edges, vtToolDirectionNew)
local dDepthToMachine = EdgeToMachine.dElevation + BeamData.CUT_EXTRA
local OptionalParametersFaceByBlade = { dDepthToMachine = dDepthToMachine,
nToolIndex = nToolIndex,
dRadialStepSpan = 0,
dExtendAfterTail = dExtendAfterTail
}
local OptionalParametersFaceByBlade = {
dDepthToMachine = dDepthToMachine,
nToolIndex = nToolIndex,
dRadialStepSpan = 0,
dExtendAfterTail = dExtendAfterTail
}
Cutting = FaceByBlade.Make( ProcTrimesh, Part, FaceToMachine, EdgeToMachine, OptionalParametersFaceByBlade)
Cutting.ptCenter = Point3d( ProcTrimesh.Faces[1].ptCenter:getX(), 0, 0)
if Cutting.bIsApplicable then
@@ -623,17 +808,13 @@ local function CutWithDicing( Proc, Part, OptionalParameters)
local ProcTrimesh = FeatureLib.GetProcFromTrimesh( vCuts[i][j], Part)
local _, Edges = FaceData.GetEdgesInfo( vCuts[i][j], 0)
local EdgeToMachine = BeamLib.FindEdgeBestOrientedAsDirection( Edges, vtToolDirection)
local EdgeToMachineAlternative = {}
if ( i % 2 == 0) and ( Proc.Fct == 1) and bNoPerpCuts then
EdgeToMachineAlternative = BeamLib.FindEdgeBestOrientedAsDirection( Edges, -EdgeToMachine.vtN)
end
local dDepthToMachine = EdgeToMachine.dElevation + dExtraCut
local OptionalParametersFaceByBlade = { dDepthToMachine = dDepthToMachine,
nToolIndex = nToolIndex,
EdgeToMachineAlternative = EdgeToMachineAlternative,
dRadialStepSpan = 0,
dExtendAfterTail = dExtendAfterTail
}
local OptionalParametersFaceByBlade = {
dDepthToMachine = dDepthToMachine,
nToolIndex = nToolIndex,
dRadialStepSpan = 0,
dExtendAfterTail = dExtendAfterTail
}
Cutting = FaceByBlade.Make( ProcTrimesh, Part, FaceToMachine, EdgeToMachine, OptionalParametersFaceByBlade)
Cutting.ptCenter = Point3d( ProcTrimesh.Faces[1].ptCenter:getX(), 0, 0)
if Cutting.bIsApplicable then
@@ -743,9 +924,7 @@ function BLADETOWASTE.Make( ProcOrId, Part, OptionalParameters)
-- parametri opzionali e default
-- quelli non censiti sono gestiti direttamente nelle funzioni sotto e devono quindi solo transitare
if not OptionalParameters then
OptionalParameters = {}
end
OptionalParameters = OptionalParameters or {}
local dMaxWasteVolume = OptionalParameters.dMaxWasteVolume or 0
local dMaxWasteLength = OptionalParameters.dMaxWasteLength or 0
local bSaveAddedGeometries = OptionalParameters.bSaveAddedGeometries
StrategyLibs/FACEBYBLADE.lua
+9 -7
View File
@@ -199,7 +199,10 @@ function FACEBYBLADE.GetPathReductionLength( nToolIndex, dRadialOffset, Optional
local dExtra = OptionalParameters.dExtra or BeamData.CUT_EXTRA
-- calcolo
local dReductionLength = sqrt( ( dToolRadius - dExtra)^2 - ( dToolRadius - dRadialOffset)^2)
local dReductionLength = -dExtra
if dRadialOffset > dExtra + 10 * GEO.EPS_SMALL then
dReductionLength = sqrt( ( dToolRadius - dExtra)^2 - ( dToolRadius - dRadialOffset)^2)
end
return dReductionLength
end
@@ -226,7 +229,6 @@ function FACEBYBLADE.GetRadialOffsetForGuillotine( nToolIndex, dEdgeLength, Opti
end
-- TODO EdgeToMachineAlternative da gestire?
function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalParameters)
local Cutting = MachiningLib.InitMachiningParameters( MCH_MY.MILLING)
Cutting.bIsApplicable = true
@@ -347,7 +349,7 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
Cutting.bInvert = false
end
-- se OppositeToolDirectionMode è Optimized, se possibile e necessario, si attiva per garantire taglio concorde e verso l'alto (massima qualità)
if ( OppositeToolDirectionMode == 'Optimized') and ( Proc.nFct == 1) and ( FaceData.IsFaceRectangular( Proc, FaceToMachine.id)) then
if ( OppositeToolDirectionMode == 'Optimized') and ( Proc.nFct == 1) and ( FaceData.IsFaceRhomboid( Proc, FaceToMachine.id)) then
OppositeToolDirectionMode = 'Disabled'
-- la direzione di percorrenza del lato deve essere verso l'alto; bInvert va considerata perchè inverte la direzione di percorrenza.
if ( Cutting.bInvert and Cutting.vtEdgeDirection:getZ() > 100 * GEO.EPS_SMALL)
@@ -406,16 +408,16 @@ function FACEBYBLADE.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalPar
and FaceData.IsFaceRectangular( Proc, FaceToMachine.id) then
local bIsTopBlade = TOOLS[nToolIndex].SetupInfo.HeadType.bTop
Cutting.dMaxRadialOffset = TOOLS[nToolIndex].dMaxMaterial - EdgeToMachine.dElevation - BeamData.CUT_SIC
Cutting.dMaxRadialOffset = TOOLS[nToolIndex].dMaxMaterial - Cutting.dDepthToMachine - BeamData.CUT_SIC
Cutting.dRadialOffsetGuillotine = FACEBYBLADE.GetRadialOffsetForGuillotine( nToolIndex, EdgeToMachine.dLength)
if Cutting.dMaxRadialOffset > 10 * GEO.EPS_SMALL then
-- taglio a ghigliottina
if bIsTopBlade and ( Cutting.dRadialOffsetGuillotine < Cutting.dMaxRadialOffset - 10 * GEO.EPS_SMALL) then
dDepthToMachine = EdgeToMachine.dElevation + Cutting.dRadialOffsetGuillotine
if bIsTopBlade and ( OppositeToolDirectionMode ~= 'Enabled') and ( Cutting.dRadialOffsetGuillotine < Cutting.dMaxRadialOffset - 10 * GEO.EPS_SMALL) then
dDepthToMachine = Cutting.dDepthToMachine + Cutting.dRadialOffsetGuillotine
Cutting.sCutType = 'Guillotine'
-- taglio ridotto
else
dDepthToMachine = EdgeToMachine.dElevation + Cutting.dMaxRadialOffset
dDepthToMachine = Cutting.dDepthToMachine + Cutting.dMaxRadialOffset
Cutting.sCutType = 'Reduced'
end
end
StrategyLibs/FACEBYMILL.lua
-1
View File
@@ -165,7 +165,6 @@ end
-- TODO calcolo area lavorata per completamento
-- TODO EdgeToMachineAlternative da gestire
function FACEBYMILL.Make( Proc, Part, FaceToMachine, EdgeToMachine, OptionalParameters)
local Milling = MachiningLib.InitMachiningParameters( MCH_MY.MILLING)
Milling.bIsApplicable = true