diff --git a/LuaLibs/BeamExec.lua b/LuaLibs/BeamExec.lua index 2afbb54..980fb61 100644 --- a/LuaLibs/BeamExec.lua +++ b/LuaLibs/BeamExec.lua @@ -39,6 +39,8 @@ -- 2022/09/29 Aggiunta la ricerca di feature specchiate, al momento solo per DtMortise, con le relative funzioni. -- 2022/12/23 Corrette rotazioni 90 deg per macchine con carico da destra. -- 2022/12/28 Implementata gestione forature e code di rondine in doppio. +-- 2023/01/31 Implementata gestione mortase in doppio. +-- 2023/01/31 Nelle lavorazioni in doppio aggiunta la minima distanza tra le feature. -- Tabella per definizione modulo @@ -1378,14 +1380,15 @@ local function MoveDrillsOnTenon( vProc) end ------------------------------------------------------------------------------------------------------------- --- Controlla se la feature ProcMirror è la specchiata di Proc, per feature di tipo DtMortise -local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId) +-- Controlla se la feature ProcMirror è la specchiata di Proc, per feature di tipo tasca o simile +local function CheckMirrorPocket( Proc, ProcMirror, b3Raw, AuxId) -- recupero i dati geometrici della curva Proc local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB) local ptBC = EgtGP( AuxId, GDB_RT.GLOB) local rfDtMrt = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0, GDB_RT.GLOB) local b3DtMrt = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, rfDtMrt) + local b3Proc = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD) -- determino l'asse della curva Proc local vtAx = EgtEV( AuxId, GDB_RT.GLOB) - EgtSV( AuxId, GDB_RT.GLOB) @@ -1395,10 +1398,15 @@ local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId) if not AuxIdMirror or ( EgtGetType( AuxIdMirror) & GDB_FY.GEO_CURVE) == 0 then return false end + -- se Mortise, se curva di contorno aperta la rendo chiusa + if Mortise.SideIdentify( ProcMirror) then + BL.ConvertToClosedCurve( ProcMirror, AuxIdMirror) + end -- recupero i dati geometrici della curva ProcMirror local vtExtrMirror = EgtCurveExtrusion( AuxIdMirror, GDB_RT.GLOB) local ptBCMirror = EgtGP( AuxIdMirror, GDB_RT.GLOB) local b3DtMrtMirror = EgtGetBBoxRef( ProcMirror.Id, GDB_BB.STANDARD, rfDtMrt) + local b3ProcMirror = EgtGetBBoxGlob( ProcMirror.Id, GDB_BB.STANDARD) -- determino l'asse della curva ProcMirror local vtAxMirror = EgtEV( AuxIdMirror, GDB_RT.GLOB) - EgtSV( AuxIdMirror, GDB_RT.GLOB) @@ -1406,13 +1414,19 @@ local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId) local bIsMirror = true local vtDisplacement = ptBC - ptBCMirror local ptCenRaw = b3Raw:getCenter() - -- controllo che il centro delle due mortase sia allineato e che queste siano equidistanti dalla mezzeria della trave + local dYMinDistance = EgtIf( ptBC:getY() > ptBCMirror:getY(), abs( b3ProcMirror:getMax():getY() - b3Proc:getMin():getY()), abs( b3Proc:getMax():getY() - b3ProcMirror:getMin():getY())) + local dZMinDistance = EgtIf( ptBC:getZ() > ptBCMirror:getZ(), abs( b3ProcMirror:getMax():getZ() - b3Proc:getMin():getZ()), abs( b3Proc:getMax():getZ() - b3ProcMirror:getMin():getZ())) + local dMinimumDistanceMirroredFeatures = 60 + -- controllo che il centro delle due mortase sia allineato, che queste siano equidistanti dalla mezzeria della trave + -- e che queste non siano troppo vicine if AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) then bIsMirror = abs( vtDisplacement:getX()) < 500 * GEO.EPS_SMALL and abs( vtDisplacement:getZ()) < 500 * GEO.EPS_SMALL and - ( abs( ptBC:getY() - ptCenRaw:getY()) - abs( ptBCMirror:getY() - ptCenRaw:getY())) < 500 * GEO.EPS_SMALL + ( abs( ptBC:getY() - ptCenRaw:getY()) - abs( ptBCMirror:getY() - ptCenRaw:getY())) < 500 * GEO.EPS_SMALL and + dYMinDistance - dMinimumDistanceMirroredFeatures > 10 * GEO.EPS_SMALL elseif AreSameOrOppositeVectorApprox( vtExtr, Z_AX()) then bIsMirror = abs( vtDisplacement:getX()) < 500 * GEO.EPS_SMALL and abs( vtDisplacement:getY()) < 500 * GEO.EPS_SMALL and - ( abs( ptBC:getZ() - ptCenRaw:getZ()) - abs( ptBCMirror:getZ() - ptCenRaw:getZ())) < 500 * GEO.EPS_SMALL + ( abs( ptBC:getZ() - ptCenRaw:getZ()) - abs( ptBCMirror:getZ() - ptCenRaw:getZ())) < 500 * GEO.EPS_SMALL and + dZMinDistance - dMinimumDistanceMirroredFeatures > 10 * GEO.EPS_SMALL end -- controllo che le dimensioni dei due box siano le stesse bIsMirror = bIsMirror and abs( b3DtMrt:getDimX() - b3DtMrtMirror:getDimX()) < 500 * GEO.EPS_SMALL and @@ -1424,6 +1438,96 @@ local function CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId) return bIsMirror end +------------------------------------------------------------------------------------------------------------- +-- Verifica se Proc (mortasa) è lavorabile in doppio e nel caso ne imposta i dati. +local function VerifyMortiseMirrored( Proc, vProc, b3Raw) + -- recupero e verifico l'entità curva + local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i') + if AuxId then + AuxId = AuxId + Proc.Id + end + if not AuxId or ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then + local sErr = 'Error : missing profile geometry' + EgtOutLog( sErr) + return false, sErr + end + -- recupero versore estrusione della curva supplementare + local vtExtr = EgtCurveExtrusion( AuxId, GDB_ID.ROOT) + -- Se curva di contorno aperta la converto in curva chiusa + BL.ConvertToClosedCurve( Proc, AuxId) + -- recupero i dati della faccia di fondo + local frMor, dL, dW = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0, GDB_ID.ROOT) + -- determino larghezza della mortasa + if dL < dW then dL, dW = dW, dL end + local ptC = ORIG() + local vtN = V_NULL() + if frMor then + ptC = frMor:getOrigin() + vtN = frMor:getVersZ() + end + -- se mortasa passante esco + local bOpenBtm = not AreSameVectorApprox( vtExtr, vtN) + if bOpenBtm then + return + end + -- determino altezza della mortasa + local b3Mor = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, frMor) + local dMorH = b3Mor:getDimZ() + -- elevazione del punto centrale + local _, dCenElev = BL.GetPointDirDepth( nPartId, ptC, vtN) + dMorH = max( dMorH, dCenElev or 0) + -- recupero lavorazione adatta + local sPockType = 'Mortise' + local sPocketing + if Proc.Prc ~= 53 then + sPocketing = Mortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType, false) + end + if not sPocketing then + sPockType = 'Pocket' + sPocketing = Mortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType, false) + end + if not sPocketing or not EgtMdbSetCurrMachining( sPocketing) then + return + end + -- recupero il suo utensile + if not EgtTdbSetCurrTool( EgtMdbGetCurrMachiningParam( MCH_MP.TOOL) or '') then + return + end + -- recupero eventuale utensile in doppio e suo diametro + local sToolDoubleName = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'DOUBLE', 's') + if not sToolDoubleName or not EgtTdbSetCurrTool( sToolDoubleName) or not EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then + return + end + local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd') + -- verifico se possibile in doppio (diametro utensile e direzione feature) + if dToolDoubleDiam < dW + GEO.EPS_SMALL and ( AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) or AreSameVectorApprox( vtExtr, Z_AX())) then + for i = 1, #vProc do + local ProcMirror = vProc[i] + if Mortise.SideIdentify( ProcMirror) and ProcMirror.Id ~= Proc.Id and ProcMirror.Flg ~= 0 then + if CheckMirrorPocket( Proc, ProcMirror, b3Raw, AuxId) then + if ( not BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Y_AX())) or + ( BD.DOWN_HEAD and AreOppositeVectorApprox( vtExtr, Y_AX())) then + Proc.Double = 2 + Proc.MirrorId = ProcMirror.Id + Proc.MirrorCutId = ProcMirror.CutId + Proc.MirrorTaskId = ProcMirror.TaskId + ProcMirror.Flg = 0 + ProcMirror.Double = 0 + elseif BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Z_AX()) then + Proc.Double = 3 + Proc.MirrorId = ProcMirror.Id + Proc.MirrorCutId = ProcMirror.CutId + Proc.MirrorTaskId = ProcMirror.TaskId + ProcMirror.Flg = 0 + ProcMirror.Double = 0 + end + break + end + end + end + end +end + ------------------------------------------------------------------------------------------------------------- -- Verifica se Proc (mortasa a coda di rondine) è lavorabile in doppio e nel caso ne imposta i dati. local function VerifyDtMortiseMirrored( Proc, vProc, b3Raw) @@ -1464,12 +1568,12 @@ local function VerifyDtMortiseMirrored( Proc, vProc, b3Raw) return end local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd') - -- verifico se possibile in doppio (diametro utensile e direzione feaure) + -- verifico se possibile in doppio (diametro utensile e direzione feature) if dToolDoubleDiam < dMaxDiam + GEO.EPS_SMALL and ( AreSameOrOppositeVectorApprox( vtExtr, Y_AX()) or AreSameVectorApprox( vtExtr, Z_AX())) then for i = 1, #vProc do local ProcMirror = vProc[i] if DtMortise.SideIdentify( ProcMirror) and ProcMirror.Id ~= Proc.Id and ProcMirror.Flg ~= 0 then - if CheckMirrorDtMortise( Proc, ProcMirror, b3Raw, AuxId) then + if CheckMirrorPocket( Proc, ProcMirror, b3Raw, AuxId) then if ( not BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Y_AX())) or ( BD.DOWN_HEAD and AreOppositeVectorApprox( vtExtr, Y_AX())) then Proc.Double = 2 @@ -1532,10 +1636,13 @@ local function VerifyDrillMirrored( Proc, vProc, b3Raw) if not sDrilling or sType ~= 'Drill' or not EgtMdbSetCurrMachining( sDrilling) then return end + local dDrillingStep = EgtMdbGetCurrMachiningParam( MCH_MP.STEP) -- recupero il suo utensile if not EgtTdbSetCurrTool( EgtMdbGetCurrMachiningParam( MCH_MP.TOOL) or '') then return end + -- recupero la lunghezza della parte inclinata della punta + local dToolTipLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) - EgtTdbGetCurrToolParam( MCH_TP.LEN) -- recupero eventuale utensile in doppio, suo diametro e massima lavorazione local sToolDoubleName = EgtTdbGetCurrToolValInNotes( MCH_TP.USERNOTES, 'DOUBLE', 's') if not sToolDoubleName or not EgtTdbSetCurrTool( sToolDoubleName) or not EgtTdbGetCurrToolParam( MCH_TP.ACTIVE) then @@ -1543,9 +1650,13 @@ local function VerifyDrillMirrored( Proc, vProc, b3Raw) end local dToolDoubleDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM, 'd') local dToolDoubleMaxDepth = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT) + -- recupero la lunghezza della parte inclinata della punta + local dToolDoubleTipLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN) - EgtTdbGetCurrToolParam( MCH_TP.LEN) -- verifico se in doppio + local dMinimumDistanceMirroredFeatures = 40 dMachiningDepth = min( dMachiningDepth, dToolDoubleMaxDepth) - if abs( Proc.Flg) == 2 and dToolDoubleDiam < dDiam + 10 * GEO.EPS_SMALL and dToolDoubleDiam > dDiam - BD.DRILL_TOL - 10 * GEO.EPS_SMALL then + if abs( Proc.Flg) == 2 and dToolDoubleDiam < dDiam + 10 * GEO.EPS_SMALL and dToolDoubleDiam > dDiam - BD.DRILL_TOL - 10 * GEO.EPS_SMALL and + (( 2 * dDrillingStep - dToolTipLength - dToolDoubleTipLength) - dMinimumDistanceMirroredFeatures) > 10 * GEO.EPS_SMALL then if Proc.Fce ~= 0 then if Proc.Flg == -2 then vtExtr = -vtExtr end if ( not BD.DOWN_HEAD and AreSameVectorApprox( vtExtr, Y_AX())) or @@ -1572,6 +1683,8 @@ local function SetMirroredFeatures( vProc, b3Raw) -- Proc.MirrorId -> Id della feature mirrorata if DtMortise.SideIdentify( Proc) and BD.DOUBLE_HEAD_DOVETAIL then VerifyDtMortiseMirrored( Proc, vProc, b3Raw) + elseif Mortise.SideIdentify( Proc) and BD.DOUBLE_HEAD_MORTISE then + VerifyMortiseMirrored( Proc, vProc, b3Raw) elseif Drill.Identify( Proc) and BD.DOUBLE_HEAD_DRILLING then VerifyDrillMirrored( Proc, vProc, b3Raw) end diff --git a/LuaLibs/BeamLib.lua b/LuaLibs/BeamLib.lua index eb16352..865be86 100644 --- a/LuaLibs/BeamLib.lua +++ b/LuaLibs/BeamLib.lua @@ -19,6 +19,7 @@ -- 2022/09/01 Aggiunte le funzioni GetTunnelDimension, CalcCollisionSafety, SetOpenSide, precedentemente in ProcessLapJoint. -- 2023/01/10 In GetFaceWithMostAdj aggiunta verifica che la feature abbia almeno una faccia aperta. -- 2023/01/20 Modificata PutStartNearestToEdge per gestire lato preferito come Y+, Y-, z*, Z-. Aggiunta funzione GetDistanceToNextPart. +-- 2023/01/31 Aggiunta funzione ConvertToClosedCurve, precedentemente parte di ProcessMortise.Make -- Tabella per definizione modulo local BeamLib = {} @@ -1081,5 +1082,41 @@ function BeamLib.SetOpenSide( nPathInt, vtOrtho, b3Solid, nAddGrpId, nStartPoint return false end +------------------------------------------------------------------------------------------------------------- +function BeamLib.ConvertToClosedCurve( Proc, AuxId) + local bCurveModified = false + if not EgtCurveIsClosed( AuxId) then + local NewId, nCount = EgtExtractSurfTmFacetLoops( Proc.Id, 0, EgtGetParent( Proc.Id)) + if NewId then + -- elimino eventuali loop interni (non dovrebbero comunque esserci) + for i = 1, nCount - 1 do + EgtErase( NewId + i) + end + local vtExtr = EgtCurveExtrusion( AuxId, GDB_ID.ROOT) + -- sostituisco il loop esterno alla curva originale + EgtModifyCurveExtrusion( NewId, vtExtr, GDB_ID.ROOT) + EgtRelocate( NewId, AuxId, GDB_IN.AFTER) + EgtErase( AuxId) + EgtChangeId( NewId, AuxId) + bCurveModified = true + -- sistemo i lati aperti + local vFacAdj = EgtSurfTmFacetAdjacencies( Proc.Id, 0)[1] + if vFacAdj then + local sOpen = '' + for i = 1, #vFacAdj do + if vFacAdj[i] < 0 then + sOpen = sOpen .. EgtIf( #sOpen > 0, ',', '') .. tostring( i - 1) + end + end + if #sOpen > 0 then + EgtSetInfo( AuxId, 'OPEN', sOpen) + end + end + end + end + + return true, bCurveModified +end + ------------------------------------------------------------------------------------------------------------- return BeamLib diff --git a/LuaLibs/MachiningLib.lua b/LuaLibs/MachiningLib.lua index 4b097e8..1547b03 100644 --- a/LuaLibs/MachiningLib.lua +++ b/LuaLibs/MachiningLib.lua @@ -5,6 +5,7 @@ -- 2022/11/02 Modificata scelta utensile ottimizzata. Ora se c'è un utensile più grande disponibile si dà preferenza a quello. -- 2022/11/25 Per FindMilling implementata la possibilità di escludere la testa H3 dalla ricerca utensile. -- 2022/12/28 Per FindMilling e FindDrilling possibilità di escludere la testa H2 dalla ricerca utensile. +-- 2023/01/31 Per FindPocketing implementata la possibilità di escludere le teste H2 o H3 dalla ricerca utensile. -- Tabella per definizione modulo local MachiningLib = {} @@ -402,8 +403,8 @@ function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotL end --------------------------------------------------------------------- -function MachiningLib.FindPocketing( sType, dMaxDiam, dDepth, dMaxTotLen, bTopHead, bDownHead) - return FindMachining( MCH_MY.POCKETING, sType, { MaxDiam = dMaxDiam, Depth = dDepth, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead) +function MachiningLib.FindPocketing( sType, dMaxDiam, dDepth, dMaxTotLen, bTopHead, bDownHead, bExcludeH2, bExcludeH3) + return FindMachining( MCH_MY.POCKETING, sType, { MaxDiam = dMaxDiam, Depth = dDepth, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead, bExcludeH2, bExcludeH3) end --------------------------------------------------------------------- diff --git a/LuaLibs/ProcessDtMortise.lua b/LuaLibs/ProcessDtMortise.lua index a268f35..b7b6085 100644 --- a/LuaLibs/ProcessDtMortise.lua +++ b/LuaLibs/ProcessDtMortise.lua @@ -8,6 +8,7 @@ -- 2022/06/01 Modifiche per evitare di entrare nel legno con mortase parziali. -- 2022/08/18 Migliorato calcolo dello step. -- 2022/09/29 Aggiunto riconoscimento della sola feature laterale. +-- 2022/12/28 Aggiunta gestione lavorazione in doppio. -- Tabella per definizione modulo local ProcessDtMortise = {} @@ -237,6 +238,7 @@ function ProcessDtMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH) bMillUp = true bMillDown = false bExcludeH2 = true + sMchExt = '' end -- recupero la lavorazione : prima ricerca per sola tipologia local sMilling = ML.FindMilling( sMillType..sMchExt, nil, nil, nil, nil, bMillUp, bMillDown, bExcludeH2) diff --git a/LuaLibs/ProcessMortise.lua b/LuaLibs/ProcessMortise.lua index d321317..24419d2 100644 --- a/LuaLibs/ProcessMortise.lua +++ b/LuaLibs/ProcessMortise.lua @@ -7,6 +7,8 @@ -- 2022/09/27 Migliorata la scelta utensile. Se c'è almeno una lavorazione 'mortise' si cerca di usare quelle, riducendo l'elevazione se necessario. -- Se non c'è nemmeno una lavorazione 'mortise' si passa alle pocket. -- 2022/12/12 Migliorato controllo necessità CleanCorners. +-- 2023/01/31 Aggiunta gestione lavorazione in doppio. +-- 2023/01/31 Creata la funzione ConvertToClosedCurve (parte della ProcessMortise.Make) e spostata in BeamLib. -- Tabella per definizione modulo local ProcessMortise = {} @@ -36,6 +38,13 @@ function ProcessMortise.FrontIdentify( Proc) return (( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 51) end +--------------------------------------------------------------------- +-- Riconoscimento delle sole feature laterali +function ProcessMortise.SideIdentify( Proc) + return ( (( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 50) or + (( Proc.Grp == 3 or Proc.Grp == 4) and Proc.Prc == 53)) +end + --------------------------------------------------------------------- -- Classificazione della feature: decide se la feature è in una posizione che per lavorala -- deve essere ribaltata o no @@ -234,17 +243,17 @@ local function CleanCorners( Proc, dMorH, vtN, bDoubleDir, AuxId) end --------------------------------------------------------------------- -local function VerifyMortiseOrPocket( Proc, dDiam, dDepth, dMaxTotLen, sType, bPocketDown) +function ProcessMortise.VerifyMortiseOrPocket( Proc, dDiam, dDepth, dMaxTotLen, sType, bPocketDown, bExcludeH2) -- ricerca della svuotatura local sPocketing if dDepth then - sPocketing = ML.FindPocketing( sType, dDiam, dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or - ML.FindPocketing( sType, dDiam, 0.8 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or - ML.FindPocketing( sType, dDiam, 0.6 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or - ML.FindPocketing( sType, dDiam, 0.4 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown) or - ML.FindPocketing( sType, dDiam, 0, dMaxTotLen) + sPocketing = ML.FindPocketing( sType, dDiam, dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) or + ML.FindPocketing( sType, dDiam, 0.8 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) or + ML.FindPocketing( sType, dDiam, 0.6 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) or + ML.FindPocketing( sType, dDiam, 0.4 * dDepth, dMaxTotLen, not bPocketDown, bPocketDown, bExcludeH2) or + ML.FindPocketing( sType, dDiam, 0, dMaxTotLen, bExcludeH2) else - sPocketing = ML.FindPocketing( sType, dDiam, 0, dMaxTotLen) + sPocketing = ML.FindPocketing( sType, dDiam, 0, dMaxTotLen, bExcludeH2) end if not sPocketing then return false @@ -286,34 +295,8 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH) end -- recupero versore estrusione della curva supplementare local vtExtr = EgtCurveExtrusion( AuxId, GDB_ID.ROOT) - -- Se curva di contorno aperta - if not EgtCurveIsClosed( AuxId) then - local NewId, nCount = EgtExtractSurfTmFacetLoops( Proc.Id, 0, EgtGetParent( Proc.Id)) - if NewId then - -- elimino eventuali loop interni (non dovrebbero comunque esserci) - for i = 1, nCount - 1 do - EgtErase( NewId + i) - end - -- sostituisco il loop esterno alla curva originale - EgtModifyCurveExtrusion( NewId, vtExtr, GDB_ID.ROOT) - EgtRelocate( NewId, AuxId, GDB_IN.AFTER) - EgtErase( AuxId) - EgtChangeId( NewId, AuxId) - -- sistemo i lati aperti - local vFacAdj = EgtSurfTmFacetAdjacencies( Proc.Id, 0)[1] - if vFacAdj then - local sOpen = '' - for i = 1, #vFacAdj do - if vFacAdj[i] < 0 then - sOpen = sOpen .. EgtIf( #sOpen > 0, ',', '') .. tostring( i - 1) - end - end - if #sOpen > 0 then - EgtSetInfo( AuxId, 'OPEN', sOpen) - end - end - end - end + -- se curva di contorno aperta la rendo chiusa + BL.ConvertToClosedCurve( Proc, AuxId) -- verifico se frontale local bFront = ( Proc.Prc == 51) -- recupero i dati della faccia di fondo @@ -420,18 +403,25 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH) elseif bPockAngTrasm then sMchExt = '_AT' end + local bExcludeH2 = false + if Proc.Double and Proc.Double > 0 then + bPockUp = false + bPockDown = false + bExcludeH2 = true + sMchExt = '' + end local sPocketing if Proc.Prc ~= 53 then - sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown) + sPocketing = ProcessMortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown, bExcludeH2) if not sPocketing and bPockUp then - sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt) + sPocketing = ProcessMortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, _, bExcludeH2) end end if not sPocketing then sPockType = 'Pocket' - sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown) + sPocketing = ProcessMortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, bPockDown, bExcludeH2) if not sPocketing and bPockUp then - sPocketing = VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt) + sPocketing = ProcessMortise.VerifyMortiseOrPocket( Proc, dW, dMorH, nil, sPockType..sMchExt, _, bExcludeH2) end end if not sPocketing then @@ -509,7 +499,12 @@ function ProcessMortise.Make( Proc, nPhase, nRawId, nPartId, dCurrOvmH) end end -- imposto elevazione - EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dMorH, 1) .. ';') + local sUserNotes = 'MaxElev=' .. EgtNumToString( dMorH, 1) .. ';' + -- se lavorazione in doppio + if Proc.Double and Proc.Double > 0 then + sUserNotes = EgtSetValInNotes( sUserNotes, 'DOUBLE', Proc.Double) + end + EgtSetMachiningParam( MCH_MP.USERNOTES, sUserNotes) -- eseguo if not ML.ApplyMachining( true, false) then local _, sErr = EgtGetLastMachMgrError()