diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index 9c29ff0..b612abe 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -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 ------------------------------------------------------------------------------------------------------------- diff --git a/LuaLibs/FaceData.lua b/LuaLibs/FaceData.lua index bf2a6e8..7ed0e32 100644 --- a/LuaLibs/FaceData.lua +++ b/LuaLibs/FaceData.lua @@ -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 diff --git a/StrategyLibs/BLADETOWASTE.lua b/StrategyLibs/BLADETOWASTE.lua index dfc4bfe..430bd6a 100644 --- a/StrategyLibs/BLADETOWASTE.lua +++ b/StrategyLibs/BLADETOWASTE.lua @@ -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 diff --git a/StrategyLibs/FACEBYBLADE.lua b/StrategyLibs/FACEBYBLADE.lua index d9721f2..5bf85b4 100644 --- a/StrategyLibs/FACEBYBLADE.lua +++ b/StrategyLibs/FACEBYBLADE.lua @@ -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 diff --git a/StrategyLibs/FACEBYMILL.lua b/StrategyLibs/FACEBYMILL.lua index d020e76..fd5ed3d 100644 --- a/StrategyLibs/FACEBYMILL.lua +++ b/StrategyLibs/FACEBYMILL.lua @@ -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