From 653557a23d38ba7ddd83b3470ccd5cd2c63ed166 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Fri, 15 Mar 2024 09:09:08 +0100 Subject: [PATCH 01/26] - in lapjoint primo implemento di MakeBySawPlusChain, da completare - in BeamExec -> collect si scrive l'id della feature btl --- LuaLibs/BeamExec.lua | 2 + LuaLibs/FeatureTopology.lua | 1 + LuaLibs/ProcessLapJoint.lua | 166 ++++++++++++++++++++++++++++++++++++ 3 files changed, 169 insertions(+) diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index 8676b0f..28abade 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -343,6 +343,8 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT) Proc.Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD) if b3Raw then local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD) + -- id della feature btl + Proc.FeatureId = EgtGetInfo( Proc.Id, 'PRID', 's') -- recupero l'elenco delle facce della parte interessate dalla feature Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc) -- recupero informazioni sulle facce della feature diff --git a/LuaLibs/FeatureTopology.lua b/LuaLibs/FeatureTopology.lua index 5426c5d..ef9e1cc 100644 --- a/LuaLibs/FeatureTopology.lua +++ b/LuaLibs/FeatureTopology.lua @@ -249,6 +249,7 @@ function FeatureTopology.Classify( Proc, b3Raw) Proc.IsThrough = bIsThrough Proc.AllRightAngles = bAllRightAngles Proc.IsParallel = bIsParallel + Proc.vAdj = vAdj return true else Proc.Topology = 'OTHER' diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 08040d7..629d1ef 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -172,6 +172,7 @@ local function AssignQIdent( Proc) Q_ANTISPLINT_TYPE = '' Q_MAX_ELEVATION = 'Q10' Q_STAIRCASE = '' + Q_SAW_PLUS_CHAIN = '' if ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 16 then Q_FORCE_BLADE = 'Q01' -- i @@ -4580,6 +4581,153 @@ local function MakeTunnelByChainSaw( Proc, sSawing, nLundIdFace, vtOrtho, dWorkD return true end +--------------------------------------------------------------------- +local function MakeBySawPlusChain( Proc, sTopologyLongName, b3Raw) + + if sTopologyLongName == 'Pocket-Blind-RightAngles-Parallel-5' then + + -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) + if Proc.AffectedFaces.Bottom then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket on bottom face' + return false, sErr + end + + -- faccia da lavorare, la stessa per lama e motosega + do + Proc.Pocket = {} + -- faccia di fondo + local vBottomFace = Topology.GetFacesWithGivenAdjacencyNumber( Proc, Proc.vAdj, 4) + Proc.Pocket.BottomFace = {} + Proc.Pocket.BottomFace.Id = vBottomFace[1] + Proc.Pocket.BottomFace.Width = Proc.Face[ Proc.Pocket.BottomFace.Id + 1].Width + Proc.Pocket.BottomFace.Height = Proc.Face[ Proc.Pocket.BottomFace.Id + 1].Height + Proc.Pocket.BottomFace.Elevation = Proc.Face[ Proc.Pocket.BottomFace.Id + 1].Elevation + Proc.Pocket.BottomFace.vtN = Proc.Face[ Proc.Pocket.BottomFace.Id + 1].VtN + if Proc.Pocket.BottomFace.Height > Proc.Pocket.BottomFace.Width then + Proc.Pocket.BottomFace.Width, Proc.Pocket.BottomFace.Height = Proc.Pocket.BottomFace.Height, Proc.Pocket.BottomFace.Width + end + -- facce adiacenti a quella di fondo + local vFacesAdjacentToBottom = EgtSurfTmFacetAdjacencies( Proc.Id, Proc.Pocket.BottomFace.Id)[1] + -- si cerca la faccia adiacente a quella di fondo sul lato lungo + local dMaxLen = 0 + for i = 1, #vFacesAdjacentToBottom do + local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, Proc.Pocket.BottomFace.Id, vFacesAdjacentToBottom[i], GDB_ID.ROOT) + local dLen = dist( ptP1, ptP2) + if dLen > dMaxLen then + Proc.Pocket.FaceToMachine = vFacesAdjacentToBottom[i] + dMaxLen = dLen + end + end + end + + -- caratteristiche della tasca + Proc.Pocket.Width = Proc.Pocket.BottomFace.Width + Proc.Pocket.Height = Proc.Pocket.BottomFace.Height + Proc.Pocket.Depth = Proc.Pocket.BottomFace.Elevation + Proc.Pocket.Direction = Proc.Pocket.BottomFace.vtN + + -- lavorazione di lama e relativi dati + local Cutting = {} + Cutting.Tool = {} + Cutting.Name, Cutting.IsDownHead = ML.FindCutting( 'HeadSide') + Cutting.Tool.Diameter = 0 + Cutting.Tool.Thickness = 0 + Cutting.Tool.MaxDepth = 0 + if EgtMdbSetCurrMachining( Cutting.Name) then + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) + if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then + Cutting.Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or Cutting.Tool.Diameter + Cutting.Tool.Thickness = EgtTdbGetCurrToolParam(MCH_TP.THICK) or Cutting.Tool.Thickness + Cutting.Tool.MaxDepth = EgtTdbGetCurrToolMaxDepth() or Cutting.Tool.MaxDepth + end + end + + -- lavorazione di sega a catena e relativi dati + local Chainsawing = {} + Chainsawing.Tool = {} + Chainsawing.Name, Chainsawing.IsDownHead = ML.FindSawing( 'Sawing') + Chainsawing.Tool.Length = 0 + Chainsawing.Tool.Width = 0 + Chainsawing.Tool.MaxMat = 0 + Chainsawing.Tool.Thickness = 0 + Chainsawing.Tool.CornerRadius = 0 + if EgtMdbSetCurrMachining( Chainsawing.Name) then + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) + if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then + Chainsawing.Tool.Length = EgtTdbGetCurrToolParam( MCH_TP.LEN) or Chainsawing.Tool.Length + Chainsawing.Tool.MaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or Chainsawing.Tool.MaxMat + Chainsawing.Tool.Width = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or Chainsawing.Tool.Width + Chainsawing.Tool.Thickness = EgtTdbGetCurrToolParam( MCH_TP.THICK) or Chainsawing.Tool.Thickness + Chainsawing.Tool.CornerRadius = EgtTdbGetCurrToolParam( MCH_TP.CORNRAD) or Chainsawing.Tool.CornerRadius + end + end + + -- se tasca più stretta della lama la strategia non è applicabile + if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket too narrow for saw blade diameter' + return false, sErr + end + + -- se tasca più stretta della sega a catena la strategia non è applicabile + if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket too narrow for chainsaw width' + return false, sErr + end + + -- se tasca meno spessa della lama la strategia non è applicabile + if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket too narrow for saw blade thickness' + return false, sErr + end + + -- se tasca meno spessa della sega a catena la strategia non è applicabile + if Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket too narrow for chainsaw thickness' + return false, sErr + end + + -- parametri della lavorazione con lama + -- profondità e offset radiale + if Cutting.Tool.MaxDepth > Proc.Pocket.Depth - 10 * GEO.EPS_SMALL then + Cutting.Depth = Proc.Pocket.Depth + Cutting.RadialOffset = 0 + else + Cutting.Depth = Cutting.Tool.MaxDepth + Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth + end + -- faceuse + Cutting.Direction = Proc.Pocket.Direction + -- approccio e retrazione + Cutting.LeadIn = {} + Cutting.LeadOut = {} + Cutting.LeadIn.Type = MCH_MILL_LI.LINEAR + Cutting.LeadOut.Type = MCH_MILL_LI.LINEAR + Cutting.LeadIn.StartAddLength = -sqrt( Cutting.Depth * Cutting.Tool.Diameter - Cutting.Depth * Cutting.Depth) + Cutting.LeadOut.StartAddLength = -sqrt( Cutting.Depth * Cutting.Tool.Diameter - Cutting.Depth * Cutting.Depth) + Cutting.LeadIn.TangentDistance = 0 + Cutting.LeadOut.TangentDistance = 0 + Cutting.LeadIn.PerpDistance = 1 + Cutting.LeadOut.PerpDistance = 1 + Cutting.LeadIn.Elevation = 0 + Cutting.LeadOut.Elevation = 0 + Cutting.LeadIn.CompLength = 0 + Cutting.LeadOut.CompLength = 0 + + -- lavorazione con lama + local bOk, sErr = Fbs.MakeOne( Proc.Id, Proc.Pocket.FaceToMachine, Cutting.Name, Cutting.Tool.Diameter, Cutting.Direction, 2, Cutting.RadialOffset, BD.CUT_SIC, 0, -Cutting.LeadIn.StartAddLength, -Cutting.LeadOut.StartAddLength, sNotes, b3Raw) + + return bOk, sErr + + elseif sTopologyLongName == 'Groove-Through-RightAngles-Parallel-3' then + return + elseif sTopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then + return + else + local sErr = 'Feature '.. Proc.FeatureId .. ' : Strategy not implemented for topology ' .. sTopologyLongName + return false, sErr + end +end + --------------------------------------------------------------------- local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePart, bPrevBhSideMill, bAllWithEndCap) if not BD.MAXDIAM_POCK_CORNER then @@ -4602,6 +4750,24 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa EgtOutLog( sErr) return false, sErr end + + + + + +-- rimuovere true or!!!!!! + if true or EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') == 1 then --TEST + local bOk + local sErr + bOk, sErr = MakeBySawPlusChain( Proc, Proc.TopologyLongName, b3Raw) + return bOk, sErr + end + + + + + + local bClosedOrthoFaces local nFacInd, dFacElev, nFacInd2, dFacElev2 local nBottomFace From f589464063adcd068edbc1330f96ed63b6fc9c1c Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Fri, 22 Mar 2024 17:48:50 +0100 Subject: [PATCH 02/26] - aggiunte lavorazioni SawPlusChainsaw funzionanti - manca la gestione nel caso la feature non sia parallela al pezzo --- LuaLibs/ProcessLapJoint.lua | 438 ++++++++++++++++++++++++------------ 1 file changed, 300 insertions(+), 138 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 6464ccf..9977020 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4585,152 +4585,314 @@ local function MakeTunnelByChainSaw( Proc, sSawing, nLundIdFace, vtOrtho, dWorkD end --------------------------------------------------------------------- -local function MakeBySawPlusChain( Proc, sTopologyLongName, b3Raw) +--#region SawPlusChain +local SawPlusChain = {} - if sTopologyLongName == 'Pocket-Blind-RightAngles-Parallel-5' then - - -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) - if Proc.AffectedFaces.Bottom then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket on bottom face' - return false, sErr - end - - -- faccia da lavorare, la stessa per lama e motosega - do - Proc.Pocket = {} - -- faccia di fondo - local vBottomFace = Topology.GetFacesWithGivenAdjacencyNumber( Proc, Proc.vAdj, 4) - Proc.Pocket.BottomFace = {} - Proc.Pocket.BottomFace.Id = vBottomFace[1] - Proc.Pocket.BottomFace.Width = Proc.Face[ Proc.Pocket.BottomFace.Id + 1].Width - Proc.Pocket.BottomFace.Height = Proc.Face[ Proc.Pocket.BottomFace.Id + 1].Height - Proc.Pocket.BottomFace.Elevation = Proc.Face[ Proc.Pocket.BottomFace.Id + 1].Elevation - Proc.Pocket.BottomFace.vtN = Proc.Face[ Proc.Pocket.BottomFace.Id + 1].VtN - if Proc.Pocket.BottomFace.Height > Proc.Pocket.BottomFace.Width then - Proc.Pocket.BottomFace.Width, Proc.Pocket.BottomFace.Height = Proc.Pocket.BottomFace.Height, Proc.Pocket.BottomFace.Width - end - -- facce adiacenti a quella di fondo - local vFacesAdjacentToBottom = EgtSurfTmFacetAdjacencies( Proc.Id, Proc.Pocket.BottomFace.Id)[1] - -- si cerca la faccia adiacente a quella di fondo sul lato lungo - local dMaxLen = 0 - for i = 1, #vFacesAdjacentToBottom do - local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, Proc.Pocket.BottomFace.Id, vFacesAdjacentToBottom[i], GDB_ID.ROOT) - local dLen = dist( ptP1, ptP2) - if dLen > dMaxLen then - Proc.Pocket.FaceToMachine = vFacesAdjacentToBottom[i] - dMaxLen = dLen +function SawPlusChain.GetBottomFace( Proc) + -- la faccia di fondo ha sempre Fct - 1 adiacenze. Se si trovano più facce di fondo si sceglie quella con minor elevazione + local vBottomFace = Topology.GetFacesWithGivenAdjacencyNumber( Proc, Proc.vAdj, Proc.Fct - 1) + local nBottomFace + if #vBottomFace > 1 then + local dMinElevation = GEO.INFINITO + for i = 1, #vBottomFace do + for j = 1, Proc.Fct do + if vBottomFace[i] == Proc.Face[j].Id then + if Proc.Face[j].Elevation < dMinElevation then + dMinElevation = Proc.Face[j].Elevation + nBottomFace = Proc.Face[j].Id + end end end end - - -- caratteristiche della tasca - Proc.Pocket.Width = Proc.Pocket.BottomFace.Width - Proc.Pocket.Height = Proc.Pocket.BottomFace.Height - Proc.Pocket.Depth = Proc.Pocket.BottomFace.Elevation - Proc.Pocket.Direction = Proc.Pocket.BottomFace.vtN - - -- lavorazione di lama e relativi dati - local Cutting = {} - Cutting.Tool = {} - Cutting.Name, Cutting.IsDownHead = ML.FindCutting( 'HeadSide') - Cutting.Tool.Diameter = 0 - Cutting.Tool.Thickness = 0 - Cutting.Tool.MaxDepth = 0 - if EgtMdbSetCurrMachining( Cutting.Name) then - local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) - if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then - Cutting.Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or Cutting.Tool.Diameter - Cutting.Tool.Thickness = EgtTdbGetCurrToolParam(MCH_TP.THICK) or Cutting.Tool.Thickness - Cutting.Tool.MaxDepth = EgtTdbGetCurrToolMaxDepth() or Cutting.Tool.MaxDepth - end - end - - -- lavorazione di sega a catena e relativi dati - local Chainsawing = {} - Chainsawing.Tool = {} - Chainsawing.Name, Chainsawing.IsDownHead = ML.FindSawing( 'Sawing') - Chainsawing.Tool.Length = 0 - Chainsawing.Tool.Width = 0 - Chainsawing.Tool.MaxMat = 0 - Chainsawing.Tool.Thickness = 0 - Chainsawing.Tool.CornerRadius = 0 - if EgtMdbSetCurrMachining( Chainsawing.Name) then - local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) - if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then - Chainsawing.Tool.Length = EgtTdbGetCurrToolParam( MCH_TP.LEN) or Chainsawing.Tool.Length - Chainsawing.Tool.MaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or Chainsawing.Tool.MaxMat - Chainsawing.Tool.Width = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or Chainsawing.Tool.Width - Chainsawing.Tool.Thickness = EgtTdbGetCurrToolParam( MCH_TP.THICK) or Chainsawing.Tool.Thickness - Chainsawing.Tool.CornerRadius = EgtTdbGetCurrToolParam( MCH_TP.CORNRAD) or Chainsawing.Tool.CornerRadius - end - end - - -- se tasca più stretta della lama la strategia non è applicabile - if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket too narrow for saw blade diameter' - return false, sErr - end - - -- se tasca più stretta della sega a catena la strategia non è applicabile - if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket too narrow for chainsaw width' - return false, sErr - end - - -- se tasca meno spessa della lama la strategia non è applicabile - if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket too narrow for saw blade thickness' - return false, sErr - end - - -- se tasca meno spessa della sega a catena la strategia non è applicabile - if Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket too narrow for chainsaw thickness' - return false, sErr - end - - -- parametri della lavorazione con lama - -- profondità e offset radiale - if Cutting.Tool.MaxDepth > Proc.Pocket.Depth - 10 * GEO.EPS_SMALL then - Cutting.Depth = Proc.Pocket.Depth - Cutting.RadialOffset = 0 - else - Cutting.Depth = Cutting.Tool.MaxDepth - Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth - end - -- faceuse - Cutting.Direction = Proc.Pocket.Direction - -- approccio e retrazione - Cutting.LeadIn = {} - Cutting.LeadOut = {} - Cutting.LeadIn.Type = MCH_MILL_LI.LINEAR - Cutting.LeadOut.Type = MCH_MILL_LI.LINEAR - Cutting.LeadIn.StartAddLength = -sqrt( Cutting.Depth * Cutting.Tool.Diameter - Cutting.Depth * Cutting.Depth) - Cutting.LeadOut.StartAddLength = -sqrt( Cutting.Depth * Cutting.Tool.Diameter - Cutting.Depth * Cutting.Depth) - Cutting.LeadIn.TangentDistance = 0 - Cutting.LeadOut.TangentDistance = 0 - Cutting.LeadIn.PerpDistance = 1 - Cutting.LeadOut.PerpDistance = 1 - Cutting.LeadIn.Elevation = 0 - Cutting.LeadOut.Elevation = 0 - Cutting.LeadIn.CompLength = 0 - Cutting.LeadOut.CompLength = 0 - - -- lavorazione con lama - local bOk, sErr = Fbs.MakeOne( Proc.Id, Proc.Pocket.FaceToMachine, Cutting.Name, Cutting.Tool.Diameter, Cutting.Direction, 2, Cutting.RadialOffset, BD.CUT_SIC, 0, -Cutting.LeadIn.StartAddLength, -Cutting.LeadOut.StartAddLength, sNotes, b3Raw) - - return bOk, sErr - - elseif sTopologyLongName == 'Groove-Through-RightAngles-Parallel-3' then - return - elseif sTopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then - return else - local sErr = 'Feature '.. Proc.FeatureId .. ' : Strategy not implemented for topology ' .. sTopologyLongName + nBottomFace = vBottomFace[1] + end + + local BottomFace = {} + BottomFace.Id = nBottomFace + BottomFace.Width = Proc.Face[nBottomFace + 1].Width + BottomFace.Height = Proc.Face[nBottomFace + 1].Height + BottomFace.Elevation = Proc.Face[nBottomFace + 1].Elevation + BottomFace.VtN = Proc.Face[nBottomFace + 1].VtN + if BottomFace.Height > BottomFace.Width then + BottomFace.Height, BottomFace.Width = BottomFace.Width, BottomFace.Height + end + + return BottomFace +end + +function SawPlusChain.GetFaceToMachine( Proc) + -- si cercano le facce adiacenti a quella di fondo + local FacesAdjacentToBottom = {} + local vBottomFaceAdjacencies = EgtSurfTmFacetAdjacencies( Proc.Id, Proc.Pocket.BottomFace.Id)[1] + for i = 1, #vBottomFaceAdjacencies do + if vBottomFaceAdjacencies[i] > -1 then + local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, Proc.Pocket.BottomFace.Id, vBottomFaceAdjacencies[i], GDB_ID.ROOT) + local dLen = dist( ptP1, ptP2) + table.insert( FacesAdjacentToBottom, { Id = vBottomFaceAdjacencies[i], LengthOnBottom = dLen}) + end + end + + -- si sceglie la faccia adiacente sul lato più lungo + local FaceToMachine = {} + table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnBottom > b.LengthOnBottom end) + FaceToMachine.Id = FacesAdjacentToBottom[1].Id + for i = 1, Proc.Fct do + if FaceToMachine.Id == Proc.Face[i].Id then + FaceToMachine.Width = Proc.Face[i].Width + FaceToMachine.Height = Proc.Face[i].Height + FaceToMachine.Elevation = Proc.Face[i].Elevation + FaceToMachine.VtN = Proc.Face[i].VtN + if FaceToMachine.Height > FaceToMachine.Width then + FaceToMachine.Height, FaceToMachine.Width = FaceToMachine.Width, FaceToMachine.Height + end + end + end + + return FaceToMachine +end + +function SawPlusChain.GetToolFromMachining( sMachiningName) + local Tool = {} + if EgtMdbSetCurrMachining( sMachiningName) then + local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID) + if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then + Tool.Name = EgtTdbGetCurrToolParam( MCH_TP.NAME) + Tool.IsCCW = ( EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) < 0) + Tool.Type = EgtTdbGetCurrToolParam( MCH_TP.TYPE) + -- lama + if Tool.Type == MCH_TY.SAW_STD or Tool.Type == MCH_TY.SAW_FLAT then + Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0 + Tool.Thickness = EgtTdbGetCurrToolParam(MCH_TP.THICK) or 0 + Tool.MaxDepth = EgtTdbGetCurrToolMaxDepth() or 0 + -- sega a catena + elseif Tool.Type == MCH_TY.MORTISE_STD then + Tool.Length = EgtTdbGetCurrToolParam( MCH_TP.LEN) or 0 + Tool.MaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) or 0 + Tool.Width = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0 + Tool.Thickness = EgtTdbGetCurrToolParam( MCH_TP.THICK) or 0 + Tool.CornerRadius = EgtTdbGetCurrToolParam( MCH_TP.CORNRAD) or 0 + -- altri utensili al momento non previsti + else + error( 'Wrong tool type') + end + end + end + + return Tool +end + +function SawPlusChain.GetSCC( vMachiningDirection) + local nSCC = MCH_SCC.NONE + if AreSameVectorApprox( vMachiningDirection, Z_AX()) then + nSCC = MCH_SCC.ADIR_ZP + elseif AreOppositeVectorApprox( vMachiningDirection, Z_AX()) then + nSCC = MCH_SCC.ADIR_ZM + elseif AreSameVectorApprox( vMachiningDirection, Y_AX()) then + nSCC = MCH_SCC.ADIR_YP + elseif AreOppositeVectorApprox( vMachiningDirection, Y_AX()) then + nSCC = MCH_SCC.ADIR_YM + elseif AreSameVectorApprox( vMachiningDirection, X_AX()) then + nSCC = MCH_SCC.ADIR_XP + elseif AreOppositeVectorApprox( vMachiningDirection, X_AX()) then + nSCC = MCH_SCC.ADIR_XM + end + + return nSCC +end + +function SawPlusChain.GetVerticalSteps( Proc, Machining) + VerticalSteps = {} + VerticalSteps.Count = ceil( ( Proc.Pocket.Height - 10 * GEO.EPS_SMALL) / Machining.Tool.Thickness) + VerticalSteps.StepLength = 0 + if VerticalSteps.Count > 1 then + VerticalSteps.StepLength = ( Proc.Pocket.Height - Machining.Tool.Thickness) / ( VerticalSteps.Count - 1) + end + + return VerticalSteps +end + +function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) + local sOperationName = sOperationNamePrefix .. ( EgtGetName( Machining.ProcId) or tostring( Machining.ProcId)) .. '_' .. tostring( Machining.FaceToMachine.Id + 1) + local nOperationId = EgtAddMachining( sOperationName, Machining.Name) + if not nOperationId then + local sErr = 'Error adding machining ' .. sOperationName .. '-' .. Machining.Name + EgtOutLog( sErr) return false, sErr end + + -- impostazione parametri lavorazione + EgtSetMachiningGeometry( {{ Machining.ProcId, Machining.FaceToMachine.Id}}) + EgtSetMachiningParam( MCH_MP.FACEUSE, Machining.Faceuse) + EgtSetMachiningParam( MCH_MP.SCC, Machining.SCC) + EgtSetMachiningParam( MCH_MP.INVERT, Machining.Invert) + EgtSetMachiningParam( MCH_MP.WORKSIDE, Machining.Workside) + EgtSetMachiningParam( MCH_MP.TOOLINVERT, Machining.ToolInvert) + EgtSetMachiningParam( MCH_MP.OFFSR, Machining.RadialOffset) + EgtSetMachiningParam( MCH_MP.OFFSL, Machining.LongitudinalOffset) + EgtSetMachiningParam( MCH_MP.LITANG, Machining.LeadIn.TangentDistance) + EgtSetMachiningParam( MCH_MP.LIPERP, Machining.LeadIn.PerpDistance) + EgtSetMachiningParam( MCH_MP.LOTANG, Machining.LeadOut.TangentDistance) + EgtSetMachiningParam( MCH_MP.LOPERP, Machining.LeadOut.PerpDistance) + EgtSetMachiningParam( MCH_MP.STARTADDLEN, Machining.LeadIn.StartAddLength) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, Machining.LeadOut.EndAddLength) + -- imposto angolo 3° asse rot + local sBlockedAxis = 'perpendicular' + local vtOut = EgtIf( Machining.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX()) + EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, sBlockedAxis, b3Raw, Machining.FaceToMachine.VtN, vtOut)) + + local bIsApplyOk = ML.ApplyMachining( true, false) + if not bIsApplyOk then + local _, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nOperationId, false) + return false, sErr + end + + return true end +function SawPlusChain.Make( Proc, b3Raw) + Proc.Pocket = {} + Proc.Pocket.Strategy = 'SawPlusChain' + + if Proc.TopologyLongName == 'Pocket-Blind-RightAngles-Parallel-5' then + Proc.Pocket.SideOpeningsCount = 0 + elseif Proc.TopologyLongName == 'Groove-Through-RightAngles-Parallel-3' then + Proc.Pocket.SideOpeningsCount = 1 + elseif Proc.TopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then + Proc.Pocket.SideOpeningsCount = 2 + else + local sErr = 'Feature '.. Proc.FeatureId .. ' : Strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName + return false, sErr + end + + -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) + if Proc.AffectedFaces.Bottom then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket on bottom face' + return false, sErr + end + + -- caratteristiche della tasca + Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc) + Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc) + Proc.Pocket.Width = Proc.Pocket.BottomFace.Width + Proc.Pocket.Height = Proc.Pocket.BottomFace.Height + Proc.Pocket.Depth = Proc.Pocket.BottomFace.Elevation + Proc.Pocket.Direction = Proc.Pocket.BottomFace.VtN + + -- lavorazione di lama e relativi dati + local Cutting = {} + Cutting.ProcId = Proc.Id + Cutting.Name = ML.FindCutting( 'HeadSide', true, false) + Cutting.Tool = SawPlusChain.GetToolFromMachining( Cutting.Name) + Cutting.FaceToMachine = Proc.Pocket.FaceToMachine + + -- lavorazione di sega a catena e relativi dati + local Chainsawing = {} + Chainsawing.ProcId = Proc.Id + Chainsawing.Name = ML.FindSawing( 'Sawing') + Chainsawing.Tool = SawPlusChain.GetToolFromMachining( Chainsawing.Name) + + -- verifica dimensioni tasca compatibili con utensili + -- se tasca meno spessa della lama la strategia non è applicabile + if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' + return false, sErr + end + -- se tasca meno spessa della sega a catena la strategia non è applicabile + if Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' + return false, sErr + end + if Proc.Pocket.SideOpeningsCount == 0 then + -- se tasca più stretta della lama la strategia non è applicabile + if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' + return false, sErr + end + -- se tasca più stretta della sega a catena la strategia non è applicabile + if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' + return false, sErr + end + end + + -- parametri della lavorazione con lama + -- lato di lavoro e inversioni + if Cutting.Tool.IsCCW then + Cutting.Workside = MCH_MILL_WS.RIGHT + Cutting.Invert = true + else + Cutting.Workside = MCH_MILL_WS.LEFT + Cutting.Invert = false + end + if Cutting.FaceToMachine.VtN:getZ() < - 10 * GEO.EPS_SMALL then + Cutting.ToolInvert = true + Cutting.Invert = not Cutting.Invert + else + Cutting.ToolInvert = false + end + -- profondità e offset radiale + if Cutting.Tool.MaxDepth > Proc.Pocket.Depth - 10 * GEO.EPS_SMALL then + Cutting.Depth = Proc.Pocket.Depth + Cutting.RadialOffset = 0 + else + Cutting.Depth = Cutting.Tool.MaxDepth + Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth + end + -- offset longitudinale + Cutting.LongitudinalOffset = 0 + -- faceuse + Cutting.Faceuse = BL.GetNearestOrthoOpposite( Proc.Pocket.Direction) + -- SCC + Cutting.SCC = SawPlusChain.GetSCC( Proc.Pocket.Direction) + -- approccio e retrazione + local dAddLengthToReduce = sqrt( Cutting.Depth * Cutting.Tool.Diameter - Cutting.Depth * Cutting.Depth) + Cutting.LeadIn = {} + Cutting.LeadOut = {} + Cutting.LeadIn.Type = MCH_MILL_LI.LINEAR + Cutting.LeadOut.Type = MCH_MILL_LI.LINEAR + Cutting.LeadIn.StartAddLength = 0 + Cutting.LeadOut.EndAddLength = 0 + Cutting.LeadIn.TangentDistance = 0 + Cutting.LeadOut.TangentDistance = 0 + Cutting.LeadIn.PerpDistance = 0 + Cutting.LeadOut.PerpDistance = 0 + Cutting.LeadIn.Elevation = 0 + Cutting.LeadOut.Elevation = 0 + Cutting.LeadIn.CompLength = 0 + Cutting.LeadOut.CompLength = 0 + if Proc.Pocket.SideOpeningsCount == 0 then + Cutting.LeadIn.StartAddLength = -dAddLengthToReduce + Cutting.LeadOut.EndAddLength = -dAddLengthToReduce + Cutting.LeadIn.PerpDistance = 1 + Cutting.LeadOut.PerpDistance = 1 + elseif Proc.Pocket.SideOpeningsCount == 1 then + -- BISOGNA CAPIRE DA CHE LATO ACCORCIARE! + end + + -- lavorazione con lama + Cutting.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Cutting) + local bOk, sErr + for i = 1, Cutting.VerticalSteps.Count do + if Cutting.ToolInvert then + Cutting.LongitudinalOffset = ( ( i - 1) * -Cutting.VerticalSteps.StepLength) - Cutting.Tool.Thickness + else + Cutting.LongitudinalOffset = ( i - 1) * Cutting.VerticalSteps.StepLength + end + + bOk, sErr = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) + end + + -- parametri della lavorazione con sega a catena + + -- lavorazione con sega a catena + + return bOk, sErr +end + +--#endregion SawPlusChain + --------------------------------------------------------------------- local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePart, bPrevBhSideMill, bAllWithEndCap) if not BD.MAXDIAM_POCK_CORNER then @@ -4762,7 +4924,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa if true or EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') == 1 then --TEST local bOk local sErr - bOk, sErr = MakeBySawPlusChain( Proc, Proc.TopologyLongName, b3Raw) + bOk, sErr = SawPlusChain.Make ( Proc, b3Raw) return bOk, sErr end From 3d0adbdd39f3afe8fdd6cbf5c1c3c8f9059fd8da Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 26 Mar 2024 10:59:34 +0100 Subject: [PATCH 03/26] - in SawPlusChainsaw aggiunta gestione accorciamenti percorsi per faccia laterale --- LuaLibs/ProcessLapJoint.lua | 104 ++++++++++++++++++++++++++++++------ 1 file changed, 88 insertions(+), 16 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 9977020..0159541 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4588,6 +4588,17 @@ end --#region SawPlusChain local SawPlusChain = {} +function SawPlusChain.IsTopologyOk( Proc) + if Proc.TopologyLongName == 'Pocket-Blind-RightAngles-Parallel-5' or + Proc.TopologyLongName == 'Groove-Through-RightAngles-Parallel-3' or + Proc.TopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then + return true + else + return false + end +end + + function SawPlusChain.GetBottomFace( Proc) -- la faccia di fondo ha sempre Fct - 1 adiacenze. Se si trovano più facce di fondo si sceglie quella con minor elevazione local vBottomFace = Topology.GetFacesWithGivenAdjacencyNumber( Proc, Proc.vAdj, Proc.Fct - 1) @@ -4622,6 +4633,10 @@ function SawPlusChain.GetBottomFace( Proc) end function SawPlusChain.GetFaceToMachine( Proc) + if not Proc.Pocket.BottomFace or not Proc.Pocket.BottomFace.Id then + Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc) + end + -- si cercano le facce adiacenti a quella di fondo local FacesAdjacentToBottom = {} local vBottomFaceAdjacencies = EgtSurfTmFacetAdjacencies( Proc.Id, Proc.Pocket.BottomFace.Id)[1] @@ -4652,6 +4667,42 @@ function SawPlusChain.GetFaceToMachine( Proc) return FaceToMachine end +function SawPlusChain.GetSideFaces( Proc) + if not Proc.Pocket.BottomFace or not Proc.Pocket.BottomFace.Id then + Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc) + end + + -- si cercano le facce adiacenti a quella di fondo + local FacesAdjacentToBottom = {} + local vBottomFaceAdjacencies = EgtSurfTmFacetAdjacencies( Proc.Id, Proc.Pocket.BottomFace.Id)[1] + for i = 1, #vBottomFaceAdjacencies do + if vBottomFaceAdjacencies[i] > -1 then + local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, Proc.Pocket.BottomFace.Id, vBottomFaceAdjacencies[i], GDB_ID.ROOT) + local dLen = dist( ptP1, ptP2) + table.insert( FacesAdjacentToBottom, { Id = vBottomFaceAdjacencies[i], LengthOnBottom = dLen}) + end + end + + -- le facce laterali sono quelle che rimangono una volta escluse le due sopra e sotto, che sono le più lunghe + table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnBottom > b.LengthOnBottom end) + local SideFaces = {} + for i = 1, #FacesAdjacentToBottom do + if i > 2 then + table.insert( SideFaces, FacesAdjacentToBottom[i]) + SideFaces[ #SideFaces].Id = FacesAdjacentToBottom[i].Id + SideFaces[ #SideFaces].Width = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Width + SideFaces[ #SideFaces].Height = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Height + SideFaces[ #SideFaces].Elevation = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Elevation + SideFaces[ #SideFaces].VtN = Proc.Face[FacesAdjacentToBottom[i].Id + 1].VtN + if SideFaces[ #SideFaces].Height > SideFaces[ #SideFaces].Width then + SideFaces[ #SideFaces].Height, SideFaces[ #SideFaces].Width = SideFaces[ #SideFaces].Width, SideFaces[ #SideFaces].Height + end + end + end + + return SideFaces +end + function SawPlusChain.GetToolFromMachining( sMachiningName) local Tool = {} if EgtMdbSetCurrMachining( sMachiningName) then @@ -4755,13 +4806,7 @@ function SawPlusChain.Make( Proc, b3Raw) Proc.Pocket = {} Proc.Pocket.Strategy = 'SawPlusChain' - if Proc.TopologyLongName == 'Pocket-Blind-RightAngles-Parallel-5' then - Proc.Pocket.SideOpeningsCount = 0 - elseif Proc.TopologyLongName == 'Groove-Through-RightAngles-Parallel-3' then - Proc.Pocket.SideOpeningsCount = 1 - elseif Proc.TopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then - Proc.Pocket.SideOpeningsCount = 2 - else + if not SawPlusChain.IsTopologyOk( Proc) then local sErr = 'Feature '.. Proc.FeatureId .. ' : Strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName return false, sErr end @@ -4775,6 +4820,7 @@ function SawPlusChain.Make( Proc, b3Raw) -- caratteristiche della tasca Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc) Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc) + Proc.Pocket.SideFaces = SawPlusChain.GetSideFaces( Proc) Proc.Pocket.Width = Proc.Pocket.BottomFace.Width Proc.Pocket.Height = Proc.Pocket.BottomFace.Height Proc.Pocket.Depth = Proc.Pocket.BottomFace.Elevation @@ -4826,6 +4872,7 @@ function SawPlusChain.Make( Proc, b3Raw) Cutting.Workside = MCH_MILL_WS.LEFT Cutting.Invert = false end + -- TODO gestire lama da sotto e lama downUp if Cutting.FaceToMachine.VtN:getZ() < - 10 * GEO.EPS_SMALL then Cutting.ToolInvert = true Cutting.Invert = not Cutting.Invert @@ -4847,28 +4894,53 @@ function SawPlusChain.Make( Proc, b3Raw) -- SCC Cutting.SCC = SawPlusChain.GetSCC( Proc.Pocket.Direction) -- approccio e retrazione - local dAddLengthToReduce = sqrt( Cutting.Depth * Cutting.Tool.Diameter - Cutting.Depth * Cutting.Depth) Cutting.LeadIn = {} Cutting.LeadOut = {} Cutting.LeadIn.Type = MCH_MILL_LI.LINEAR Cutting.LeadOut.Type = MCH_MILL_LI.LINEAR - Cutting.LeadIn.StartAddLength = 0 - Cutting.LeadOut.EndAddLength = 0 Cutting.LeadIn.TangentDistance = 0 Cutting.LeadOut.TangentDistance = 0 - Cutting.LeadIn.PerpDistance = 0 - Cutting.LeadOut.PerpDistance = 0 Cutting.LeadIn.Elevation = 0 Cutting.LeadOut.Elevation = 0 Cutting.LeadIn.CompLength = 0 Cutting.LeadOut.CompLength = 0 - if Proc.Pocket.SideOpeningsCount == 0 then + Cutting.IsStartClosed = false + Cutting.IsEndClosed = false + Cutting.LeadIn.StartAddLength = 0 + Cutting.LeadOut.EndAddLength = 0 + Cutting.LeadIn.PerpDistance = 0 + Cutting.LeadOut.PerpDistance = 0 + if #( Proc.Pocket.SideFaces) == 2 then + Cutting.IsStartClosed = true + Cutting.IsEndClosed = true + elseif #( Proc.Pocket.SideFaces) == 1 then + if not Cutting.ToolInvert then + Cutting.FaceToMachine.CCWDirection = ( Cutting.FaceToMachine.VtN ^ Proc.Pocket.BottomFace.VtN) + else + Cutting.FaceToMachine.CCWDirection = - ( Cutting.FaceToMachine.VtN ^ Proc.Pocket.BottomFace.VtN) + end + if Cutting.FaceToMachine.CCWDirection * Proc.Pocket.SideFaces[1].VtN > 10 * GEO.EPS_SMALL then + if Cutting.Tool.IsCCW then + Cutting.IsStartClosed = true + else + Cutting.IsEndClosed = true + end + else + if Cutting.Tool.IsCCW then + Cutting.IsEndClosed = true + else + Cutting.IsStartClosed = true + end + end + end + local dAddLengthToReduce = sqrt( Cutting.Depth * Cutting.Tool.Diameter - Cutting.Depth * Cutting.Depth) + if Cutting.IsStartClosed then Cutting.LeadIn.StartAddLength = -dAddLengthToReduce - Cutting.LeadOut.EndAddLength = -dAddLengthToReduce Cutting.LeadIn.PerpDistance = 1 + end + if Cutting.IsEndClosed then + Cutting.LeadOut.EndAddLength = -dAddLengthToReduce Cutting.LeadOut.PerpDistance = 1 - elseif Proc.Pocket.SideOpeningsCount == 1 then - -- BISOGNA CAPIRE DA CHE LATO ACCORCIARE! end -- lavorazione con lama From 8b1d3a0efbfcace8de7b99aca765d001680c3696 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 27 Mar 2024 09:24:35 +0100 Subject: [PATCH 04/26] modifiche a SawPlusChainsaw --- LuaLibs/ProcessLapJoint.lua | 50 ++++++++++++++++++++++++++----------- 1 file changed, 36 insertions(+), 14 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 0159541..0c3663c 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4598,7 +4598,6 @@ function SawPlusChain.IsTopologyOk( Proc) end end - function SawPlusChain.GetBottomFace( Proc) -- la faccia di fondo ha sempre Fct - 1 adiacenze. Se si trovano più facce di fondo si sceglie quella con minor elevazione local vBottomFace = Topology.GetFacesWithGivenAdjacencyNumber( Proc, Proc.vAdj, Proc.Fct - 1) @@ -4716,6 +4715,7 @@ function SawPlusChain.GetToolFromMachining( sMachiningName) Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0 Tool.Thickness = EgtTdbGetCurrToolParam(MCH_TP.THICK) or 0 Tool.MaxDepth = EgtTdbGetCurrToolMaxDepth() or 0 + Tool.SideStep = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDESTEP', 'd') -- sega a catena elseif Tool.Type == MCH_TY.MORTISE_STD then Tool.Length = EgtTdbGetCurrToolParam( MCH_TP.LEN) or 0 @@ -4754,15 +4754,31 @@ end function SawPlusChain.GetVerticalSteps( Proc, Machining) VerticalSteps = {} - VerticalSteps.Count = ceil( ( Proc.Pocket.Height - 10 * GEO.EPS_SMALL) / Machining.Tool.Thickness) VerticalSteps.StepLength = 0 + VerticalSteps.Count = ceil( ( Proc.Pocket.Height - 10 * GEO.EPS_SMALL) / Machining.Tool.Thickness) if VerticalSteps.Count > 1 then VerticalSteps.StepLength = ( Proc.Pocket.Height - Machining.Tool.Thickness) / ( VerticalSteps.Count - 1) + VerticalSteps.MaxElev = VerticalSteps.StepLength * VerticalSteps.Count - 10 * GEO.EPS_SMALL + VerticalSteps.StepType = MCH_MILL_ST.ONEWAY end return VerticalSteps end +function SawPlusChain.GetHorizontalSteps( Proc, Machining) + HorizontalSteps = {} + HorizontalSteps.StepLength = 0 + HorizontalSteps.Count = 1 + if Machining.Tool.SideStep then + HorizontalSteps.Count = ceil( ( Proc.Pocket.Depth - 10 * GEO.EPS_SMALL) / Machining.Tool.SideStep) + if HorizontalSteps.Count > 1 then + HorizontalSteps.StepLength = ( Proc.Pocket.Height - Machining.Tool.Thickness) / ( HorizontalSteps.Count - 1) + end + end + + return HorizontalSteps +end + function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) local sOperationName = sOperationNamePrefix .. ( EgtGetName( Machining.ProcId) or tostring( Machining.ProcId)) .. '_' .. tostring( Machining.FaceToMachine.Id + 1) local nOperationId = EgtAddMachining( sOperationName, Machining.Name) @@ -4787,6 +4803,14 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) EgtSetMachiningParam( MCH_MP.LOPERP, Machining.LeadOut.PerpDistance) EgtSetMachiningParam( MCH_MP.STARTADDLEN, Machining.LeadIn.StartAddLength) EgtSetMachiningParam( MCH_MP.ENDADDLEN, Machining.LeadOut.EndAddLength) + EgtSetMachiningParam( MCH_MP.ENDADDLEN, Machining.LeadOut.EndAddLength) + EgtSetMachiningParam( MCH_MP.STEPTYPE, Machining.VerticalSteps.StepType) + EgtSetMachiningParam( MCH_MP.STEP, Machining.VerticalSteps.StepLength) + local sNotes + if Machining.VerticalSteps.MaxElev then + sNotes = EgtSetValInNotes( sNotes, 'MaxElev', Machining.VerticalSteps.MaxElev) + end + EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) -- imposto angolo 3° asse rot local sBlockedAxis = 'perpendicular' local vtOut = EgtIf( Machining.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX()) @@ -4887,12 +4911,19 @@ function SawPlusChain.Make( Proc, b3Raw) Cutting.Depth = Cutting.Tool.MaxDepth Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth end - -- offset longitudinale - Cutting.LongitudinalOffset = 0 -- faceuse Cutting.Faceuse = BL.GetNearestOrthoOpposite( Proc.Pocket.Direction) -- SCC Cutting.SCC = SawPlusChain.GetSCC( Proc.Pocket.Direction) + -- step verticale e offset longitudinale + Cutting.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Cutting) + if Cutting.ToolInvert and Cutting.VerticalSteps.Count > 1 then + Cutting.LongitudinalOffset = - Proc.Pocket.Height + else + Cutting.LongitudinalOffset = 0 + end + -- step orizzontale + Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Proc, Cutting) -- approccio e retrazione Cutting.LeadIn = {} Cutting.LeadOut = {} @@ -4944,17 +4975,8 @@ function SawPlusChain.Make( Proc, b3Raw) end -- lavorazione con lama - Cutting.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Cutting) local bOk, sErr - for i = 1, Cutting.VerticalSteps.Count do - if Cutting.ToolInvert then - Cutting.LongitudinalOffset = ( ( i - 1) * -Cutting.VerticalSteps.StepLength) - Cutting.Tool.Thickness - else - Cutting.LongitudinalOffset = ( i - 1) * Cutting.VerticalSteps.StepLength - end - - bOk, sErr = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) - end + bOk, sErr = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) -- parametri della lavorazione con sega a catena From b7b9ea2065399a6e407ca01a15305139ae8bd0b5 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 27 Mar 2024 11:32:09 +0100 Subject: [PATCH 05/26] - implementate passate orizzontali --- LuaLibs/ProcessLapJoint.lua | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 0c3663c..b8cdcf8 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4770,9 +4770,9 @@ function SawPlusChain.GetHorizontalSteps( Proc, Machining) HorizontalSteps.StepLength = 0 HorizontalSteps.Count = 1 if Machining.Tool.SideStep then - HorizontalSteps.Count = ceil( ( Proc.Pocket.Depth - 10 * GEO.EPS_SMALL) / Machining.Tool.SideStep) + HorizontalSteps.Count = ceil( ( Machining.Depth - 10 * GEO.EPS_SMALL) / Machining.Tool.SideStep) if HorizontalSteps.Count > 1 then - HorizontalSteps.StepLength = ( Proc.Pocket.Height - Machining.Tool.Thickness) / ( HorizontalSteps.Count - 1) + HorizontalSteps.StepLength = ( Machining.Depth - Machining.Tool.SideStep) / ( HorizontalSteps.Count - 1) end end @@ -4862,6 +4862,7 @@ function SawPlusChain.Make( Proc, b3Raw) Chainsawing.ProcId = Proc.Id Chainsawing.Name = ML.FindSawing( 'Sawing') Chainsawing.Tool = SawPlusChain.GetToolFromMachining( Chainsawing.Name) + Chainsawing.FaceToMachine = Proc.Pocket.FaceToMachine -- verifica dimensioni tasca compatibili con utensili -- se tasca meno spessa della lama la strategia non è applicabile @@ -4974,10 +4975,14 @@ function SawPlusChain.Make( Proc, b3Raw) Cutting.LeadOut.PerpDistance = 1 end - -- lavorazione con lama local bOk, sErr - bOk, sErr = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) + -- lavorazione con lama + local dOriginalRadialOffset = Cutting.RadialOffset + for i = Cutting.HorizontalSteps.Count, 1, -1 do + Cutting.RadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.StepLength * ( i - 1) + bOk, sErr = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) + end -- parametri della lavorazione con sega a catena -- lavorazione con sega a catena @@ -6208,7 +6213,7 @@ local function MakeLongMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) for i = 1, #vAddId do local b3Box = EgtGetBBoxGlob( vAddId[i], GDB_BB.STANDARD) local nFct = EgtSurfTmFacetCount( vAddId[i]) - local AddProc = { Id = vAddId[i], Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId} + local AddProc = { Id = vAddId[i], Grp = Proc.Grp, FeatureId = Proc.FeatureId, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId} Topology.Classify( AddProc, b3Raw) -- lasciare il false nel sesto parametro (perchè internamente viene verificato se diverso da nil) local bOk, sMyWarn From 5ebdda4abd3224137fe62e44fec2971bcccf452d Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 28 Mar 2024 11:50:39 +0100 Subject: [PATCH 06/26] - refactoring e migliorie varie --- LuaLibs/ProcessLapJoint.lua | 139 ++++++++++++++++++++---------------- 1 file changed, 78 insertions(+), 61 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index b8cdcf8..fd7c76d 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4733,19 +4733,19 @@ function SawPlusChain.GetToolFromMachining( sMachiningName) return Tool end -function SawPlusChain.GetSCC( vMachiningDirection) +function SawPlusChain.GetSCC( vtMachiningDirection) local nSCC = MCH_SCC.NONE - if AreSameVectorApprox( vMachiningDirection, Z_AX()) then + if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then nSCC = MCH_SCC.ADIR_ZP - elseif AreOppositeVectorApprox( vMachiningDirection, Z_AX()) then + elseif AreOppositeVectorApprox( vtMachiningDirection, Z_AX()) then nSCC = MCH_SCC.ADIR_ZM - elseif AreSameVectorApprox( vMachiningDirection, Y_AX()) then + elseif AreSameVectorApprox( vtMachiningDirection, Y_AX()) then nSCC = MCH_SCC.ADIR_YP - elseif AreOppositeVectorApprox( vMachiningDirection, Y_AX()) then + elseif AreOppositeVectorApprox( vtMachiningDirection, Y_AX()) then nSCC = MCH_SCC.ADIR_YM - elseif AreSameVectorApprox( vMachiningDirection, X_AX()) then + elseif AreSameVectorApprox( vtMachiningDirection, X_AX()) then nSCC = MCH_SCC.ADIR_XP - elseif AreOppositeVectorApprox( vMachiningDirection, X_AX()) then + elseif AreOppositeVectorApprox( vtMachiningDirection, X_AX()) then nSCC = MCH_SCC.ADIR_XM end @@ -4765,7 +4765,7 @@ function SawPlusChain.GetVerticalSteps( Proc, Machining) return VerticalSteps end -function SawPlusChain.GetHorizontalSteps( Proc, Machining) +function SawPlusChain.GetHorizontalSteps( Machining) HorizontalSteps = {} HorizontalSteps.StepLength = 0 HorizontalSteps.Count = 1 @@ -4779,6 +4779,60 @@ function SawPlusChain.GetHorizontalSteps( Proc, Machining) return HorizontalSteps end +function SawPlusChain.GetLeadInOut( Proc, Machining) + -- si determina se l'inizio o la fine della lavorazione sono chiusi e l'eventuale riduzione da applicare + local bIsStartClosed = false + local bIsEndClosed = false + local dAddLengthToReduce = sqrt( Machining.Depth * Machining.Tool.Diameter - Machining.Depth * Machining.Depth) + if #( Proc.Pocket.SideFaces) == 2 then + bIsStartClosed = true + bIsEndClosed = true + elseif #( Proc.Pocket.SideFaces) == 1 then + local CCWDirection = ( Machining.FaceToMachine.VtN ^ Proc.Pocket.BottomFace.VtN) + if Machining.ToolInvert then + CCWDirection = - CCWDirection + end + if CCWDirection * Proc.Pocket.SideFaces[1].VtN > 10 * GEO.EPS_SMALL then + if Machining.Tool.IsCCW then + bIsStartClosed = true + else + bIsEndClosed = true + end + else + if Machining.Tool.IsCCW then + bIsEndClosed = true + else + bIsStartClosed = true + end + end + end + + LeadIn = {} + LeadOut = {} + LeadIn.Type = MCH_MILL_LI.LINEAR + LeadOut.Type = MCH_MILL_LI.LINEAR + LeadIn.TangentDistance = 0 + LeadOut.TangentDistance = 0 + LeadIn.Elevation = 0 + LeadOut.Elevation = 0 + LeadIn.CompLength = 0 + LeadOut.CompLength = 0 + LeadIn.StartAddLength = 0 + LeadOut.EndAddLength = 0 + LeadIn.PerpDistance = 0 + LeadOut.PerpDistance = 0 + if bIsStartClosed then + LeadIn.StartAddLength = -dAddLengthToReduce + LeadIn.PerpDistance = 1 + end + if bIsEndClosed then + LeadOut.EndAddLength = -dAddLengthToReduce + LeadOut.PerpDistance = 1 + end + + return LeadIn, LeadOut +end + function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) local sOperationName = sOperationNamePrefix .. ( EgtGetName( Machining.ProcId) or tostring( Machining.ProcId)) .. '_' .. tostring( Machining.FaceToMachine.Id + 1) local nOperationId = EgtAddMachining( sOperationName, Machining.Name) @@ -4810,11 +4864,8 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) if Machining.VerticalSteps.MaxElev then sNotes = EgtSetValInNotes( sNotes, 'MaxElev', Machining.VerticalSteps.MaxElev) end + EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut)) EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) - -- imposto angolo 3° asse rot - local sBlockedAxis = 'perpendicular' - local vtOut = EgtIf( Machining.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX()) - EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, sBlockedAxis, b3Raw, Machining.FaceToMachine.VtN, vtOut)) local bIsApplyOk = ML.ApplyMachining( true, false) if not bIsApplyOk then @@ -4854,6 +4905,10 @@ function SawPlusChain.Make( Proc, b3Raw) local Cutting = {} Cutting.ProcId = Proc.Id Cutting.Name = ML.FindCutting( 'HeadSide', true, false) + if not Cutting.Name then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' + return false, sErr + end Cutting.Tool = SawPlusChain.GetToolFromMachining( Cutting.Name) Cutting.FaceToMachine = Proc.Pocket.FaceToMachine @@ -4861,6 +4916,10 @@ function SawPlusChain.Make( Proc, b3Raw) local Chainsawing = {} Chainsawing.ProcId = Proc.Id Chainsawing.Name = ML.FindSawing( 'Sawing') + if not Chainsawing.Name then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' + return false, sErr + end Chainsawing.Tool = SawPlusChain.GetToolFromMachining( Chainsawing.Name) Chainsawing.FaceToMachine = Proc.Pocket.FaceToMachine @@ -4916,6 +4975,10 @@ function SawPlusChain.Make( Proc, b3Raw) Cutting.Faceuse = BL.GetNearestOrthoOpposite( Proc.Pocket.Direction) -- SCC Cutting.SCC = SawPlusChain.GetSCC( Proc.Pocket.Direction) + -- asse bloccato + Cutting.BlockedAxis = {} + Cutting.BlockedAxis.Orientation = 'perpendicular' + Cutting.BlockedAxis.VtOut = EgtIf( Cutting.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX()) -- step verticale e offset longitudinale Cutting.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Cutting) if Cutting.ToolInvert and Cutting.VerticalSteps.Count > 1 then @@ -4924,56 +4987,9 @@ function SawPlusChain.Make( Proc, b3Raw) Cutting.LongitudinalOffset = 0 end -- step orizzontale - Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Proc, Cutting) + Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Cutting) -- approccio e retrazione - Cutting.LeadIn = {} - Cutting.LeadOut = {} - Cutting.LeadIn.Type = MCH_MILL_LI.LINEAR - Cutting.LeadOut.Type = MCH_MILL_LI.LINEAR - Cutting.LeadIn.TangentDistance = 0 - Cutting.LeadOut.TangentDistance = 0 - Cutting.LeadIn.Elevation = 0 - Cutting.LeadOut.Elevation = 0 - Cutting.LeadIn.CompLength = 0 - Cutting.LeadOut.CompLength = 0 - Cutting.IsStartClosed = false - Cutting.IsEndClosed = false - Cutting.LeadIn.StartAddLength = 0 - Cutting.LeadOut.EndAddLength = 0 - Cutting.LeadIn.PerpDistance = 0 - Cutting.LeadOut.PerpDistance = 0 - if #( Proc.Pocket.SideFaces) == 2 then - Cutting.IsStartClosed = true - Cutting.IsEndClosed = true - elseif #( Proc.Pocket.SideFaces) == 1 then - if not Cutting.ToolInvert then - Cutting.FaceToMachine.CCWDirection = ( Cutting.FaceToMachine.VtN ^ Proc.Pocket.BottomFace.VtN) - else - Cutting.FaceToMachine.CCWDirection = - ( Cutting.FaceToMachine.VtN ^ Proc.Pocket.BottomFace.VtN) - end - if Cutting.FaceToMachine.CCWDirection * Proc.Pocket.SideFaces[1].VtN > 10 * GEO.EPS_SMALL then - if Cutting.Tool.IsCCW then - Cutting.IsStartClosed = true - else - Cutting.IsEndClosed = true - end - else - if Cutting.Tool.IsCCW then - Cutting.IsEndClosed = true - else - Cutting.IsStartClosed = true - end - end - end - local dAddLengthToReduce = sqrt( Cutting.Depth * Cutting.Tool.Diameter - Cutting.Depth * Cutting.Depth) - if Cutting.IsStartClosed then - Cutting.LeadIn.StartAddLength = -dAddLengthToReduce - Cutting.LeadIn.PerpDistance = 1 - end - if Cutting.IsEndClosed then - Cutting.LeadOut.EndAddLength = -dAddLengthToReduce - Cutting.LeadOut.PerpDistance = 1 - end + Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.GetLeadInOut( Proc, Cutting) local bOk, sErr @@ -4983,6 +4999,7 @@ function SawPlusChain.Make( Proc, b3Raw) Cutting.RadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.StepLength * ( i - 1) bOk, sErr = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) end + -- parametri della lavorazione con sega a catena -- lavorazione con sega a catena From e3f8783c182dde5801479f8bfeca5193c04ad1a9 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Fri, 29 Mar 2024 09:29:08 +0100 Subject: [PATCH 07/26] - in SawPlusChain piccole correzioni --- LuaLibs/ProcessLapJoint.lua | 59 ++++++++++++++++++++++++++----------- 1 file changed, 42 insertions(+), 17 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index fd7c76d..d6697fd 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4753,7 +4753,12 @@ function SawPlusChain.GetSCC( vtMachiningDirection) end function SawPlusChain.GetVerticalSteps( Proc, Machining) - VerticalSteps = {} + if not Proc.Pocket or not Proc.Pocket.Height then + error( 'Missing pocket depth') + elseif not Machining.Tool or not Machining.Tool.Thickness then + error( 'Missing tool thickness') + end + local VerticalSteps = {} VerticalSteps.StepLength = 0 VerticalSteps.Count = ceil( ( Proc.Pocket.Height - 10 * GEO.EPS_SMALL) / Machining.Tool.Thickness) if VerticalSteps.Count > 1 then @@ -4766,7 +4771,10 @@ function SawPlusChain.GetVerticalSteps( Proc, Machining) end function SawPlusChain.GetHorizontalSteps( Machining) - HorizontalSteps = {} + if not Machining.Depth then + error( 'Missing machining depth') + end + local HorizontalSteps = {} HorizontalSteps.StepLength = 0 HorizontalSteps.Count = 1 if Machining.Tool.SideStep then @@ -4807,8 +4815,8 @@ function SawPlusChain.GetLeadInOut( Proc, Machining) end end - LeadIn = {} - LeadOut = {} + local LeadIn = {} + local LeadOut = {} LeadIn.Type = MCH_MILL_LI.LINEAR LeadOut.Type = MCH_MILL_LI.LINEAR LeadIn.TangentDistance = 0 @@ -4865,6 +4873,9 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) sNotes = EgtSetValInNotes( sNotes, 'MaxElev', Machining.VerticalSteps.MaxElev) end EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut)) + EgtSetMachiningParam( MCH_MP.OVERL, Machining.Overlap) + EgtSetMachiningParam( MCH_MP.INITANGS, Machining.SuggestedAngles) + EgtSetMachiningParam( MCH_MP.STARTPOS, max( Machining.StartSafetyLength, EgtGetMachiningParam( MCH_MP.STARTPOS))) EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) local bIsApplyOk = ML.ApplyMachining( true, false) @@ -4877,7 +4888,7 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) return true end -function SawPlusChain.Make( Proc, b3Raw) +function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) Proc.Pocket = {} Proc.Pocket.Strategy = 'SawPlusChain' @@ -4887,6 +4898,7 @@ function SawPlusChain.Make( Proc, b3Raw) end -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) + -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto if Proc.AffectedFaces.Bottom then local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket on bottom face' return false, sErr @@ -4930,7 +4942,7 @@ function SawPlusChain.Make( Proc, b3Raw) return false, sErr end -- se tasca meno spessa della sega a catena la strategia non è applicabile - if Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then + if not bOnlySaw and Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' return false, sErr end @@ -4941,7 +4953,7 @@ function SawPlusChain.Make( Proc, b3Raw) return false, sErr end -- se tasca più stretta della sega a catena la strategia non è applicabile - if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + if not bOnlySaw and Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' return false, sErr end @@ -4971,14 +4983,6 @@ function SawPlusChain.Make( Proc, b3Raw) Cutting.Depth = Cutting.Tool.MaxDepth Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth end - -- faceuse - Cutting.Faceuse = BL.GetNearestOrthoOpposite( Proc.Pocket.Direction) - -- SCC - Cutting.SCC = SawPlusChain.GetSCC( Proc.Pocket.Direction) - -- asse bloccato - Cutting.BlockedAxis = {} - Cutting.BlockedAxis.Orientation = 'perpendicular' - Cutting.BlockedAxis.VtOut = EgtIf( Cutting.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX()) -- step verticale e offset longitudinale Cutting.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Cutting) if Cutting.ToolInvert and Cutting.VerticalSteps.Count > 1 then @@ -4986,8 +4990,20 @@ function SawPlusChain.Make( Proc, b3Raw) else Cutting.LongitudinalOffset = 0 end + Cutting.StartSafetyLength = 10 + Cutting.Overlap = 0 -- step orizzontale Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Cutting) + -- faceuse + Cutting.Faceuse = BL.GetNearestOrthoOpposite( Proc.Pocket.Direction) + -- SCC + Cutting.SCC = SawPlusChain.GetSCC( Proc.Pocket.Direction) + -- angoli suggeriti + Cutting.SuggestedAngles = '' + -- asse bloccato + Cutting.BlockedAxis = {} + Cutting.BlockedAxis.Orientation = 'perpendicular' + Cutting.BlockedAxis.VtOut = EgtIf( Cutting.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX()) -- approccio e retrazione Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.GetLeadInOut( Proc, Cutting) @@ -5000,8 +5016,16 @@ function SawPlusChain.Make( Proc, b3Raw) bOk, sErr = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) end + if bOnlySaw then + return bOk, sErr + end + -- parametri della lavorazione con sega a catena + + + + -- lavorazione con sega a catena return bOk, sErr @@ -5037,10 +5061,11 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa -- rimuovere true or!!!!!! - if true or EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') == 1 then --TEST + if true or EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') > 0 then --TEST local bOk local sErr - bOk, sErr = SawPlusChain.Make ( Proc, b3Raw) + local bOnlySaw = EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') == 1 + bOk, sErr = SawPlusChain.Make ( Proc, b3Raw, bOnlySaw) return bOk, sErr end From 51b5c7ac80d224aa20f53d5f3e5b62b7d01562cb Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Fri, 29 Mar 2024 19:20:19 +0100 Subject: [PATCH 08/26] - in SawPlusChain implementata sega a catena, da testare --- LuaLibs/ProcessLapJoint.lua | 158 +++++++++++++++++++++++++----------- 1 file changed, 110 insertions(+), 48 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index d6697fd..07fa52e 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4710,9 +4710,9 @@ function SawPlusChain.GetToolFromMachining( sMachiningName) Tool.Name = EgtTdbGetCurrToolParam( MCH_TP.NAME) Tool.IsCCW = ( EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) < 0) Tool.Type = EgtTdbGetCurrToolParam( MCH_TP.TYPE) + Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0 -- lama if Tool.Type == MCH_TY.SAW_STD or Tool.Type == MCH_TY.SAW_FLAT then - Tool.Diameter = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or 0 Tool.Thickness = EgtTdbGetCurrToolParam(MCH_TP.THICK) or 0 Tool.MaxDepth = EgtTdbGetCurrToolMaxDepth() or 0 Tool.SideStep = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'SIDESTEP', 'd') @@ -4776,12 +4776,9 @@ function SawPlusChain.GetHorizontalSteps( Machining) end local HorizontalSteps = {} HorizontalSteps.StepLength = 0 - HorizontalSteps.Count = 1 - if Machining.Tool.SideStep then - HorizontalSteps.Count = ceil( ( Machining.Depth - 10 * GEO.EPS_SMALL) / Machining.Tool.SideStep) - if HorizontalSteps.Count > 1 then - HorizontalSteps.StepLength = ( Machining.Depth - Machining.Tool.SideStep) / ( HorizontalSteps.Count - 1) - end + HorizontalSteps.Count = ceil( ( Machining.Depth - 10 * GEO.EPS_SMALL) / Machining.Tool.SideStep) + if HorizontalSteps.Count > 1 then + HorizontalSteps.StepLength = ( Machining.Depth - Machining.Tool.SideStep) / ( HorizontalSteps.Count - 1) end return HorizontalSteps @@ -4791,13 +4788,19 @@ function SawPlusChain.GetLeadInOut( Proc, Machining) -- si determina se l'inizio o la fine della lavorazione sono chiusi e l'eventuale riduzione da applicare local bIsStartClosed = false local bIsEndClosed = false - local dAddLengthToReduce = sqrt( Machining.Depth * Machining.Tool.Diameter - Machining.Depth * Machining.Depth) + local bIsMortising = ( Machining.Tool.Type == MCH_TY.MORTISE_STD) + local dAddLengthToReduce = 0 + if bIsMortising then + dAddLengthToReduce = Machining.Tool.Diameter / 2 + else + dAddLengthToReduce = sqrt( Machining.Depth * Machining.Tool.Diameter - Machining.Depth * Machining.Depth) + end if #( Proc.Pocket.SideFaces) == 2 then bIsStartClosed = true bIsEndClosed = true elseif #( Proc.Pocket.SideFaces) == 1 then local CCWDirection = ( Machining.FaceToMachine.VtN ^ Proc.Pocket.BottomFace.VtN) - if Machining.ToolInvert then + if Machining.ToolInvert or bIsMortising then CCWDirection = - CCWDirection end if CCWDirection * Proc.Pocket.SideFaces[1].VtN > 10 * GEO.EPS_SMALL then @@ -4817,25 +4820,34 @@ function SawPlusChain.GetLeadInOut( Proc, Machining) local LeadIn = {} local LeadOut = {} - LeadIn.Type = MCH_MILL_LI.LINEAR - LeadOut.Type = MCH_MILL_LI.LINEAR - LeadIn.TangentDistance = 0 - LeadOut.TangentDistance = 0 - LeadIn.Elevation = 0 - LeadOut.Elevation = 0 - LeadIn.CompLength = 0 - LeadOut.CompLength = 0 LeadIn.StartAddLength = 0 LeadOut.EndAddLength = 0 - LeadIn.PerpDistance = 0 - LeadOut.PerpDistance = 0 - if bIsStartClosed then - LeadIn.StartAddLength = -dAddLengthToReduce - LeadIn.PerpDistance = 1 - end - if bIsEndClosed then - LeadOut.EndAddLength = -dAddLengthToReduce - LeadOut.PerpDistance = 1 + if Machining.Tool.Type ~= MCH_TY.MORTISE_STD then + LeadIn.Type = MCH_MILL_LI.LINEAR + LeadOut.Type = MCH_MILL_LI.LINEAR + LeadIn.TangentDistance = 0 + LeadOut.TangentDistance = 0 + LeadIn.Elevation = 0 + LeadOut.Elevation = 0 + LeadIn.CompLength = 0 + LeadOut.CompLength = 0 + LeadIn.PerpDistance = 0 + LeadOut.PerpDistance = 0 + if bIsStartClosed then + LeadIn.StartAddLength = -dAddLengthToReduce + LeadIn.PerpDistance = 1 + end + if bIsEndClosed then + LeadOut.EndAddLength = -dAddLengthToReduce + LeadOut.PerpDistance = 1 + end + else + if bIsStartClosed then + LeadIn.StartAddLength = -dAddLengthToReduce + end + if bIsEndClosed then + LeadOut.EndAddLength = -dAddLengthToReduce + end end return LeadIn, LeadOut @@ -4851,6 +4863,7 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) end -- impostazione parametri lavorazione + local sUserNotes = EgtGetMachiningParam( MCH_MP.USERNOTES) EgtSetMachiningGeometry( {{ Machining.ProcId, Machining.FaceToMachine.Id}}) EgtSetMachiningParam( MCH_MP.FACEUSE, Machining.Faceuse) EgtSetMachiningParam( MCH_MP.SCC, Machining.SCC) @@ -4859,24 +4872,30 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) EgtSetMachiningParam( MCH_MP.TOOLINVERT, Machining.ToolInvert) EgtSetMachiningParam( MCH_MP.OFFSR, Machining.RadialOffset) EgtSetMachiningParam( MCH_MP.OFFSL, Machining.LongitudinalOffset) - EgtSetMachiningParam( MCH_MP.LITANG, Machining.LeadIn.TangentDistance) - EgtSetMachiningParam( MCH_MP.LIPERP, Machining.LeadIn.PerpDistance) - EgtSetMachiningParam( MCH_MP.LOTANG, Machining.LeadOut.TangentDistance) - EgtSetMachiningParam( MCH_MP.LOPERP, Machining.LeadOut.PerpDistance) + if Machining.Tool.Type ~= MCH_TY.MORTISE_STD then + EgtSetMachiningParam( MCH_MP.LITANG, Machining.LeadIn.TangentDistance) + EgtSetMachiningParam( MCH_MP.LIPERP, Machining.LeadIn.PerpDistance) + EgtSetMachiningParam( MCH_MP.LOTANG, Machining.LeadOut.TangentDistance) + EgtSetMachiningParam( MCH_MP.LOPERP, Machining.LeadOut.PerpDistance) + end EgtSetMachiningParam( MCH_MP.STARTADDLEN, Machining.LeadIn.StartAddLength) EgtSetMachiningParam( MCH_MP.ENDADDLEN, Machining.LeadOut.EndAddLength) - EgtSetMachiningParam( MCH_MP.ENDADDLEN, Machining.LeadOut.EndAddLength) - EgtSetMachiningParam( MCH_MP.STEPTYPE, Machining.VerticalSteps.StepType) - EgtSetMachiningParam( MCH_MP.STEP, Machining.VerticalSteps.StepLength) - local sNotes - if Machining.VerticalSteps.MaxElev then - sNotes = EgtSetValInNotes( sNotes, 'MaxElev', Machining.VerticalSteps.MaxElev) + if Machining.Steps then + if Machining.Steps.StepType then + EgtSetMachiningParam( MCH_MP.STEPTYPE, Machining.Steps.StepType) + end + if Machining.Steps.StepLength then + EgtSetMachiningParam( MCH_MP.STEP, Machining.Steps.StepLength) + end + if Machining.Steps.MaxElev then + sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', Machining.Steps.MaxElev) + end end EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut)) EgtSetMachiningParam( MCH_MP.OVERL, Machining.Overlap) EgtSetMachiningParam( MCH_MP.INITANGS, Machining.SuggestedAngles) EgtSetMachiningParam( MCH_MP.STARTPOS, max( Machining.StartSafetyLength, EgtGetMachiningParam( MCH_MP.STARTPOS))) - EgtSetMachiningParam( MCH_MP.USERNOTES, sNotes) + EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes) local bIsApplyOk = ML.ApplyMachining( true, false) if not bIsApplyOk then @@ -4984,16 +5003,16 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth end -- step verticale e offset longitudinale - Cutting.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Cutting) - if Cutting.ToolInvert and Cutting.VerticalSteps.Count > 1 then + Cutting.Steps = SawPlusChain.GetVerticalSteps( Proc, Cutting) + if Cutting.ToolInvert and Cutting.Steps.Count > 1 then Cutting.LongitudinalOffset = - Proc.Pocket.Height else Cutting.LongitudinalOffset = 0 end + -- distanza di sicurezza Cutting.StartSafetyLength = 10 + -- overlap Cutting.Overlap = 0 - -- step orizzontale - Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Cutting) -- faceuse Cutting.Faceuse = BL.GetNearestOrthoOpposite( Proc.Pocket.Direction) -- SCC @@ -5010,9 +5029,16 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) local bOk, sErr -- lavorazione con lama - local dOriginalRadialOffset = Cutting.RadialOffset + -- eventuale step orizzontale + if Cutting.Tool.SideStep then + Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Cutting) + else + Cutting.HorizontalSteps.Count = 1 + Cutting.HorizontalSteps.StepLength = 0 + end + local dOriginalRadialOffsetCutting = Cutting.RadialOffset for i = Cutting.HorizontalSteps.Count, 1, -1 do - Cutting.RadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.StepLength * ( i - 1) + Cutting.RadialOffset = dOriginalRadialOffsetCutting + Cutting.HorizontalSteps.StepLength * ( i - 1) bOk, sErr = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) end @@ -5021,12 +5047,48 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) end -- parametri della lavorazione con sega a catena + -- lato di lavoro e inversioni + if Chainsawing.Tool.IsCCW then + Chainsawing.Workside = MCH_MILL_WS.RIGHT + Chainsawing.Invert = false + else + Chainsawing.Workside = MCH_MILL_WS.LEFT + Chainsawing.Invert = true + end + Chainsawing.ToolInvert = false + -- profondità e offset longitudinale + if Chainsawing.Tool.MaxMat > Proc.Pocket.Depth - 10 * GEO.EPS_SMALL then + Chainsawing.Depth = Proc.Pocket.Depth + Chainsawing.LongitudinalOffset = 0 + else + Chainsawing.Depth = Chainsawing.Tool.MaxMat + Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth + end + -- offset radiale + Chainsawing.RadialOffset = 0 + -- distanza di sicurezza + Chainsawing.StartSafetyLength = 10 + -- overlap + Chainsawing.Overlap = 0 + -- faceuse + Chainsawing.Faceuse = BL.GetNearestParalOpposite( Proc.Pocket.Direction) + -- SCC + Chainsawing.SCC = MCH_SCC.NONE + -- angoli suggeriti + Chainsawing.SuggestedAngles = '' + -- asse bloccato + Chainsawing.BlockedAxis = {} + Chainsawing.BlockedAxis.Orientation = 'perpendicular' + -- approccio e retrazione + Chainsawing.LeadIn, Chainsawing.LeadOut = SawPlusChain.GetLeadInOut( Proc, Chainsawing) - - - - - -- lavorazione con sega a catena +-- lavorazione con sega a catena +Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing) +local dOriginalRadialOffsetChainsawing = Chainsawing.RadialOffset +for i = Chainsawing.VerticalSteps.Count, 1, -1 do + Chainsawing.RadialOffset = dOriginalRadialOffsetChainsawing + Chainsawing.VerticalSteps.StepLength * ( i - 1) + bOk, sErr = SawPlusChain.ApplyMachining( Chainsawing, 'Chainsaw_', b3Raw) +end return bOk, sErr end From 1e094aac56d7698631d7a54989a1825bc6705b9a Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 2 Apr 2024 10:30:27 +0200 Subject: [PATCH 09/26] - in SawPlusChain correzioni a sega a catena --- LuaLibs/ProcessLapJoint.lua | 111 ++++++++++++++++++++---------------- 1 file changed, 62 insertions(+), 49 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 07fa52e..4d63712 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4763,7 +4763,6 @@ function SawPlusChain.GetVerticalSteps( Proc, Machining) VerticalSteps.Count = ceil( ( Proc.Pocket.Height - 10 * GEO.EPS_SMALL) / Machining.Tool.Thickness) if VerticalSteps.Count > 1 then VerticalSteps.StepLength = ( Proc.Pocket.Height - Machining.Tool.Thickness) / ( VerticalSteps.Count - 1) - VerticalSteps.MaxElev = VerticalSteps.StepLength * VerticalSteps.Count - 10 * GEO.EPS_SMALL VerticalSteps.StepType = MCH_MILL_ST.ONEWAY end @@ -4788,7 +4787,7 @@ function SawPlusChain.GetLeadInOut( Proc, Machining) -- si determina se l'inizio o la fine della lavorazione sono chiusi e l'eventuale riduzione da applicare local bIsStartClosed = false local bIsEndClosed = false - local bIsMortising = ( Machining.Tool.Type == MCH_TY.MORTISE_STD) + local bIsMortising = ( Machining.Type == MCH_OY.MORTISING) local dAddLengthToReduce = 0 if bIsMortising then dAddLengthToReduce = Machining.Tool.Diameter / 2 @@ -4822,32 +4821,29 @@ function SawPlusChain.GetLeadInOut( Proc, Machining) local LeadOut = {} LeadIn.StartAddLength = 0 LeadOut.EndAddLength = 0 - if Machining.Tool.Type ~= MCH_TY.MORTISE_STD then + if not bIsMortising then LeadIn.Type = MCH_MILL_LI.LINEAR LeadOut.Type = MCH_MILL_LI.LINEAR LeadIn.TangentDistance = 0 LeadOut.TangentDistance = 0 + LeadIn.PerpDistance = 0 + LeadOut.PerpDistance = 0 LeadIn.Elevation = 0 LeadOut.Elevation = 0 LeadIn.CompLength = 0 LeadOut.CompLength = 0 - LeadIn.PerpDistance = 0 - LeadOut.PerpDistance = 0 if bIsStartClosed then - LeadIn.StartAddLength = -dAddLengthToReduce LeadIn.PerpDistance = 1 end if bIsEndClosed then - LeadOut.EndAddLength = -dAddLengthToReduce LeadOut.PerpDistance = 1 end - else - if bIsStartClosed then - LeadIn.StartAddLength = -dAddLengthToReduce - end - if bIsEndClosed then - LeadOut.EndAddLength = -dAddLengthToReduce - end + end + if bIsStartClosed then + LeadIn.StartAddLength = -dAddLengthToReduce + end + if bIsEndClosed then + LeadOut.EndAddLength = -dAddLengthToReduce end return LeadIn, LeadOut @@ -4872,11 +4868,17 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) EgtSetMachiningParam( MCH_MP.TOOLINVERT, Machining.ToolInvert) EgtSetMachiningParam( MCH_MP.OFFSR, Machining.RadialOffset) EgtSetMachiningParam( MCH_MP.OFFSL, Machining.LongitudinalOffset) - if Machining.Tool.Type ~= MCH_TY.MORTISE_STD then + if Machining.Type ~= MCH_OY.MORTISING then + EgtSetMachiningParam( MCH_MP.LEADINTYPE, Machining.LeadIn.Type) + EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, Machining.LeadOut.Type) EgtSetMachiningParam( MCH_MP.LITANG, Machining.LeadIn.TangentDistance) - EgtSetMachiningParam( MCH_MP.LIPERP, Machining.LeadIn.PerpDistance) EgtSetMachiningParam( MCH_MP.LOTANG, Machining.LeadOut.TangentDistance) + EgtSetMachiningParam( MCH_MP.LIPERP, Machining.LeadIn.PerpDistance) EgtSetMachiningParam( MCH_MP.LOPERP, Machining.LeadOut.PerpDistance) + EgtSetMachiningParam( MCH_MP.LIELEV, Machining.LeadIn.Elevation) + EgtSetMachiningParam( MCH_MP.LOELEV, Machining.LeadOut.Elevation) + EgtSetMachiningParam( MCH_MP.LICOMPLEN, Machining.LeadIn.CompLength) + EgtSetMachiningParam( MCH_MP.LOCOMPLEN, Machining.LeadOut.CompLength) end EgtSetMachiningParam( MCH_MP.STARTADDLEN, Machining.LeadIn.StartAddLength) EgtSetMachiningParam( MCH_MP.ENDADDLEN, Machining.LeadOut.EndAddLength) @@ -4887,14 +4889,14 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) if Machining.Steps.StepLength then EgtSetMachiningParam( MCH_MP.STEP, Machining.Steps.StepLength) end - if Machining.Steps.MaxElev then - sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', Machining.Steps.MaxElev) - end end EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut)) EgtSetMachiningParam( MCH_MP.OVERL, Machining.Overlap) EgtSetMachiningParam( MCH_MP.INITANGS, Machining.SuggestedAngles) EgtSetMachiningParam( MCH_MP.STARTPOS, max( Machining.StartSafetyLength, EgtGetMachiningParam( MCH_MP.STARTPOS))) + if Machining.MaxElev then + sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', Machining.MaxElev) + end EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes) local bIsApplyOk = ML.ApplyMachining( true, false) @@ -4940,42 +4942,22 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' return false, sErr end + Cutting.Type = MCH_OY.MILLING Cutting.Tool = SawPlusChain.GetToolFromMachining( Cutting.Name) Cutting.FaceToMachine = Proc.Pocket.FaceToMachine - -- lavorazione di sega a catena e relativi dati - local Chainsawing = {} - Chainsawing.ProcId = Proc.Id - Chainsawing.Name = ML.FindSawing( 'Sawing') - if not Chainsawing.Name then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' - return false, sErr - end - Chainsawing.Tool = SawPlusChain.GetToolFromMachining( Chainsawing.Name) - Chainsawing.FaceToMachine = Proc.Pocket.FaceToMachine - - -- verifica dimensioni tasca compatibili con utensili + -- verifica dimensioni tasca compatibili con lama -- se tasca meno spessa della lama la strategia non è applicabile if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' return false, sErr end - -- se tasca meno spessa della sega a catena la strategia non è applicabile - if not bOnlySaw and Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' - return false, sErr - end if Proc.Pocket.SideOpeningsCount == 0 then -- se tasca più stretta della lama la strategia non è applicabile if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' return false, sErr end - -- se tasca più stretta della sega a catena la strategia non è applicabile - if not bOnlySaw and Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' - return false, sErr - end end -- parametri della lavorazione con lama @@ -5004,6 +4986,7 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) end -- step verticale e offset longitudinale Cutting.Steps = SawPlusChain.GetVerticalSteps( Proc, Cutting) + Cutting.MaxElev = Cutting.Steps.StepLength * Cutting.Steps.Count - 10 * GEO.EPS_SMALL if Cutting.ToolInvert and Cutting.Steps.Count > 1 then Cutting.LongitudinalOffset = - Proc.Pocket.Height else @@ -5026,8 +5009,6 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) -- approccio e retrazione Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.GetLeadInOut( Proc, Cutting) - local bOk, sErr - -- lavorazione con lama -- eventuale step orizzontale if Cutting.Tool.SideStep then @@ -5036,14 +5017,42 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) Cutting.HorizontalSteps.Count = 1 Cutting.HorizontalSteps.StepLength = 0 end + local bIsCuttingOk, sErrorMessageCutting local dOriginalRadialOffsetCutting = Cutting.RadialOffset for i = Cutting.HorizontalSteps.Count, 1, -1 do Cutting.RadialOffset = dOriginalRadialOffsetCutting + Cutting.HorizontalSteps.StepLength * ( i - 1) - bOk, sErr = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) + bIsCuttingOk, sErrorMessageCutting = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) end - if bOnlySaw then - return bOk, sErr + if bOnlySaw or not bIsCuttingOk then + return bIsCuttingOk, sErrorMessageCutting + end + + -- lavorazione di sega a catena e relativi dati + local Chainsawing = {} + Chainsawing.ProcId = Proc.Id + Chainsawing.Name = ML.FindSawing( 'Sawing') + if not Chainsawing.Name then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' + return false, sErr + end + Chainsawing.Type = MCH_OY.MORTISING + Chainsawing.Tool = SawPlusChain.GetToolFromMachining( Chainsawing.Name) + Chainsawing.FaceToMachine = Proc.Pocket.FaceToMachine + + -- verifica dimensioni tasca compatibili con sega a catena + -- se tasca meno spessa della sega a catena la strategia non è applicabile + if not bOnlySaw and Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' + return false, sErr + end + + if Proc.Pocket.SideOpeningsCount == 0 then + -- se tasca più stretta della sega a catena la strategia non è applicabile + if not bOnlySaw and Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' + return false, sErr + end end -- parametri della lavorazione con sega a catena @@ -5063,11 +5072,14 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) else Chainsawing.Depth = Chainsawing.Tool.MaxMat Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth + -- QUI WARNING DEL MANCATO COMPLETAMENTO DELLA TASCA end -- offset radiale Chainsawing.RadialOffset = 0 + -- profondità da lavorare, ossia MaxElev. Si lavora solo quanto non lavorato dalla lama + Chainsawing.MaxElev = Cutting.RadialOffset + BD.CUT_EXTRA -- distanza di sicurezza - Chainsawing.StartSafetyLength = 10 + Chainsawing.StartSafetyLength = Proc.Pocket.Depth -- overlap Chainsawing.Overlap = 0 -- faceuse @@ -5085,12 +5097,13 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) -- lavorazione con sega a catena Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing) local dOriginalRadialOffsetChainsawing = Chainsawing.RadialOffset +local bIsChainsawingOk, sErrorMessageChainsawing for i = Chainsawing.VerticalSteps.Count, 1, -1 do Chainsawing.RadialOffset = dOriginalRadialOffsetChainsawing + Chainsawing.VerticalSteps.StepLength * ( i - 1) - bOk, sErr = SawPlusChain.ApplyMachining( Chainsawing, 'Chainsaw_', b3Raw) + bIsChainsawingOk, sErrorMessageChainsawing = SawPlusChain.ApplyMachining( Chainsawing, 'Chainsaw_', b3Raw) end - return bOk, sErr +return bIsChainsawingOk, sErrorMessageChainsawing end --#endregion SawPlusChain From 99c0ada098e85c47a088772ca66fe8657d76e6e8 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 2 Apr 2024 19:05:05 +0200 Subject: [PATCH 10/26] - in sawpluschain migliorata gestione errori chainsaw - in sawpluschain migliorato riconoscimento facce laterali --- LuaLibs/ProcessLapJoint.lua | 61 ++++++++++++++++++++++++++----------- 1 file changed, 43 insertions(+), 18 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 6f806c0..87c7b26 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4589,6 +4589,7 @@ end --#region SawPlusChain local SawPlusChain = {} + function SawPlusChain.IsTopologyOk( Proc) if Proc.TopologyLongName == 'Pocket-Blind-RightAngles-Parallel-5' or Proc.TopologyLongName == 'Groove-Through-RightAngles-Parallel-3' or @@ -4599,6 +4600,7 @@ function SawPlusChain.IsTopologyOk( Proc) end end + function SawPlusChain.GetBottomFace( Proc) -- la faccia di fondo ha sempre Fct - 1 adiacenze. Se si trovano più facce di fondo si sceglie quella con minor elevazione local vBottomFace = Topology.GetFacesWithGivenAdjacencyNumber( Proc, Proc.vAdj, Proc.Fct - 1) @@ -4632,6 +4634,7 @@ function SawPlusChain.GetBottomFace( Proc) return BottomFace end + function SawPlusChain.GetFaceToMachine( Proc) if not Proc.Pocket.BottomFace or not Proc.Pocket.BottomFace.Id then Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc) @@ -4667,10 +4670,14 @@ function SawPlusChain.GetFaceToMachine( Proc) return FaceToMachine end + function SawPlusChain.GetSideFaces( Proc) if not Proc.Pocket.BottomFace or not Proc.Pocket.BottomFace.Id then Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc) end + if not Proc.Pocket.FaceToMachine or not Proc.Pocket.FaceToMachine.Id then + Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc) + end -- si cercano le facce adiacenti a quella di fondo local FacesAdjacentToBottom = {} @@ -4683,11 +4690,13 @@ function SawPlusChain.GetSideFaces( Proc) end end - -- le facce laterali sono quelle che rimangono una volta escluse le due sopra e sotto, che sono le più lunghe + -- se non 4 facce, le facce laterali sono quelle che rimangono una volta escluse le due sopra e sotto, che sono le più lunghe + -- se 4 facce, le facce laterali sono le rimanenti esclusa quella da lavorare table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnBottom > b.LengthOnBottom end) local SideFaces = {} for i = 1, #FacesAdjacentToBottom do - if i > 2 then + if ( Proc.Fct ~= 4 and i > 2) or + ( Proc.Fct == 4 and ( FacesAdjacentToBottom[i].Id ~= Proc.Pocket.FaceToMachine.Id)) then table.insert( SideFaces, FacesAdjacentToBottom[i]) SideFaces[ #SideFaces].Id = FacesAdjacentToBottom[i].Id SideFaces[ #SideFaces].Width = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Width @@ -4703,6 +4712,7 @@ function SawPlusChain.GetSideFaces( Proc) return SideFaces end + function SawPlusChain.GetToolFromMachining( sMachiningName) local Tool = {} if EgtMdbSetCurrMachining( sMachiningName) then @@ -4734,6 +4744,7 @@ function SawPlusChain.GetToolFromMachining( sMachiningName) return Tool end + function SawPlusChain.GetSCC( vtMachiningDirection) local nSCC = MCH_SCC.NONE if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then @@ -4753,6 +4764,7 @@ function SawPlusChain.GetSCC( vtMachiningDirection) return nSCC end + function SawPlusChain.GetVerticalSteps( Proc, Machining) if not Proc.Pocket or not Proc.Pocket.Height then error( 'Missing pocket depth') @@ -4764,12 +4776,12 @@ function SawPlusChain.GetVerticalSteps( Proc, Machining) VerticalSteps.Count = ceil( ( Proc.Pocket.Height - 10 * GEO.EPS_SMALL) / Machining.Tool.Thickness) if VerticalSteps.Count > 1 then VerticalSteps.StepLength = ( Proc.Pocket.Height - Machining.Tool.Thickness) / ( VerticalSteps.Count - 1) - VerticalSteps.StepType = MCH_MILL_ST.ONEWAY end return VerticalSteps end + function SawPlusChain.GetHorizontalSteps( Machining) if not Machining.Depth then error( 'Missing machining depth') @@ -4784,6 +4796,7 @@ function SawPlusChain.GetHorizontalSteps( Machining) return HorizontalSteps end + function SawPlusChain.GetLeadInOut( Proc, Machining) -- si determina se l'inizio o la fine della lavorazione sono chiusi e l'eventuale riduzione da applicare local bIsStartClosed = false @@ -4850,11 +4863,13 @@ function SawPlusChain.GetLeadInOut( Proc, Machining) return LeadIn, LeadOut end + function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) + local sErr = '' local sOperationName = sOperationNamePrefix .. ( EgtGetName( Machining.ProcId) or tostring( Machining.ProcId)) .. '_' .. tostring( Machining.FaceToMachine.Id + 1) local nOperationId = EgtAddMachining( sOperationName, Machining.Name) if not nOperationId then - local sErr = 'Error adding machining ' .. sOperationName .. '-' .. Machining.Name + sErr = 'Error adding machining ' .. sOperationName .. '-' .. Machining.Name EgtOutLog( sErr) return false, sErr end @@ -4902,27 +4917,28 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) local bIsApplyOk = ML.ApplyMachining( true, false) if not bIsApplyOk then - local _, sErr = EgtGetLastMachMgrError() + sErr = EgtGetLastMachMgrError() EgtSetOperationMode( nOperationId, false) return false, sErr end - return true + return true, sErr end + function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) Proc.Pocket = {} Proc.Pocket.Strategy = 'SawPlusChain' if not SawPlusChain.IsTopologyOk( Proc) then - local sErr = 'Feature '.. Proc.FeatureId .. ' : Strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName return false, sErr end -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto if Proc.AffectedFaces.Bottom then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy not applicable - pocket on bottom face' + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face' return false, sErr end @@ -4940,7 +4956,7 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) Cutting.ProcId = Proc.Id Cutting.Name = ML.FindCutting( 'HeadSide', true, false) if not Cutting.Name then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' return false, sErr end Cutting.Type = MCH_OY.MILLING @@ -4950,13 +4966,13 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) -- verifica dimensioni tasca compatibili con lama -- se tasca meno spessa della lama la strategia non è applicabile if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' return false, sErr end if Proc.Pocket.SideOpeningsCount == 0 then -- se tasca più stretta della lama la strategia non è applicabile if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' return false, sErr end end @@ -4987,6 +5003,7 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) end -- step verticale e offset longitudinale Cutting.Steps = SawPlusChain.GetVerticalSteps( Proc, Cutting) + Cutting.Steps.StepType = MCH_MILL_ST.ONEWAY Cutting.MaxElev = Cutting.Steps.StepLength * Cutting.Steps.Count - 10 * GEO.EPS_SMALL if Cutting.ToolInvert and Cutting.Steps.Count > 1 then Cutting.LongitudinalOffset = - Proc.Pocket.Height @@ -5032,9 +5049,12 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) -- lavorazione di sega a catena e relativi dati local Chainsawing = {} Chainsawing.ProcId = Proc.Id - Chainsawing.Name = ML.FindSawing( 'Sawing') + Chainsawing.Name = ML.FindSawing( 'Sawing', Proc.Pocket.Depth) if not Chainsawing.Name then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' + Chainsawing.Name = ML.FindSawing( 'Sawing', nil, nil, 'Longest') + end + if not Chainsawing.Name then + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' return false, sErr end Chainsawing.Type = MCH_OY.MORTISING @@ -5044,18 +5064,20 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) -- verifica dimensioni tasca compatibili con sega a catena -- se tasca meno spessa della sega a catena la strategia non è applicabile if not bOnlySaw and Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' return false, sErr end if Proc.Pocket.SideOpeningsCount == 0 then -- se tasca più stretta della sega a catena la strategia non è applicabile if not bOnlySaw and Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ': Strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' return false, sErr end end + local sErrorMessageChainsawing = '' + -- parametri della lavorazione con sega a catena -- lato di lavoro e inversioni if Chainsawing.Tool.IsCCW then @@ -5073,7 +5095,7 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) else Chainsawing.Depth = Chainsawing.Tool.MaxMat Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth - -- QUI WARNING DEL MANCATO COMPLETAMENTO DELLA TASCA + sErrorMessageChainsawing = 'Feature '.. Proc.FeatureId .. ' : chainsawing elevation bigger than max tool depth' end -- offset radiale Chainsawing.RadialOffset = 0 @@ -5098,10 +5120,13 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) -- lavorazione con sega a catena Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing) local dOriginalRadialOffsetChainsawing = Chainsawing.RadialOffset -local bIsChainsawingOk, sErrorMessageChainsawing +local bIsChainsawingOk, sErrorMessageChainsawingApply for i = Chainsawing.VerticalSteps.Count, 1, -1 do Chainsawing.RadialOffset = dOriginalRadialOffsetChainsawing + Chainsawing.VerticalSteps.StepLength * ( i - 1) - bIsChainsawingOk, sErrorMessageChainsawing = SawPlusChain.ApplyMachining( Chainsawing, 'Chainsaw_', b3Raw) + bIsChainsawingOk, sErrorMessageChainsawingApply = SawPlusChain.ApplyMachining( Chainsawing, 'Chainsaw_', b3Raw) +end +if sErrorMessageChainsawingApply and #sErrorMessageChainsawingApply > 0 then + sErrorMessageChainsawing = sErrorMessageChainsawing .. '\n' .. 'Apply : ' .. sErrorMessageChainsawingApply end return bIsChainsawingOk, sErrorMessageChainsawing From 57d696e2fccb00c3d921b9ba8df9c94132179e25 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 3 Apr 2024 17:56:39 +0200 Subject: [PATCH 11/26] =?UTF-8?q?-=20in=20sawpluschain=20refactoring=20per?= =?UTF-8?q?=20migliorare=20leggibilit=C3=A0=20-=20in=20sawpluschain=20gest?= =?UTF-8?q?ita=20estensione=20start=20se=20tasca=20troppo=20stretta=20-=20?= =?UTF-8?q?in=20BeamLib=20aggiunta=20funzione=20GetAdjacentFaces?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LuaLibs/BeamLib.lua | 17 ++- LuaLibs/ProcessLapJoint.lua | 235 +++++++++++++++++++++--------------- 2 files changed, 152 insertions(+), 100 deletions(-) diff --git a/LuaLibs/BeamLib.lua b/LuaLibs/BeamLib.lua index f65dc8d..5293154 100644 --- a/LuaLibs/BeamLib.lua +++ b/LuaLibs/BeamLib.lua @@ -1169,4 +1169,19 @@ function BeamLib.IsFeatureCuttingEntireSection( b3Proc, dRawW, dRawH) end ------------------------------------------------------------------------------------------------------------- -return BeamLib +function BeamLib.GetAdjacentFaces( Proc, nFacet) + local AdjacentFaces = {} + local vFaceAdjacencies = EgtSurfTmFacetAdjacencies( Proc.Id, nFacet)[1] + for i = 1, #vFaceAdjacencies do + if vFaceAdjacencies[i] > -1 then + local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, nFacet, vFaceAdjacencies[i], GDB_ID.ROOT) + local dLen = dist( ptP1, ptP2) + table.insert( AdjacentFaces, { Id = vFaceAdjacencies[i], LengthOnMainFace = dLen}) + end + end + + return AdjacentFaces +end + +------------------------------------------------------------------------------------------------------------- +return BeamLib \ No newline at end of file diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 87c7b26..780d6b9 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4587,7 +4587,15 @@ end --------------------------------------------------------------------- --#region SawPlusChain + +-- 5 facce: la faccia di fondo è il fondo della tasca, la faccia da lavorare è grande, le facce laterali sono le due piccole +-- 4 facce con faccia di fondo piccola: la faccia da lavorare è grande (2 adj) e l'unica faccia laterale è piccola +-- 4 facce con faccia di fondo grande: la faccia da lavorare è piccola (3 adj) e le facce laterali sono le due piccole +-- 3 facce: la faccia di fondo è il fondo della tasca, la faccia da lavorare è grande, non ci sono facce laterali + local SawPlusChain = {} +SawPlusChain.Saw = {} +SawPlusChain.Chainsaw = {} function SawPlusChain.IsTopologyOk( Proc) @@ -4640,20 +4648,12 @@ function SawPlusChain.GetFaceToMachine( Proc) Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc) end - -- si cercano le facce adiacenti a quella di fondo - local FacesAdjacentToBottom = {} - local vBottomFaceAdjacencies = EgtSurfTmFacetAdjacencies( Proc.Id, Proc.Pocket.BottomFace.Id)[1] - for i = 1, #vBottomFaceAdjacencies do - if vBottomFaceAdjacencies[i] > -1 then - local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, Proc.Pocket.BottomFace.Id, vBottomFaceAdjacencies[i], GDB_ID.ROOT) - local dLen = dist( ptP1, ptP2) - table.insert( FacesAdjacentToBottom, { Id = vBottomFaceAdjacencies[i], LengthOnBottom = dLen}) - end - end + -- facce adiacenti a quella di fondo, ordinate + local FacesAdjacentToBottom = BL.GetAdjacentFaces( Proc, Proc.Pocket.BottomFace.Id) + table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnMainFace > b.LengthOnMainFace end) -- si sceglie la faccia adiacente sul lato più lungo local FaceToMachine = {} - table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnBottom > b.LengthOnBottom end) FaceToMachine.Id = FacesAdjacentToBottom[1].Id for i = 1, Proc.Fct do if FaceToMachine.Id == Proc.Face[i].Id then @@ -4679,24 +4679,18 @@ function SawPlusChain.GetSideFaces( Proc) Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc) end - -- si cercano le facce adiacenti a quella di fondo - local FacesAdjacentToBottom = {} - local vBottomFaceAdjacencies = EgtSurfTmFacetAdjacencies( Proc.Id, Proc.Pocket.BottomFace.Id)[1] - for i = 1, #vBottomFaceAdjacencies do - if vBottomFaceAdjacencies[i] > -1 then - local _, ptP1, ptP2 = EgtSurfTmFacetsContact( Proc.Id, Proc.Pocket.BottomFace.Id, vBottomFaceAdjacencies[i], GDB_ID.ROOT) - local dLen = dist( ptP1, ptP2) - table.insert( FacesAdjacentToBottom, { Id = vBottomFaceAdjacencies[i], LengthOnBottom = dLen}) - end - end + -- facce adiacenti a quella di fondo, ordinate + local FacesAdjacentToBottom = BL.GetAdjacentFaces( Proc, Proc.Pocket.BottomFace.Id) + table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnMainFace > b.LengthOnMainFace end) + + -- si determina il criterio di scelta delle facce laterali + local FacesAdjacentToFaceToMachine = BL.GetAdjacentFaces( Proc, Proc.Pocket.FaceToMachine.Id) + local bIsFaceToMachineTheLargest = not ( Proc.Fct == 4 and #FacesAdjacentToFaceToMachine == 3) - -- se non 4 facce, le facce laterali sono quelle che rimangono una volta escluse le due sopra e sotto, che sono le più lunghe - -- se 4 facce, le facce laterali sono le rimanenti esclusa quella da lavorare - table.sort( FacesAdjacentToBottom, function( a, b) return a.LengthOnBottom > b.LengthOnBottom end) local SideFaces = {} for i = 1, #FacesAdjacentToBottom do - if ( Proc.Fct ~= 4 and i > 2) or - ( Proc.Fct == 4 and ( FacesAdjacentToBottom[i].Id ~= Proc.Pocket.FaceToMachine.Id)) then + if ( not bIsFaceToMachineTheLargest and i < #FacesAdjacentToBottom) or + ( bIsFaceToMachineTheLargest and i > 2) then table.insert( SideFaces, FacesAdjacentToBottom[i]) SideFaces[ #SideFaces].Id = FacesAdjacentToBottom[i].Id SideFaces[ #SideFaces].Width = Proc.Face[FacesAdjacentToBottom[i].Id + 1].Width @@ -4847,11 +4841,19 @@ function SawPlusChain.GetLeadInOut( Proc, Machining) LeadIn.CompLength = 0 LeadOut.CompLength = 0 if bIsStartClosed then + LeadIn.StartAddLength = -dAddLengthToReduce LeadIn.PerpDistance = 1 end if bIsEndClosed then + LeadOut.EndAddLength = -dAddLengthToReduce LeadOut.PerpDistance = 1 end + if abs( LeadIn.StartAddLength) > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + LeadOut.EndAddLength = -LeadIn.StartAddLength - Proc.Pocket.Width + 1 + end + if abs( LeadOut.EndAddLength) > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + LeadIn.StartAddLength = -LeadOut.EndAddLength - Proc.Pocket.Width + 1 + end end if bIsStartClosed then LeadIn.StartAddLength = -dAddLengthToReduce @@ -4926,58 +4928,40 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) end -function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) - Proc.Pocket = {} - Proc.Pocket.Strategy = 'SawPlusChain' - - if not SawPlusChain.IsTopologyOk( Proc) then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName - return false, sErr - end - - -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) - -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto - if Proc.AffectedFaces.Bottom then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face' - return false, sErr - end - - -- caratteristiche della tasca - Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc) - Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc) - Proc.Pocket.SideFaces = SawPlusChain.GetSideFaces( Proc) - Proc.Pocket.Width = Proc.Pocket.BottomFace.Width - Proc.Pocket.Height = Proc.Pocket.BottomFace.Height - Proc.Pocket.Depth = Proc.Pocket.BottomFace.Elevation - Proc.Pocket.Direction = Proc.Pocket.BottomFace.VtN - - -- lavorazione di lama e relativi dati +function SawPlusChain.Saw.CalculateMachiningParameters( Proc) local Cutting = {} + Cutting.CanApply = true + Cutting.Message = '' Cutting.ProcId = Proc.Id + + -- ricerca lavorazione Cutting.Name = ML.FindCutting( 'HeadSide', true, false) if not Cutting.Name then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' - return false, sErr + Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' + Cutting.CanApply = false + return Cutting end Cutting.Type = MCH_OY.MILLING Cutting.Tool = SawPlusChain.GetToolFromMachining( Cutting.Name) Cutting.FaceToMachine = Proc.Pocket.FaceToMachine - -- verifica dimensioni tasca compatibili con lama + -- verifica dimensioni tasca compatibili -- se tasca meno spessa della lama la strategia non è applicabile if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' - return false, sErr + Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' + Cutting.CanApply = false + return Cutting end if Proc.Pocket.SideOpeningsCount == 0 then -- se tasca più stretta della lama la strategia non è applicabile if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' - return false, sErr + Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' + Cutting.CanApply = false + return Cutting end end - -- parametri della lavorazione con lama + -- parametri della lavorazione -- lato di lavoro e inversioni if Cutting.Tool.IsCCW then Cutting.Workside = MCH_MILL_WS.RIGHT @@ -5026,8 +5010,6 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) Cutting.BlockedAxis.VtOut = EgtIf( Cutting.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX()) -- approccio e retrazione Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.GetLeadInOut( Proc, Cutting) - - -- lavorazione con lama -- eventuale step orizzontale if Cutting.Tool.SideStep then Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Cutting) @@ -5035,49 +5017,47 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) Cutting.HorizontalSteps.Count = 1 Cutting.HorizontalSteps.StepLength = 0 end - local bIsCuttingOk, sErrorMessageCutting - local dOriginalRadialOffsetCutting = Cutting.RadialOffset - for i = Cutting.HorizontalSteps.Count, 1, -1 do - Cutting.RadialOffset = dOriginalRadialOffsetCutting + Cutting.HorizontalSteps.StepLength * ( i - 1) - bIsCuttingOk, sErrorMessageCutting = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) - end - if bOnlySaw or not bIsCuttingOk then - return bIsCuttingOk, sErrorMessageCutting - end - - -- lavorazione di sega a catena e relativi dati + return Cutting +end + + +function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) local Chainsawing = {} + Chainsawing.CanApply = true + Chainsawing.Message = '' Chainsawing.ProcId = Proc.Id + + -- ricerca lavorazione Chainsawing.Name = ML.FindSawing( 'Sawing', Proc.Pocket.Depth) if not Chainsawing.Name then Chainsawing.Name = ML.FindSawing( 'Sawing', nil, nil, 'Longest') end if not Chainsawing.Name then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' - return false, sErr + Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' + Chainsawing.CanApply = false + return Chainsawing end Chainsawing.Type = MCH_OY.MORTISING Chainsawing.Tool = SawPlusChain.GetToolFromMachining( Chainsawing.Name) Chainsawing.FaceToMachine = Proc.Pocket.FaceToMachine - -- verifica dimensioni tasca compatibili con sega a catena + -- verifica dimensioni tasca compatibili -- se tasca meno spessa della sega a catena la strategia non è applicabile - if not bOnlySaw and Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' - return false, sErr + if Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then + Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' + Chainsawing.CanApply = false + return Chainsawing end - if Proc.Pocket.SideOpeningsCount == 0 then -- se tasca più stretta della sega a catena la strategia non è applicabile - if not bOnlySaw and Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' - return false, sErr + if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' + Chainsawing.CanApply = false + return Chainsawing end end - local sErrorMessageChainsawing = '' - -- parametri della lavorazione con sega a catena -- lato di lavoro e inversioni if Chainsawing.Tool.IsCCW then @@ -5095,12 +5075,10 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) else Chainsawing.Depth = Chainsawing.Tool.MaxMat Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth - sErrorMessageChainsawing = 'Feature '.. Proc.FeatureId .. ' : chainsawing elevation bigger than max tool depth' + Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : chainsawing elevation bigger than max tool depth' end -- offset radiale Chainsawing.RadialOffset = 0 - -- profondità da lavorare, ossia MaxElev. Si lavora solo quanto non lavorato dalla lama - Chainsawing.MaxElev = Cutting.RadialOffset + BD.CUT_EXTRA -- distanza di sicurezza Chainsawing.StartSafetyLength = Proc.Pocket.Depth -- overlap @@ -5116,20 +5094,79 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) Chainsawing.BlockedAxis.Orientation = 'perpendicular' -- approccio e retrazione Chainsawing.LeadIn, Chainsawing.LeadOut = SawPlusChain.GetLeadInOut( Proc, Chainsawing) + -- eventuale step verticale + Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing) --- lavorazione con sega a catena -Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing) -local dOriginalRadialOffsetChainsawing = Chainsawing.RadialOffset -local bIsChainsawingOk, sErrorMessageChainsawingApply -for i = Chainsawing.VerticalSteps.Count, 1, -1 do - Chainsawing.RadialOffset = dOriginalRadialOffsetChainsawing + Chainsawing.VerticalSteps.StepLength * ( i - 1) - bIsChainsawingOk, sErrorMessageChainsawingApply = SawPlusChain.ApplyMachining( Chainsawing, 'Chainsaw_', b3Raw) -end -if sErrorMessageChainsawingApply and #sErrorMessageChainsawingApply > 0 then - sErrorMessageChainsawing = sErrorMessageChainsawing .. '\n' .. 'Apply : ' .. sErrorMessageChainsawingApply + return Chainsawing end -return bIsChainsawingOk, sErrorMessageChainsawing + +function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) + Proc.Pocket = {} + Proc.Pocket.Strategy = 'SawPlusChain' + + if not SawPlusChain.IsTopologyOk( Proc) then + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName + return false, sErr + end + + -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) + -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto + if Proc.AffectedFaces.Bottom then + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face' + return false, sErr + end + + -- caratteristiche della tasca + Proc.Pocket.BottomFace = SawPlusChain.GetBottomFace( Proc) + Proc.Pocket.FaceToMachine = SawPlusChain.GetFaceToMachine( Proc) + Proc.Pocket.SideFaces = SawPlusChain.GetSideFaces( Proc) + Proc.Pocket.Width = Proc.Pocket.BottomFace.Width + Proc.Pocket.Height = Proc.Pocket.BottomFace.Height + Proc.Pocket.Depth = Proc.Pocket.BottomFace.Elevation + Proc.Pocket.Direction = Proc.Pocket.BottomFace.VtN + + -- parametri lavorazione di lama + local Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc) + + -- applicazione lavorazione di lama + local bIsCuttingOk = false + local sCuttingApplyMessage = '' + if Cutting.CanApply then + local dOriginalRadialOffset = Cutting.RadialOffset + for i = Cutting.HorizontalSteps.Count, 1, -1 do + Cutting.RadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.StepLength * ( i - 1) + bIsCuttingOk, sCuttingApplyMessage = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) + if sCuttingApplyMessage and #sCuttingApplyMessage > 0 then + Cutting.Message = Cutting.Message .. '\n' .. 'Apply : ' .. sCuttingApplyMessage + end + end + end + + if bOnlySaw or not bIsCuttingOk then + return bIsCuttingOk, Cutting.Message + end + + -- parametri lavorazione con sega a catena + local Chainsawing = SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) + -- si lavora solo quanto non lavorato dalla lama + Chainsawing.MaxElev = Cutting.RadialOffset + BD.CUT_EXTRA + + -- applicazione lavorazione con sega a catena + local bIsChainsawingOk = false + local sChainsawingApplyMessage = '' + if Chainsawing.CanApply then + local dOriginalRadialOffsetChainsawing = Chainsawing.RadialOffset + for i = Chainsawing.VerticalSteps.Count, 1, -1 do + Chainsawing.RadialOffset = dOriginalRadialOffsetChainsawing + Chainsawing.VerticalSteps.StepLength * ( i - 1) + bIsChainsawingOk, sChainsawingApplyMessage = SawPlusChain.ApplyMachining( Chainsawing, 'Chainsaw_', b3Raw) + if sChainsawingApplyMessage and #sChainsawingApplyMessage > 0 then + Chainsawing.Message = Chainsawing.Message .. '\n' .. 'Apply : ' .. sChainsawingApplyMessage + end + end + end + + return bIsChainsawingOk, Chainsawing.Message end --#endregion SawPlusChain From 5f1aaac719e16ed9b0222beb29f4fb78849e7f6e Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 4 Apr 2024 08:48:13 +0200 Subject: [PATCH 12/26] - in sawpluschain migliorati approccio e retrazione lama --- LuaLibs/ProcessLapJoint.lua | 55 ++++++++++++++++++++++--------------- 1 file changed, 33 insertions(+), 22 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 780d6b9..7bb7b0b 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4791,11 +4791,12 @@ function SawPlusChain.GetHorizontalSteps( Machining) end -function SawPlusChain.GetLeadInOut( Proc, Machining) +function SawPlusChain.CalculateLeadInOut( Proc, Machining) -- si determina se l'inizio o la fine della lavorazione sono chiusi e l'eventuale riduzione da applicare local bIsStartClosed = false local bIsEndClosed = false local bIsMortising = ( Machining.Type == MCH_OY.MORTISING) + local dExtraPerpDistance = EgtMdbGetGeneralParam( MCH_GP.SAFEZ) local dAddLengthToReduce = 0 if bIsMortising then dAddLengthToReduce = Machining.Tool.Diameter / 2 @@ -4834,32 +4835,33 @@ function SawPlusChain.GetLeadInOut( Proc, Machining) LeadOut.Type = MCH_MILL_LI.LINEAR LeadIn.TangentDistance = 0 LeadOut.TangentDistance = 0 - LeadIn.PerpDistance = 0 - LeadOut.PerpDistance = 0 + LeadIn.PerpDistance = Machining.Depth + dExtraPerpDistance - Machining.RadialOffset + BD.CUT_EXTRA + LeadOut.PerpDistance = Machining.Depth + dExtraPerpDistance - Machining.RadialOffset + BD.CUT_EXTRA LeadIn.Elevation = 0 LeadOut.Elevation = 0 LeadIn.CompLength = 0 LeadOut.CompLength = 0 + if bIsStartClosed and bIsEndClosed then + LeadIn.StartAddLength = -dAddLengthToReduce + LeadOut.EndAddLength = -dAddLengthToReduce + elseif bIsStartClosed then + LeadIn.StartAddLength = -dAddLengthToReduce + LeadOut.EndAddLength = BD.CUT_EXTRA + max( -LeadIn.StartAddLength - Proc.Pocket.Width, 0) + elseif bIsEndClosed then + LeadOut.EndAddLength = -dAddLengthToReduce + LeadIn.StartAddLength = BD.CUT_EXTRA + max( -LeadOut.EndAddLength - Proc.Pocket.Width, 0) + end + else if bIsStartClosed then LeadIn.StartAddLength = -dAddLengthToReduce - LeadIn.PerpDistance = 1 + else + LeadIn.StartAddLength = BD.CUT_EXTRA end if bIsEndClosed then LeadOut.EndAddLength = -dAddLengthToReduce - LeadOut.PerpDistance = 1 + else + LeadOut.EndAddLength = BD.CUT_EXTRA end - if abs( LeadIn.StartAddLength) > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - LeadOut.EndAddLength = -LeadIn.StartAddLength - Proc.Pocket.Width + 1 - end - if abs( LeadOut.EndAddLength) > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - LeadIn.StartAddLength = -LeadOut.EndAddLength - Proc.Pocket.Width + 1 - end - end - if bIsStartClosed then - LeadIn.StartAddLength = -dAddLengthToReduce - end - if bIsEndClosed then - LeadOut.EndAddLength = -dAddLengthToReduce end return LeadIn, LeadOut @@ -5009,7 +5011,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) Cutting.BlockedAxis.Orientation = 'perpendicular' Cutting.BlockedAxis.VtOut = EgtIf( Cutting.FaceToMachine.VtN:getX() > 0, X_AX(), -X_AX()) -- approccio e retrazione - Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.GetLeadInOut( Proc, Cutting) + Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.CalculateLeadInOut( Proc, Cutting) -- eventuale step orizzontale if Cutting.Tool.SideStep then Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Cutting) @@ -5058,7 +5060,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) end end - -- parametri della lavorazione con sega a catena + -- parametri della lavorazione -- lato di lavoro e inversioni if Chainsawing.Tool.IsCCW then Chainsawing.Workside = MCH_MILL_WS.RIGHT @@ -5093,7 +5095,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) Chainsawing.BlockedAxis = {} Chainsawing.BlockedAxis.Orientation = 'perpendicular' -- approccio e retrazione - Chainsawing.LeadIn, Chainsawing.LeadOut = SawPlusChain.GetLeadInOut( Proc, Chainsawing) + Chainsawing.LeadIn, Chainsawing.LeadOut = SawPlusChain.CalculateLeadInOut( Proc, Chainsawing) -- eventuale step verticale Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing) @@ -5129,14 +5131,21 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) -- parametri lavorazione di lama local Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc) - -- applicazione lavorazione di lama + -- applicazione lavorazione di lama con eventuali step XY local bIsCuttingOk = false local sCuttingApplyMessage = '' if Cutting.CanApply then local dOriginalRadialOffset = Cutting.RadialOffset + local dOriginalLeadInPerpDistance = Cutting.LeadIn.PerpDistance + local dOriginalLeadOutPerpDistance = Cutting.LeadOut.PerpDistance for i = Cutting.HorizontalSteps.Count, 1, -1 do Cutting.RadialOffset = dOriginalRadialOffset + Cutting.HorizontalSteps.StepLength * ( i - 1) + -- update distanza perpendicolare attacco per contemplare l'offset applicato + Cutting.LeadIn.PerpDistance = dOriginalLeadInPerpDistance - Cutting.RadialOffset + Cutting.LeadOut.PerpDistance = dOriginalLeadOutPerpDistance - Cutting.RadialOffset + -- applicazione lavorazione bIsCuttingOk, sCuttingApplyMessage = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) + -- update messaggi if sCuttingApplyMessage and #sCuttingApplyMessage > 0 then Cutting.Message = Cutting.Message .. '\n' .. 'Apply : ' .. sCuttingApplyMessage end @@ -5152,14 +5161,16 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) -- si lavora solo quanto non lavorato dalla lama Chainsawing.MaxElev = Cutting.RadialOffset + BD.CUT_EXTRA - -- applicazione lavorazione con sega a catena + -- applicazione lavorazione con sega a catena con eventuali step in Z local bIsChainsawingOk = false local sChainsawingApplyMessage = '' if Chainsawing.CanApply then local dOriginalRadialOffsetChainsawing = Chainsawing.RadialOffset for i = Chainsawing.VerticalSteps.Count, 1, -1 do Chainsawing.RadialOffset = dOriginalRadialOffsetChainsawing + Chainsawing.VerticalSteps.StepLength * ( i - 1) + -- applicazione lavorazione bIsChainsawingOk, sChainsawingApplyMessage = SawPlusChain.ApplyMachining( Chainsawing, 'Chainsaw_', b3Raw) + -- update messaggi if sChainsawingApplyMessage and #sChainsawingApplyMessage > 0 then Chainsawing.Message = Chainsawing.Message .. '\n' .. 'Apply : ' .. sChainsawingApplyMessage end From b5094daa437eb4863fba111476e1daed7739cf96 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 4 Apr 2024 10:14:16 +0200 Subject: [PATCH 13/26] - in sawpluschain correzione a attacchi --- LuaLibs/ProcessLapJoint.lua | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 7bb7b0b..363bf93 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4792,11 +4792,12 @@ end function SawPlusChain.CalculateLeadInOut( Proc, Machining) + -- TODO qui saranno da implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom) + -- si determina se l'inizio o la fine della lavorazione sono chiusi e l'eventuale riduzione da applicare local bIsStartClosed = false local bIsEndClosed = false local bIsMortising = ( Machining.Type == MCH_OY.MORTISING) - local dExtraPerpDistance = EgtMdbGetGeneralParam( MCH_GP.SAFEZ) local dAddLengthToReduce = 0 if bIsMortising then dAddLengthToReduce = Machining.Tool.Diameter / 2 @@ -4835,8 +4836,8 @@ function SawPlusChain.CalculateLeadInOut( Proc, Machining) LeadOut.Type = MCH_MILL_LI.LINEAR LeadIn.TangentDistance = 0 LeadOut.TangentDistance = 0 - LeadIn.PerpDistance = Machining.Depth + dExtraPerpDistance - Machining.RadialOffset + BD.CUT_EXTRA - LeadOut.PerpDistance = Machining.Depth + dExtraPerpDistance - Machining.RadialOffset + BD.CUT_EXTRA + LeadIn.PerpDistance = Proc.Pocket.Depth + BD.CUT_SIC + LeadOut.PerpDistance = Proc.Pocket.Depth + BD.CUT_SIC LeadIn.Elevation = 0 LeadOut.Elevation = 0 LeadIn.CompLength = 0 @@ -4846,10 +4847,15 @@ function SawPlusChain.CalculateLeadInOut( Proc, Machining) LeadOut.EndAddLength = -dAddLengthToReduce elseif bIsStartClosed then LeadIn.StartAddLength = -dAddLengthToReduce + -- eventuale correzione per accorciamento maggiore di larghezza tasca LeadOut.EndAddLength = BD.CUT_EXTRA + max( -LeadIn.StartAddLength - Proc.Pocket.Width, 0) elseif bIsEndClosed then LeadOut.EndAddLength = -dAddLengthToReduce + -- eventuale correzione per accorciamento maggiore di larghezza tasca LeadIn.StartAddLength = BD.CUT_EXTRA + max( -LeadOut.EndAddLength - Proc.Pocket.Width, 0) + else + LeadIn.StartAddLength = BD.CUT_EXTRA + LeadOut.EndAddLength = BD.CUT_EXTRA end else if bIsStartClosed then From e03896cfeffd55d40950a0635084b5d168ee8101 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 4 Apr 2024 12:40:59 +0200 Subject: [PATCH 14/26] in sawpluschain ulteriori correzioni al calcolo approccio e retrazione --- LuaLibs/ProcessLapJoint.lua | 46 ++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 363bf93..1e3e491 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4739,26 +4739,6 @@ function SawPlusChain.GetToolFromMachining( sMachiningName) end -function SawPlusChain.GetSCC( vtMachiningDirection) - local nSCC = MCH_SCC.NONE - if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then - nSCC = MCH_SCC.ADIR_ZP - elseif AreOppositeVectorApprox( vtMachiningDirection, Z_AX()) then - nSCC = MCH_SCC.ADIR_ZM - elseif AreSameVectorApprox( vtMachiningDirection, Y_AX()) then - nSCC = MCH_SCC.ADIR_YP - elseif AreOppositeVectorApprox( vtMachiningDirection, Y_AX()) then - nSCC = MCH_SCC.ADIR_YM - elseif AreSameVectorApprox( vtMachiningDirection, X_AX()) then - nSCC = MCH_SCC.ADIR_XP - elseif AreOppositeVectorApprox( vtMachiningDirection, X_AX()) then - nSCC = MCH_SCC.ADIR_XM - end - - return nSCC -end - - function SawPlusChain.GetVerticalSteps( Proc, Machining) if not Proc.Pocket or not Proc.Pocket.Height then error( 'Missing pocket depth') @@ -4848,11 +4828,11 @@ function SawPlusChain.CalculateLeadInOut( Proc, Machining) elseif bIsStartClosed then LeadIn.StartAddLength = -dAddLengthToReduce -- eventuale correzione per accorciamento maggiore di larghezza tasca - LeadOut.EndAddLength = BD.CUT_EXTRA + max( -LeadIn.StartAddLength - Proc.Pocket.Width, 0) + LeadOut.EndAddLength = max( -LeadIn.StartAddLength - Proc.Pocket.Width + 10 * BD.CUT_EXTRA, BD.CUT_EXTRA) elseif bIsEndClosed then LeadOut.EndAddLength = -dAddLengthToReduce -- eventuale correzione per accorciamento maggiore di larghezza tasca - LeadIn.StartAddLength = BD.CUT_EXTRA + max( -LeadOut.EndAddLength - Proc.Pocket.Width, 0) + LeadIn.StartAddLength = max( -LeadOut.EndAddLength - Proc.Pocket.Width + 10 * BD.CUT_EXTRA, BD.CUT_EXTRA) else LeadIn.StartAddLength = BD.CUT_EXTRA LeadOut.EndAddLength = BD.CUT_EXTRA @@ -4936,6 +4916,26 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) end +function SawPlusChain.Saw.GetSCC( vtMachiningDirection) + local nSCC = MCH_SCC.NONE + if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then + nSCC = MCH_SCC.ADIR_ZP + elseif AreOppositeVectorApprox( vtMachiningDirection, Z_AX()) then + nSCC = MCH_SCC.ADIR_ZM + elseif AreSameVectorApprox( vtMachiningDirection, Y_AX()) then + nSCC = MCH_SCC.ADIR_YP + elseif AreOppositeVectorApprox( vtMachiningDirection, Y_AX()) then + nSCC = MCH_SCC.ADIR_YM + elseif AreSameVectorApprox( vtMachiningDirection, X_AX()) then + nSCC = MCH_SCC.ADIR_XP + elseif AreOppositeVectorApprox( vtMachiningDirection, X_AX()) then + nSCC = MCH_SCC.ADIR_XM + end + + return nSCC +end + + function SawPlusChain.Saw.CalculateMachiningParameters( Proc) local Cutting = {} Cutting.CanApply = true @@ -5009,7 +5009,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- faceuse Cutting.Faceuse = BL.GetNearestOrthoOpposite( Proc.Pocket.Direction) -- SCC - Cutting.SCC = SawPlusChain.GetSCC( Proc.Pocket.Direction) + Cutting.SCC = SawPlusChain.Saw.GetSCC( Proc.Pocket.Direction) -- angoli suggeriti Cutting.SuggestedAngles = '' -- asse bloccato From 7676693f663c5b8e1e324b34f2ce398c7d7eaaa4 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 4 Apr 2024 12:49:19 +0200 Subject: [PATCH 15/26] in sawpluschain correzione tabella non definita --- LuaLibs/ProcessLapJoint.lua | 1 + 1 file changed, 1 insertion(+) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 1e3e491..fed5992 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -5019,6 +5019,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- approccio e retrazione Cutting.LeadIn, Cutting.LeadOut = SawPlusChain.CalculateLeadInOut( Proc, Cutting) -- eventuale step orizzontale + Cutting.HorizontalSteps = {} if Cutting.Tool.SideStep then Cutting.HorizontalSteps = SawPlusChain.GetHorizontalSteps( Cutting) else From a95080797923311da641021119db9ca344c4b14e Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Fri, 5 Apr 2024 19:17:17 +0200 Subject: [PATCH 16/26] - in SawPlusChain aggiunto messaggio danneggiamento pezzo successivo --- LuaLibs/ProcessLapJoint.lua | 49 ++++++++++++++++++++++++++++++++++--- 1 file changed, 45 insertions(+), 4 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index fed5992..d83bc94 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4593,6 +4593,8 @@ end -- 4 facce con faccia di fondo grande: la faccia da lavorare è piccola (3 adj) e le facce laterali sono le due piccole -- 3 facce: la faccia di fondo è il fondo della tasca, la faccia da lavorare è grande, non ci sono facce laterali +-- TODO: gestione messaggi in funzione apposita ( almeno per append) + local SawPlusChain = {} SawPlusChain.Saw = {} SawPlusChain.Chainsaw = {} @@ -4947,6 +4949,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) if not Cutting.Name then Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' Cutting.CanApply = false + EgtOutLog( Cutting.Message) return Cutting end Cutting.Type = MCH_OY.MILLING @@ -4958,6 +4961,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' Cutting.CanApply = false + EgtOutLog( Cutting.Message) return Cutting end if Proc.Pocket.SideOpeningsCount == 0 then @@ -4965,6 +4969,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' Cutting.CanApply = false + EgtOutLog( Cutting.Message) return Cutting end end @@ -5027,6 +5032,18 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) Cutting.HorizontalSteps.StepLength = 0 end + -- eventuale avviso di danneggiamento pezzo successivo + local dOffsideLength = max( Cutting.LeadIn.StartAddLength, Cutting.LeadOut.EndAddLength) + Cutting.Tool.Diameter / 2 + 10 * GEO.EPS_SMALL + if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then + local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : sawblade can damage next piece.' + if #Cutting.Message > 0 then + Cutting.Message = Cutting.Message .. '\n' .. sDamageNextPieceMessage + else + Cutting.Message = sDamageNextPieceMessage + end + EgtOutLog( sDamageNextPieceMessage) + end + return Cutting end @@ -5106,13 +5123,26 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) -- eventuale step verticale Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing) + -- eventuale avviso di danneggiamento pezzo successivo + local dOffsideLength = max( Chainsawing.LeadIn.StartAddLength, Chainsawing.LeadOut.EndAddLength) + Chainsawing.Tool.Width / 2 + 10 * GEO.EPS_SMALL + if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then + local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : chainsaw can damage next piece.' + if #Chainsawing.Message > 0 then + Chainsawing.Message = Chainsawing.Message .. '\n' .. sDamageNextPieceMessage + else + Chainsawing.Message = sDamageNextPieceMessage + end + EgtOutLog( sDamageNextPieceMessage) + end + return Chainsawing end -function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) +function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) Proc.Pocket = {} Proc.Pocket.Strategy = 'SawPlusChain' + local b3Raw = EgtGetRawPartBBox( nRawId) if not SawPlusChain.IsTopologyOk( Proc) then local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName @@ -5134,6 +5164,7 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) Proc.Pocket.Height = Proc.Pocket.BottomFace.Height Proc.Pocket.Depth = Proc.Pocket.BottomFace.Elevation Proc.Pocket.Direction = Proc.Pocket.BottomFace.VtN + Proc.Pocket.DistanceToNextPart = BL.GetDistanceToNextPart( nRawId, nPhase) -- parametri lavorazione di lama local Cutting = SawPlusChain.Saw.CalculateMachiningParameters( Proc) @@ -5154,11 +5185,16 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) bIsCuttingOk, sCuttingApplyMessage = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) -- update messaggi if sCuttingApplyMessage and #sCuttingApplyMessage > 0 then - Cutting.Message = Cutting.Message .. '\n' .. 'Apply : ' .. sCuttingApplyMessage + Cutting.Message = Cutting.Message .. 'Apply : ' .. sCuttingApplyMessage .. '\n' end end end + -- se tasca passante e la lama è arrivata sul fondo, non servono ulteriori lavorazioni + if #Proc.Pocket.SideFaces == 0 and Cutting.RadialOffset == 0 then + bOnlySaw = true + end + if bOnlySaw or not bIsCuttingOk then return bIsCuttingOk, Cutting.Message end @@ -5184,7 +5220,12 @@ function SawPlusChain.Make( Proc, b3Raw, bOnlySaw) end end - return bIsChainsawingOk, Chainsawing.Message + local sFinalMessage = '' + if #Cutting.Message > 0 or #Chainsawing.Message > 0 then + sFinalMessage = Cutting.Message .. '\n' .. Chainsawing.Message + end + + return bIsChainsawingOk, sFinalMessage end --#endregion SawPlusChain @@ -5221,7 +5262,7 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa local bOk local sErr local bOnlySaw = EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') == 1 - bOk, sErr = SawPlusChain.Make ( Proc, b3Raw, bOnlySaw) + bOk, sErr = SawPlusChain.Make ( Proc, nRawId, nPhase, bOnlySaw) return bOk, sErr end From 37026c548d1c6761ab402f52655240ac2c5372c1 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Mon, 8 Apr 2024 15:26:49 +0200 Subject: [PATCH 17/26] -in SawPlusChain migliorata gestione nome lavorazione - in SawPlusChain aggiunti angoli alternativi sega a catena - in SawPlusChain incluso caso 3 facce con fondo che non guarda verso il basso --- LuaLibs/ProcessLapJoint.lua | 65 +++++++++++++++++++++++++++---------- 1 file changed, 47 insertions(+), 18 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index d83bc94..1857a94 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4593,7 +4593,7 @@ end -- 4 facce con faccia di fondo grande: la faccia da lavorare è piccola (3 adj) e le facce laterali sono le due piccole -- 3 facce: la faccia di fondo è il fondo della tasca, la faccia da lavorare è grande, non ci sono facce laterali --- TODO: gestione messaggi in funzione apposita ( almeno per append) +-- TODO gestione messaggi in funzione apposita (almeno per append) local SawPlusChain = {} SawPlusChain.Saw = {} @@ -4856,12 +4856,11 @@ function SawPlusChain.CalculateLeadInOut( Proc, Machining) end -function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) +function SawPlusChain.ApplyMachining( Machining, b3Raw) local sErr = '' - local sOperationName = sOperationNamePrefix .. ( EgtGetName( Machining.ProcId) or tostring( Machining.ProcId)) .. '_' .. tostring( Machining.FaceToMachine.Id + 1) - local nOperationId = EgtAddMachining( sOperationName, Machining.Name) + local nOperationId = EgtAddMachining( Machining.OperationName, Machining.Name) if not nOperationId then - sErr = 'Error adding machining ' .. sOperationName .. '-' .. Machining.Name + sErr = 'Error adding machining ' .. Machining.OperationName .. '-' .. Machining.Name EgtOutLog( sErr) return false, sErr end @@ -4899,8 +4898,8 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) end end EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut)) + EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.FaceToMachine.VtN, Machining.Direction, Machining.SuggestedAngles.Index)) EgtSetMachiningParam( MCH_MP.OVERL, Machining.Overlap) - EgtSetMachiningParam( MCH_MP.INITANGS, Machining.SuggestedAngles) EgtSetMachiningParam( MCH_MP.STARTPOS, max( Machining.StartSafetyLength, EgtGetMachiningParam( MCH_MP.STARTPOS))) if Machining.MaxElev then sUserNotes = EgtSetValInNotes( sUserNotes, 'MaxElev', Machining.MaxElev) @@ -4909,9 +4908,31 @@ function SawPlusChain.ApplyMachining( Machining, sOperationNamePrefix, b3Raw) local bIsApplyOk = ML.ApplyMachining( true, false) if not bIsApplyOk then - sErr = EgtGetLastMachMgrError() - EgtSetOperationMode( nOperationId, false) - return false, sErr + local nErr + nErr, sErr = EgtGetLastMachMgrError() + -- se mortasatura e l'errore è compatibile (Axes values not calculable) si prova con l'altra configurazione dell'asse bloccato + -- TODO valutare se c'è modo di capire preventivamente la configurazione dell'asse bloccato e quindi rimuovere questa parte di codice + if Machining.Type == MCH_OY.MORTISING and nErr == 2507 then + if Machining.BlockedAxis.Orientation == 'perpendicular' then + Machining.BlockedAxis.Orientation = 'parallel' + else + Machining.BlockedAxis.Orientation = 'perpendicular' + end + EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut)) + if Machining.SuggestedAngles.Index == 1 then + Machining.SuggestedAngles.Index = 2 + else + Machining.SuggestedAngles.Index = 1 + end + EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.FaceToMachine.VtN, Machining.Direction, Machining.SuggestedAngles.Index)) + sErr = '' + bIsApplyOk = ML.ApplyMachining( true, false) + end + if not bIsApplyOk then + nErr, sErr = EgtGetLastMachMgrError() + EgtSetOperationMode( nOperationId, false) + return false, sErr + end end return true, sErr @@ -4975,6 +4996,8 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) end -- parametri della lavorazione + -- direzione utensile + Cutting.Direction = Proc.Pocket.Direction -- lato di lavoro e inversioni if Cutting.Tool.IsCCW then Cutting.Workside = MCH_MILL_WS.RIGHT @@ -5012,9 +5035,9 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- overlap Cutting.Overlap = 0 -- faceuse - Cutting.Faceuse = BL.GetNearestOrthoOpposite( Proc.Pocket.Direction) + Cutting.Faceuse = BL.GetNearestOrthoOpposite( Cutting.Direction) -- SCC - Cutting.SCC = SawPlusChain.Saw.GetSCC( Proc.Pocket.Direction) + Cutting.SCC = SawPlusChain.Saw.GetSCC( Cutting.Direction) -- angoli suggeriti Cutting.SuggestedAngles = '' -- asse bloccato @@ -5031,6 +5054,8 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) Cutting.HorizontalSteps.Count = 1 Cutting.HorizontalSteps.StepLength = 0 end + -- nome operazione + Cutting.OperationName = 'Cut_' .. ( EgtGetName( Cutting.ProcId) or tostring( Cutting.ProcId)) .. '_' .. tostring( Cutting.FaceToMachine.Id + 1) -- eventuale avviso di danneggiamento pezzo successivo local dOffsideLength = max( Cutting.LeadIn.StartAddLength, Cutting.LeadOut.EndAddLength) + Cutting.Tool.Diameter / 2 + 10 * GEO.EPS_SMALL @@ -5085,6 +5110,8 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) end -- parametri della lavorazione + -- direzione utensile + Chainsawing.Direction = Proc.Pocket.Direction -- lato di lavoro e inversioni if Chainsawing.Tool.IsCCW then Chainsawing.Workside = MCH_MILL_WS.RIGHT @@ -5110,18 +5137,20 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) -- overlap Chainsawing.Overlap = 0 -- faceuse - Chainsawing.Faceuse = BL.GetNearestParalOpposite( Proc.Pocket.Direction) + Chainsawing.Faceuse = BL.GetNearestParalOpposite( Chainsawing.Direction) -- SCC Chainsawing.SCC = MCH_SCC.NONE - -- angoli suggeriti - Chainsawing.SuggestedAngles = '' - -- asse bloccato + -- asse bloccato e angoli suggeriti Chainsawing.BlockedAxis = {} Chainsawing.BlockedAxis.Orientation = 'perpendicular' + Chainsawing.SuggestedAngles = {} + Chainsawing.SuggestedAngles.Index = 1 -- approccio e retrazione Chainsawing.LeadIn, Chainsawing.LeadOut = SawPlusChain.CalculateLeadInOut( Proc, Chainsawing) -- eventuale step verticale Chainsawing.VerticalSteps = SawPlusChain.GetVerticalSteps( Proc, Chainsawing) + -- nome operazione + Chainsawing.OperationName = 'Chainsaw_' .. ( EgtGetName( Chainsawing.ProcId) or tostring( Chainsawing.ProcId)) .. '_' .. tostring( Chainsawing.FaceToMachine.Id + 1) -- eventuale avviso di danneggiamento pezzo successivo local dOffsideLength = max( Chainsawing.LeadIn.StartAddLength, Chainsawing.LeadOut.EndAddLength) + Chainsawing.Tool.Width / 2 + 10 * GEO.EPS_SMALL @@ -5151,7 +5180,7 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto - if Proc.AffectedFaces.Bottom then + if Proc.AffectedFaces.Bottom and ( Proc.Fct > 3 or not Proc.AffectedFaces.Top) then local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face' return false, sErr end @@ -5182,7 +5211,7 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) Cutting.LeadIn.PerpDistance = dOriginalLeadInPerpDistance - Cutting.RadialOffset Cutting.LeadOut.PerpDistance = dOriginalLeadOutPerpDistance - Cutting.RadialOffset -- applicazione lavorazione - bIsCuttingOk, sCuttingApplyMessage = SawPlusChain.ApplyMachining( Cutting, 'Cut_', b3Raw) + bIsCuttingOk, sCuttingApplyMessage = SawPlusChain.ApplyMachining( Cutting, b3Raw) -- update messaggi if sCuttingApplyMessage and #sCuttingApplyMessage > 0 then Cutting.Message = Cutting.Message .. 'Apply : ' .. sCuttingApplyMessage .. '\n' @@ -5212,7 +5241,7 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) for i = Chainsawing.VerticalSteps.Count, 1, -1 do Chainsawing.RadialOffset = dOriginalRadialOffsetChainsawing + Chainsawing.VerticalSteps.StepLength * ( i - 1) -- applicazione lavorazione - bIsChainsawingOk, sChainsawingApplyMessage = SawPlusChain.ApplyMachining( Chainsawing, 'Chainsaw_', b3Raw) + bIsChainsawingOk, sChainsawingApplyMessage = SawPlusChain.ApplyMachining( Chainsawing, b3Raw) -- update messaggi if sChainsawingApplyMessage and #sChainsawingApplyMessage > 0 then Chainsawing.Message = Chainsawing.Message .. '\n' .. 'Apply : ' .. sChainsawingApplyMessage From c05e58a61e0cdee96b6426f20468a3ac56e11c1c Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 9 Apr 2024 09:59:00 +0200 Subject: [PATCH 18/26] =?UTF-8?q?-=20in=20SawPlusChain=20escluse=20le=20la?= =?UTF-8?q?pjoint=20lunghe=20-=20in=20SawPlusChain=20aggiunta=20scrittura?= =?UTF-8?q?=20log=20per=20tutti=20gli=20errori=20-=20propriet=C3=A0=20facc?= =?UTF-8?q?e=20della=20Proc=20ora=20lette=20tramite=20la=20funzione=20GetF?= =?UTF-8?q?acetsInfo=20in=20BeamLib?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LuaLibs/BeamExec.lua | 22 +--------------------- LuaLibs/BeamLib.lua | 28 ++++++++++++++++++++++++++++ LuaLibs/FeatureTopology.lua | 7 ++++++- LuaLibs/ProcessLapJoint.lua | 19 ++++++++++++++++--- 4 files changed, 51 insertions(+), 25 deletions(-) diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index 85bc4f5..fe8a440 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -344,33 +344,13 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT) end Proc.Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD) if b3Raw then - local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD) -- id della feature btl Proc.FeatureId = EgtGetInfo( Proc.Id, 'PRID', 's') -- recupero l'elenco delle facce della parte interessate dalla feature Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc) -- recupero informazioni sulle facce della feature if not Proc.Face then - Proc.Face = {} - for i = 1, Proc.Fct do - Proc.Face[i] = { Id = i - 1, VtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT )} - if Proc.Fct < 10 then - local frHV, dFaceWidthTrimmed, dFaceHeightTrimmed = BL.GetFaceHvRefDim( Proc.Id, i - 1, b3Raw) - -- frame OCS faccia - Proc.Face[i].FrameHV = frHV - -- larghezza OCS faccia trimmata con grezzo - Proc.Face[i].WidthTrimmed = dFaceWidthTrimmed - -- altezza OCS faccia trimmata con grezzo - Proc.Face[i].HeightTrimmed = dFaceHeightTrimmed - local _, dFaceWidth, dFaceHeight = BL.GetFaceHvRefDim( Proc.Id, i - 1) - -- larghezza OCS faccia - Proc.Face[i].Width = dFaceWidth - -- altezza OCS faccia - Proc.Face[i].Height = dFaceHeight - -- elevazione calcolata rispetto al box della parte - Proc.Face[i].Elevation = EgtSurfTmFacetElevationInBBox( Proc.Id, i - 1, b3Solid, true, GDB_ID.ROOT) - end - end + Proc.Face = BL.GetFacetsInfo( Proc, b3Raw) end end if Proc.Box and not Proc.Box:isEmpty() then diff --git a/LuaLibs/BeamLib.lua b/LuaLibs/BeamLib.lua index 5293154..7373bd9 100644 --- a/LuaLibs/BeamLib.lua +++ b/LuaLibs/BeamLib.lua @@ -1183,5 +1183,33 @@ function BeamLib.GetAdjacentFaces( Proc, nFacet) return AdjacentFaces end +------------------------------------------------------------------------------------------------------------- +function BeamLib.GetFacetsInfo( Proc, b3Raw) + Face = {} + local b3Solid = EgtGetBBoxGlob( EgtGetFirstNameInGroup( Proc.PartId, 'Box') or GDB_ID.NULL, GDB_BB.STANDARD) + + for i = 1, Proc.Fct do + Face[i] = { Id = i - 1, VtN = EgtSurfTmFacetNormVersor( Proc.Id, i - 1, GDB_ID.ROOT )} + if Proc.Fct < 10 then + local frHV, dFaceWidthTrimmed, dFaceHeightTrimmed = BeamLib.GetFaceHvRefDim( Proc.Id, i - 1, b3Raw) + -- frame OCS faccia + Face[i].FrameHV = frHV + -- larghezza OCS faccia trimmata con grezzo + Face[i].WidthTrimmed = dFaceWidthTrimmed + -- altezza OCS faccia trimmata con grezzo + Face[i].HeightTrimmed = dFaceHeightTrimmed + local _, dFaceWidth, dFaceHeight = BeamLib.GetFaceHvRefDim( Proc.Id, i - 1) + -- larghezza OCS faccia + Face[i].Width = dFaceWidth + -- altezza OCS faccia + Face[i].Height = dFaceHeight + -- elevazione calcolata rispetto al box della parte + Face[i].Elevation = EgtSurfTmFacetElevationInBBox( Proc.Id, i - 1, b3Solid, true, GDB_ID.ROOT) + end + end + + return Face +end + ------------------------------------------------------------------------------------------------------------- return BeamLib \ No newline at end of file diff --git a/LuaLibs/FeatureTopology.lua b/LuaLibs/FeatureTopology.lua index ef9e1cc..57d4067 100644 --- a/LuaLibs/FeatureTopology.lua +++ b/LuaLibs/FeatureTopology.lua @@ -180,7 +180,12 @@ function FeatureTopology.Classify( Proc, b3Raw) end -- calcoli - if not Proc.AffectedFaces then Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc) end + if not Proc.AffectedFaces then + Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc) + end + if not Proc.Face then + Proc.Face = BL.GetFacetsInfo( Proc, b3Raw) + end local vAdj = GetAdjacencyMatrix( Proc) local bAllAnglesConcave, bAllRightAngles = AreAllAnglesConcaveOrRight( vAdj) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 1857a94..15298f6 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -5087,6 +5087,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) if not Chainsawing.Name then Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' Chainsawing.CanApply = false + EgtOutLog( Chainsawing.Message) return Chainsawing end Chainsawing.Type = MCH_OY.MORTISING @@ -5098,6 +5099,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) if Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' Chainsawing.CanApply = false + EgtOutLog( Chainsawing.Message) return Chainsawing end if Proc.Pocket.SideOpeningsCount == 0 then @@ -5105,6 +5107,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' Chainsawing.CanApply = false + EgtOutLog( Chainsawing.Message) return Chainsawing end end @@ -5129,6 +5132,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) Chainsawing.Depth = Chainsawing.Tool.MaxMat Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : chainsawing elevation bigger than max tool depth' + EgtOutLog( Chainsawing.Message) end -- offset radiale Chainsawing.RadialOffset = 0 @@ -5175,6 +5179,14 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) if not SawPlusChain.IsTopologyOk( Proc) then local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName + EgtOutLog( sErr) + return false, sErr + end + + -- TODO per implementare la strategia con lapjoint lunghe bisogna prima riconoscere le topologie che arrivano + if Proc.IsSplittedLapJoint then + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for long lapjoint ' + EgtOutLog( sErr) return false, sErr end @@ -5182,6 +5194,7 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto if Proc.AffectedFaces.Bottom and ( Proc.Fct > 3 or not Proc.AffectedFaces.Top) then local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face' + EgtOutLog( sErr) return false, sErr end @@ -6481,12 +6494,12 @@ local function MakeLongMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) for i = 1, #vAddId do local b3Box = EgtGetBBoxGlob( vAddId[i], GDB_BB.STANDARD) local nFct = EgtSurfTmFacetCount( vAddId[i]) - local AddProc = { Id = vAddId[i], Grp = Proc.Grp, FeatureId = Proc.FeatureId, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId} + local AddProc = { Id = vAddId[i], Grp = Proc.Grp, FeatureId = Proc.FeatureId, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId, IsSplittedLapJoint = true} Topology.Classify( AddProc, b3Raw) -- lasciare il false nel sesto parametro (perchè internamente viene verificato se diverso da nil) - local bOk, sMyWarn + local bOk, sMyWarn bOk, sMyWarn, bPrevBhSideMill = MakeMoreFaces( AddProc, nPhase, nRawId, nPartId, dOvmHead, bAllWithEndCap, bPrevBhSideMill, bAllWithEndCap) - if not sWarn then sWarn = sMyWarn end + if not sWarn or #sWarn == 0 then sWarn = sMyWarn end if not bOk then return bOk, sWarn end end return true, sWarn From 969f4cb6a0ee6c080925a483b564d7808a3eaecb Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 9 Apr 2024 16:17:57 +0200 Subject: [PATCH 19/26] - in FeatureTopology modifiche alla definizione di parallelo per tunnel e groove - in SawPlusChain piccole correzioni --- LuaLibs/FeatureTopology.lua | 6 +++--- LuaLibs/ProcessLapJoint.lua | 16 +++++++++------- 2 files changed, 12 insertions(+), 10 deletions(-) diff --git a/LuaLibs/FeatureTopology.lua b/LuaLibs/FeatureTopology.lua index 57d4067..c77d6b8 100644 --- a/LuaLibs/FeatureTopology.lua +++ b/LuaLibs/FeatureTopology.lua @@ -113,11 +113,11 @@ end --------------------------------------------------------------------- -- restituisce un vettore contenente gli indici delle facce di Proc parallele ad una delle direzioni principali; il check varia in base alla famiglia topologica -local function GetFacesParallelToPart( Proc, sFamily, bIsThrough) +local function GetFacesParallelToPart( Proc, sFamily) local vFacesParallelToPart = {} for i = 0, Proc.Fct - 1 do local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i, GDB_ID.ROOT) - if sFamily == 'Rabbet' or sFamily == 'Bevel' or sFamily == 'DoubleBevel' or sFamily == 'Strip' or sFamily == 'Tunnel' or ( sFamily == 'Groove' and bIsThrough) then + if sFamily == 'Rabbet' or sFamily == 'Bevel' or sFamily == 'DoubleBevel' or sFamily == 'Strip' then local vTriangularFaces = GetTriangularFaces( Proc) local bIsTriangularFace = false -- verifico se la faccia è triangolare @@ -244,7 +244,7 @@ function FeatureTopology.Classify( Proc, b3Raw) end -- verifico se facce parallele a quelle della trave - local vFacesParallelToPart = GetFacesParallelToPart( Proc, sFamily, bIsThrough) + local vFacesParallelToPart = GetFacesParallelToPart( Proc, sFamily) local bIsParallel = ( #vFacesParallelToPart == Proc.Fct) -- assegnazioni diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 15298f6..c8a3ec3 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4595,6 +4595,8 @@ end -- TODO gestione messaggi in funzione apposita (almeno per append) +-- TODO gestire topologia tunnel (anche da due lati) + local SawPlusChain = {} SawPlusChain.Saw = {} SawPlusChain.Chainsaw = {} @@ -4985,7 +4987,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) EgtOutLog( Cutting.Message) return Cutting end - if Proc.Pocket.SideOpeningsCount == 0 then + if #( Proc.Pocket.SideFaces) > 0 then -- se tasca più stretta della lama la strategia non è applicabile if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' @@ -5102,7 +5104,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) EgtOutLog( Chainsawing.Message) return Chainsawing end - if Proc.Pocket.SideOpeningsCount == 0 then + if #( Proc.Pocket.SideFaces) == 0 then -- se tasca più stretta della sega a catena la strategia non è applicabile if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' @@ -5177,15 +5179,15 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) Proc.Pocket.Strategy = 'SawPlusChain' local b3Raw = EgtGetRawPartBBox( nRawId) - if not SawPlusChain.IsTopologyOk( Proc) then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName + -- TODO per implementare la strategia con lapjoint lunghe bisogna prima riconoscere le topologie che arrivano + if Proc.IsSplittedLapJoint then + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for long lapjoint ' EgtOutLog( sErr) return false, sErr end - -- TODO per implementare la strategia con lapjoint lunghe bisogna prima riconoscere le topologie che arrivano - if Proc.IsSplittedLapJoint then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for long lapjoint ' + if not SawPlusChain.IsTopologyOk( Proc) then + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName EgtOutLog( sErr) return false, sErr end From cc30f3aeb9f88c3f7f61b1dda98d9bd35aef17ab Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Tue, 9 Apr 2024 19:02:10 +0200 Subject: [PATCH 20/26] - chiamate a FeatureId (PRID) sostituite con TaskId - in SawPlusChain angoli iniziali gestiti solo per sega a catena --- LuaLibs/BeamExec.lua | 2 -- LuaLibs/ProcessLapJoint.lua | 30 ++++++++++++++++-------------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index fe8a440..99814a8 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -344,8 +344,6 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT) end Proc.Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD) if b3Raw then - -- id della feature btl - Proc.FeatureId = EgtGetInfo( Proc.Id, 'PRID', 's') -- recupero l'elenco delle facce della parte interessate dalla feature Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc) -- recupero informazioni sulle facce della feature diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index c8a3ec3..1fa7815 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4900,7 +4900,9 @@ function SawPlusChain.ApplyMachining( Machining, b3Raw) end end EgtSetMachiningParam( MCH_MP.BLOCKEDAXIS, BL.GetBlockedAxis( Machining.Name, Machining.BlockedAxis.Orientation, b3Raw, Machining.FaceToMachine.VtN, Machining.BlockedAxis.VtOut)) - EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.FaceToMachine.VtN, Machining.Direction, Machining.SuggestedAngles.Index)) + if Machining.Type == MCH_OY.MORTISING then + EgtSetMachiningParam( MCH_MP.INITANGS, BL.GetChainSawInitAngs( Machining.FaceToMachine.VtN, Machining.Direction, Machining.SuggestedAngles.Index)) + end EgtSetMachiningParam( MCH_MP.OVERL, Machining.Overlap) EgtSetMachiningParam( MCH_MP.STARTPOS, max( Machining.StartSafetyLength, EgtGetMachiningParam( MCH_MP.STARTPOS))) if Machining.MaxElev then @@ -4970,7 +4972,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- ricerca lavorazione Cutting.Name = ML.FindCutting( 'HeadSide', true, false) if not Cutting.Name then - Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' + Cutting.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' Cutting.CanApply = false EgtOutLog( Cutting.Message) return Cutting @@ -4982,7 +4984,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- verifica dimensioni tasca compatibili -- se tasca meno spessa della lama la strategia non è applicabile if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' + Cutting.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' Cutting.CanApply = false EgtOutLog( Cutting.Message) return Cutting @@ -4990,7 +4992,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) if #( Proc.Pocket.SideFaces) > 0 then -- se tasca più stretta della lama la strategia non è applicabile if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' + Cutting.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' Cutting.CanApply = false EgtOutLog( Cutting.Message) return Cutting @@ -5062,7 +5064,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- eventuale avviso di danneggiamento pezzo successivo local dOffsideLength = max( Cutting.LeadIn.StartAddLength, Cutting.LeadOut.EndAddLength) + Cutting.Tool.Diameter / 2 + 10 * GEO.EPS_SMALL if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then - local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : sawblade can damage next piece.' + local sDamageNextPieceMessage = 'Feature '.. Proc.TaskId .. ' : sawblade can damage next piece.' if #Cutting.Message > 0 then Cutting.Message = Cutting.Message .. '\n' .. sDamageNextPieceMessage else @@ -5087,7 +5089,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) Chainsawing.Name = ML.FindSawing( 'Sawing', nil, nil, 'Longest') end if not Chainsawing.Name then - Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' + Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' Chainsawing.CanApply = false EgtOutLog( Chainsawing.Message) return Chainsawing @@ -5099,7 +5101,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) -- verifica dimensioni tasca compatibili -- se tasca meno spessa della sega a catena la strategia non è applicabile if Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' + Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' Chainsawing.CanApply = false EgtOutLog( Chainsawing.Message) return Chainsawing @@ -5107,7 +5109,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) if #( Proc.Pocket.SideFaces) == 0 then -- se tasca più stretta della sega a catena la strategia non è applicabile if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' + Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' Chainsawing.CanApply = false EgtOutLog( Chainsawing.Message) return Chainsawing @@ -5133,7 +5135,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) else Chainsawing.Depth = Chainsawing.Tool.MaxMat Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth - Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : chainsawing elevation bigger than max tool depth' + Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : chainsawing elevation bigger than max tool depth' EgtOutLog( Chainsawing.Message) end -- offset radiale @@ -5161,7 +5163,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) -- eventuale avviso di danneggiamento pezzo successivo local dOffsideLength = max( Chainsawing.LeadIn.StartAddLength, Chainsawing.LeadOut.EndAddLength) + Chainsawing.Tool.Width / 2 + 10 * GEO.EPS_SMALL if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then - local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : chainsaw can damage next piece.' + local sDamageNextPieceMessage = 'Feature '.. Proc.TaskId .. ' : chainsaw can damage next piece.' if #Chainsawing.Message > 0 then Chainsawing.Message = Chainsawing.Message .. '\n' .. sDamageNextPieceMessage else @@ -5181,13 +5183,13 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) -- TODO per implementare la strategia con lapjoint lunghe bisogna prima riconoscere le topologie che arrivano if Proc.IsSplittedLapJoint then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for long lapjoint ' + local sErr = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for long lapjoint ' EgtOutLog( sErr) return false, sErr end if not SawPlusChain.IsTopologyOk( Proc) then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName + local sErr = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName EgtOutLog( sErr) return false, sErr end @@ -5195,7 +5197,7 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto if Proc.AffectedFaces.Bottom and ( Proc.Fct > 3 or not Proc.AffectedFaces.Top) then - local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face' + local sErr = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face' EgtOutLog( sErr) return false, sErr end @@ -6496,7 +6498,7 @@ local function MakeLongMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) for i = 1, #vAddId do local b3Box = EgtGetBBoxGlob( vAddId[i], GDB_BB.STANDARD) local nFct = EgtSurfTmFacetCount( vAddId[i]) - local AddProc = { Id = vAddId[i], Grp = Proc.Grp, FeatureId = Proc.FeatureId, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId, IsSplittedLapJoint = true} + local AddProc = { Id = vAddId[i], Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId, TaskId = Proc.TaskId, IsSplittedLapJoint = true} Topology.Classify( AddProc, b3Raw) -- lasciare il false nel sesto parametro (perchè internamente viene verificato se diverso da nil) local bOk, sMyWarn From 72033c8b9f9b46588783986aad6a82fb89d5b374 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 10 Apr 2024 10:07:52 +0200 Subject: [PATCH 21/26] =?UTF-8?q?-=20in=20SawPlusChain,=20in=20messaggio?= =?UTF-8?q?=20elevazione=20non=20raggiunta,=20aggiunti=20valori=20elevazio?= =?UTF-8?q?ne=20e=20massima=20profondit=C3=A0=20raggiunta?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- LuaLibs/ProcessLapJoint.lua | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 1fa7815..a952001 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -5135,7 +5135,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) else Chainsawing.Depth = Chainsawing.Tool.MaxMat Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth - Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : chainsawing elevation bigger than max tool depth' + Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : chainsawing elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Chainsawing.Depth, 1) .. ')' EgtOutLog( Chainsawing.Message) end -- offset radiale From 139579dbef972b74e3f7b35f7c02be404b7651c2 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Wed, 10 Apr 2024 13:19:39 +0200 Subject: [PATCH 22/26] - in SawPlusChain corretta segnalazione errore tasca troppo stretta --- LuaLibs/ProcessLapJoint.lua | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index a952001..10b348b 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4989,7 +4989,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) EgtOutLog( Cutting.Message) return Cutting end - if #( Proc.Pocket.SideFaces) > 0 then + if #( Proc.Pocket.SideFaces) > 1 then -- se tasca più stretta della lama la strategia non è applicabile if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then Cutting.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' @@ -5106,7 +5106,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) EgtOutLog( Chainsawing.Message) return Chainsawing end - if #( Proc.Pocket.SideFaces) == 0 then + if #( Proc.Pocket.SideFaces) > 1 then -- se tasca più stretta della sega a catena la strategia non è applicabile if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' From d7a517160d824345d5682c0b199a3e4c7c9bd22d Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 11 Apr 2024 10:51:05 +0200 Subject: [PATCH 23/26] - in SawPlusChain piccole correzioni - in SawPlusChain aggiunta attivazione con parametro Q11 --- LuaLibs/ProcessLapJoint.lua | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 10b348b..31a18d1 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -174,7 +174,7 @@ local function AssignQIdent( Proc) Q_ANTISPLINT_TYPE = '' Q_MAX_ELEVATION = 'Q10' Q_STAIRCASE = '' - Q_SAW_PLUS_CHAIN = '' + Q_SAW_PLUS_CHAIN = 'Q11' if ( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 16 then Q_FORCE_BLADE = 'Q01' -- i @@ -5024,6 +5024,10 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) else Cutting.Depth = Cutting.Tool.MaxDepth Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth + if Proc.Pocket.ApplyOnlySawblade then + Cutting.Message = 'Feature '.. Proc.TaskId .. ' : sawblade elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Cutting.Depth, 1) .. ')' + EgtOutLog( Cutting.Message) + end end -- step verticale e offset longitudinale Cutting.Steps = SawPlusChain.GetVerticalSteps( Proc, Cutting) @@ -5135,7 +5139,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) else Chainsawing.Depth = Chainsawing.Tool.MaxMat Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth - Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : chainsawing elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Chainsawing.Depth, 1) .. ')' + Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : chainsaw elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Chainsawing.Depth, 1) .. ')' EgtOutLog( Chainsawing.Message) end -- offset radiale @@ -5178,6 +5182,7 @@ end function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) Proc.Pocket = {} + Proc.Pocket.ApplyOnlySawblade = bOnlySaw Proc.Pocket.Strategy = 'SawPlusChain' local b3Raw = EgtGetRawPartBBox( nRawId) @@ -5299,12 +5304,8 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa return false, sErr end - - - - --- rimuovere true or!!!!!! - if true or EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') > 0 then --TEST + -- strategia lama + eventuale sega a catena + if ( EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') or 0) > 0 then --TEST local bOk local sErr local bOnlySaw = EgtGetInfo( Proc.Id, Q_SAW_PLUS_CHAIN, 'i') == 1 @@ -5312,11 +5313,6 @@ local function MakeMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead, bSinglePa return bOk, sErr end - - - - - local bClosedOrthoFaces local nFacInd, dFacElev, nFacInd2, dFacElev2 local nBottomFace From 617058cdda1038f8b0d6688996d387cf7358d2e6 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 11 Apr 2024 12:14:33 +0200 Subject: [PATCH 24/26] - in SawPlusChain nei messaggi si scrive il FeatureId invece di TaskId - commenti e piccole correzioni --- LuaLibs/BeamExec.lua | 3 +++ LuaLibs/ProcessLapJoint.lua | 41 ++++++++++++++++++++----------------- 2 files changed, 25 insertions(+), 19 deletions(-) diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index 99814a8..66167cc 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -62,6 +62,7 @@ -- 2024/03/11 In CollectFeatures si scrive ora Width e Height della faccia sia trimmate con il grezzo che intere. -- 2024/03/13 In CollectFeatures si scrive lunghezza foro su Proc e si controla se serve Predrill -- In OrderFeature, preforo sempre prima del foro +-- 2024/04/11 In CollectFeatures aggiunta lettura info PRID, scritta in Proc.FeatureId -- Tabella per definizione modulo local BeamExec = {} @@ -344,6 +345,8 @@ local function CollectFeatures( PartId, b3Raw, dCurrOvmH, dCurrOvmT) end Proc.Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD) if b3Raw then + -- id della feature + Proc.FeatureId = EgtGetInfo( ProcId, 'PRID', 'i') or Proc.TaskId -- recupero l'elenco delle facce della parte interessate dalla feature Proc.AffectedFaces = BL.GetProcessAffectedFaces( Proc) -- recupero informazioni sulle facce della feature diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 31a18d1..151a24c 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -101,6 +101,7 @@ -- 2024/03/04 Implementato attacco esterno se tasca 4 facce sulla coda ma nessun pezzo successivo. -- 2024/03/15 Correzione a calcolo ingombro per feature basse e lunghe dalla testa. -- 2024/04/02 In ForceSideMill escluso caso 4 facce senza possibilità di ingresso lungo Y. +-- 2024/04/11 Aggiunta strategia SawPlusChain per lavorazione tasche con lama + sega a catena opzionale. Attivata con Q11. -- Tabella per definizione modulo local ProcessLapJoint = {} @@ -4606,10 +4607,11 @@ function SawPlusChain.IsTopologyOk( Proc) if Proc.TopologyLongName == 'Pocket-Blind-RightAngles-Parallel-5' or Proc.TopologyLongName == 'Groove-Through-RightAngles-Parallel-3' or Proc.TopologyLongName == 'Groove-Blind-RightAngles-Parallel-4' then - return true - else - return false - end + + return true + else + return false + end end @@ -4776,7 +4778,7 @@ end function SawPlusChain.CalculateLeadInOut( Proc, Machining) - -- TODO qui saranno da implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom) + -- TODO implementare le funzioni di Tool Collision Avoidance (vedi wiki e FacesBysaw -> CalcLeadInOutPerpGeom) -- si determina se l'inizio o la fine della lavorazione sono chiusi e l'eventuale riduzione da applicare local bIsStartClosed = false @@ -4944,6 +4946,7 @@ end function SawPlusChain.Saw.GetSCC( vtMachiningDirection) + -- TODO implementare SCC come per FacesBySaw local nSCC = MCH_SCC.NONE if AreSameVectorApprox( vtMachiningDirection, Z_AX()) then nSCC = MCH_SCC.ADIR_ZP @@ -4972,7 +4975,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- ricerca lavorazione Cutting.Name = ML.FindCutting( 'HeadSide', true, false) if not Cutting.Name then - Cutting.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' + Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - saw blade not found' Cutting.CanApply = false EgtOutLog( Cutting.Message) return Cutting @@ -4984,7 +4987,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- verifica dimensioni tasca compatibili -- se tasca meno spessa della lama la strategia non è applicabile if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - Cutting.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' + Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' Cutting.CanApply = false EgtOutLog( Cutting.Message) return Cutting @@ -4992,7 +4995,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) if #( Proc.Pocket.SideFaces) > 1 then -- se tasca più stretta della lama la strategia non è applicabile if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - Cutting.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' + Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' Cutting.CanApply = false EgtOutLog( Cutting.Message) return Cutting @@ -5025,7 +5028,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) Cutting.Depth = Cutting.Tool.MaxDepth Cutting.RadialOffset = Proc.Pocket.Depth - Cutting.Depth if Proc.Pocket.ApplyOnlySawblade then - Cutting.Message = 'Feature '.. Proc.TaskId .. ' : sawblade elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Cutting.Depth, 1) .. ')' + Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : sawblade elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Cutting.Depth, 1) .. ')' EgtOutLog( Cutting.Message) end end @@ -5068,7 +5071,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- eventuale avviso di danneggiamento pezzo successivo local dOffsideLength = max( Cutting.LeadIn.StartAddLength, Cutting.LeadOut.EndAddLength) + Cutting.Tool.Diameter / 2 + 10 * GEO.EPS_SMALL if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then - local sDamageNextPieceMessage = 'Feature '.. Proc.TaskId .. ' : sawblade can damage next piece.' + local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : sawblade can damage next piece.' if #Cutting.Message > 0 then Cutting.Message = Cutting.Message .. '\n' .. sDamageNextPieceMessage else @@ -5093,7 +5096,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) Chainsawing.Name = ML.FindSawing( 'Sawing', nil, nil, 'Longest') end if not Chainsawing.Name then - Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' + Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - chainsaw not found' Chainsawing.CanApply = false EgtOutLog( Chainsawing.Message) return Chainsawing @@ -5105,7 +5108,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) -- verifica dimensioni tasca compatibili -- se tasca meno spessa della sega a catena la strategia non è applicabile if Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then - Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' + Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' Chainsawing.CanApply = false EgtOutLog( Chainsawing.Message) return Chainsawing @@ -5113,7 +5116,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) if #( Proc.Pocket.SideFaces) > 1 then -- se tasca più stretta della sega a catena la strategia non è applicabile if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then - Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' + Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' Chainsawing.CanApply = false EgtOutLog( Chainsawing.Message) return Chainsawing @@ -5139,7 +5142,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) else Chainsawing.Depth = Chainsawing.Tool.MaxMat Chainsawing.LongitudinalOffset = Proc.Pocket.Depth - Chainsawing.Depth - Chainsawing.Message = 'Feature '.. Proc.TaskId .. ' : chainsaw elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Chainsawing.Depth, 1) .. ')' + Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : chainsaw elevation (' .. EgtNumToString( Proc.Pocket.Depth, 1) .. ') bigger than max tool depth (' .. EgtNumToString( Chainsawing.Depth, 1) .. ')' EgtOutLog( Chainsawing.Message) end -- offset radiale @@ -5167,7 +5170,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) -- eventuale avviso di danneggiamento pezzo successivo local dOffsideLength = max( Chainsawing.LeadIn.StartAddLength, Chainsawing.LeadOut.EndAddLength) + Chainsawing.Tool.Width / 2 + 10 * GEO.EPS_SMALL if ( not Proc.Tail or Proc.AdvTail) and Proc.AffectedFaces.Left and ( Proc.Pocket.DistanceToNextPart < dOffsideLength) then - local sDamageNextPieceMessage = 'Feature '.. Proc.TaskId .. ' : chainsaw can damage next piece.' + local sDamageNextPieceMessage = 'Feature '.. Proc.FeatureId .. ' : chainsaw can damage next piece.' if #Chainsawing.Message > 0 then Chainsawing.Message = Chainsawing.Message .. '\n' .. sDamageNextPieceMessage else @@ -5188,13 +5191,13 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) -- TODO per implementare la strategia con lapjoint lunghe bisogna prima riconoscere le topologie che arrivano if Proc.IsSplittedLapJoint then - local sErr = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for long lapjoint ' + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for long lapjoint' EgtOutLog( sErr) return false, sErr end if not SawPlusChain.IsTopologyOk( Proc) then - local sErr = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented for topology ' .. Proc.TopologyLongName + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not implemented' EgtOutLog( sErr) return false, sErr end @@ -5202,7 +5205,7 @@ function SawPlusChain.Make( Proc, nRawId, nPhase, bOnlySaw) -- se tasca su faccia sotto la strategia non è applicabile (la sega a catena in generale non può lavorare da sotto) -- TODO se OnlySaw questo test è da rimuovere ma bisogna considerare anche la lama da sotto if Proc.AffectedFaces.Bottom and ( Proc.Fct > 3 or not Proc.AffectedFaces.Top) then - local sErr = 'Feature '.. Proc.TaskId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face' + local sErr = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket on bottom face' EgtOutLog( sErr) return false, sErr end @@ -6494,7 +6497,7 @@ local function MakeLongMoreFaces( Proc, nPhase, nRawId, nPartId, dOvmHead) for i = 1, #vAddId do local b3Box = EgtGetBBoxGlob( vAddId[i], GDB_BB.STANDARD) local nFct = EgtSurfTmFacetCount( vAddId[i]) - local AddProc = { Id = vAddId[i], Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId, TaskId = Proc.TaskId, IsSplittedLapJoint = true} + local AddProc = { Id = vAddId[i], Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Box, TotBox = Proc.Box, Fct = nFct, Flg = Proc.Flg, PartId = Proc.PartId, TaskId = Proc.TaskId, FeatureId = Proc.FeatureId, IsSplittedLapJoint = true} Topology.Classify( AddProc, b3Raw) -- lasciare il false nel sesto parametro (perchè internamente viene verificato se diverso da nil) local bOk, sMyWarn From 3699daf998bd269091c42aa2ef27a6ae223e1a79 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 11 Apr 2024 12:45:56 +0200 Subject: [PATCH 25/26] - in SawPlusChain corretta tolleranza spessore tasca --- LuaLibs/ProcessLapJoint.lua | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/LuaLibs/ProcessLapJoint.lua b/LuaLibs/ProcessLapJoint.lua index 151a24c..11178a2 100644 --- a/LuaLibs/ProcessLapJoint.lua +++ b/LuaLibs/ProcessLapJoint.lua @@ -4986,7 +4986,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) -- verifica dimensioni tasca compatibili -- se tasca meno spessa della lama la strategia non è applicabile - if Cutting.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then + if Cutting.Tool.Thickness > Proc.Pocket.Height + 10 * GEO.EPS_SMALL then Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade thickness' Cutting.CanApply = false EgtOutLog( Cutting.Message) @@ -4994,7 +4994,7 @@ function SawPlusChain.Saw.CalculateMachiningParameters( Proc) end if #( Proc.Pocket.SideFaces) > 1 then -- se tasca più stretta della lama la strategia non è applicabile - if Cutting.Tool.Diameter > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + if Cutting.Tool.Diameter > Proc.Pocket.Width + 10 * GEO.EPS_SMALL then Cutting.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for saw blade diameter' Cutting.CanApply = false EgtOutLog( Cutting.Message) @@ -5107,7 +5107,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) -- verifica dimensioni tasca compatibili -- se tasca meno spessa della sega a catena la strategia non è applicabile - if Chainsawing.Tool.Thickness > Proc.Pocket.Height - 10 * GEO.EPS_SMALL then + if Chainsawing.Tool.Thickness > Proc.Pocket.Height + 10 * GEO.EPS_SMALL then Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw thickness' Chainsawing.CanApply = false EgtOutLog( Chainsawing.Message) @@ -5115,7 +5115,7 @@ function SawPlusChain.Chainsaw.CalculateMachiningParameters( Proc) end if #( Proc.Pocket.SideFaces) > 1 then -- se tasca più stretta della sega a catena la strategia non è applicabile - if Chainsawing.Tool.Width > Proc.Pocket.Width - 10 * GEO.EPS_SMALL then + if Chainsawing.Tool.Width > Proc.Pocket.Width + 10 * GEO.EPS_SMALL then Chainsawing.Message = 'Feature '.. Proc.FeatureId .. ' : strategy ' .. Proc.Pocket.Strategy .. ' not applicable - pocket too narrow for chainsaw width' Chainsawing.CanApply = false EgtOutLog( Chainsawing.Message) From eefd8ba037f8d244ea91742253eaf6aa99daece2 Mon Sep 17 00:00:00 2001 From: "luca.mazzoleni" Date: Thu, 11 Apr 2024 12:56:21 +0200 Subject: [PATCH 26/26] - update log e version --- UpdateLog.txt | 3 +++ Version.lua | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/UpdateLog.txt b/UpdateLog.txt index 03b5c30..66cb719 100644 --- a/UpdateLog.txt +++ b/UpdateLog.txt @@ -1,5 +1,8 @@ ==== Beam Update Log ==== +Versione 2.6d2 (11/04/2024) +- Added : in LapJoint aggiunta strategia per fare tasche con lama + sega a catena, attivata da Q11 + Versione 2.6d1 (08/04/2024) - Fixed : in Long2Cut corretto nome passato alla BL.GetBlockedAxis - Fixed : in MakeTwo rimossa gestione calcolo differente su ultima passata in caso di macchina FAST diff --git a/Version.lua b/Version.lua index 2f64bf4..43512e9 100644 --- a/Version.lua +++ b/Version.lua @@ -2,5 +2,5 @@ -- Gestione della versione di Beam NAME = 'Beam' -VERSION = '2.6d1' +VERSION = '2.6d2' MIN_EXE = '2.6a1'