-- -- EEEEEEEEEE GGGGGG wwww wwww -- EEEEEEEEEE GGGGGGGGGG wwww wwww -- EEEE GGGG GGGG wwww wwww wwww -- EEEE GGGG wwww wwww wwww -- EEEEEEE GGGG GGGGGGG wwww wwwwww wwww -- EEEEEEE GGGG GGGGGGG wwww wwwwww wwww -- EEEE GGGG GGGG wwww wwwwwwww wwww -- EEEE GGGG GGGG wwww wwww wwww wwww -- EEEEEEEEEE GGGGGGGGGG wwwwwwww wwwwwwww -- EEEEEEEEEE GGGGGG wwwwwww wwwwwww -- -- Machining_3v3.lua by EgalWare s.r.l. 2019.02.05 -- Autore: Filippo Monchi -- Machining generation for Doors program machine Multiax NE -- New mode to manage properties and manage materials, manage 2 tables -- 2017.06.05 V1.011 DS Fix main cycle at 10 times -- 2017.06.13 V1.012 FM Manage machining optimization -- 2017.06.13 V1.012 FM Fix bug on calculate box and row piece -- 2017.06.30 V1.013 FM Manage optimization and assignement of more paths to one machining -- 2017.11.17 V1.014 FM Add manage parameter dExtraThruDepth from CurrCamInfo for functions AdjustThrouIsle and AdjustVertHole -- 2018.02.26 V1.0b1 FM Manage piece dimension checking -- 2018.03.01 V1.0b2 FM use a table tMainTabPar instead of many variables ( more than 200 variables) -- 2018.03.22 V1.0b3 FM Manage checking effective lock/hinge side machining and adjust the second disposition. Before not recognize if -- lock/hinge side was machined or not in 1st phase -- 2018.03.23 V1.0b4 FM Manage parameter for probe extra Z position and adjust probe error values -- 2018.03.23 V1.0b4 FM Fix problem on second phase disposition by side path notes -- 2018.05.04 V1.0b5 FM Fix write 2nd phase disposition notes when first phase is empty and substitute by second phase -- 2018.05.09 V1.0b6 FM Fix error message on vacuums disposition -- 2018.05.09 V1.0b6 FM Calculate the solid box without extra surfaces -- 2018.06.18 V1.0b7 FM Manage door in probe mode and rebuilded -- 2018.06.22 V1.0b8 FM Manage second phase on rebuilded door and fix some bugs -- 2018.06.26 V1.0b9 FM Manage to use 2 bars with small width door -- 2018.06.27 V1.0c1 FM write note about number of probez geometries and if generate one of their machinings -- 2018.07.17 V1.0c2 FM Manage vacuum disposition: in case it uses only 2 bars use the vacuum for 3rd bar on 2nd bar -- 2018.07.24 V1.0d1 FM Read Properties (start managing properties) -- 2018.08.22 V1.0d2 FM Fix error on calculare roughing on bevel side profiles -- 2018.08.29 V1.0d3 FM Manage Arc Vacuum for top arc doors -- 2018.08.31 V1.0d4 ES Manage door with property 'narrowstile' (force door position like frame position, force to use smaller vacuum on 1st ad 3rd bars ) -- 2018.08.31 V1.0d5 ES Manage jamb position by parameter MachineJambsTogether from CurrCamInfo.lua -- 2018.10.17 V1.0d6 FM Fix error on Manage vacuum disposition: in case it uses only 2 bars use the vacuum for 3rd bar on 2nd bar -- 2019.01.10 V1.0d7 FM Manage assignement of dMinDistGroup variable from CurrCamInfo.lua file (by optional variable dMinDistBetweenBars) -- 2019.01.11 V1.0d8 FM Manage better group note Mach2nd to fix a problem of double machining (on 1st and 2nd phase) of same geometries into same group -- 2019.01.14 V1.0d9 FM Manage new CurrCamInfo parameter (nGenCncAsDdfName) to set -- which name use to generate the cnc file (by default as ddf file name) -- 2019.01.18 V1.0e1 FM Remove empty phase (after the first one) -- 2019.01.21 V1.0e2 FM if machine can work underneath (by bWorkUnder) and fail to machine thru drill, -- try to apply also the underneath machining (If present into Mtable) -- 2019.01.23 V1.0d8 FM Not generate machining on Group 0 (of MTable ordered table) and print warning message into repot files. -- 2019.01.31 V1.0d9 FM Move on CurrCamInfo file the vacuums data definition: point name on bars, name vacuum type, name vacuum type with lifter -- radius to apply on any type of vacuum -- 2019.02.01 V2.001 FM Change version by Egtcam5 new version -- 2019.02.01 V2.002 FM Manage 3 kind of vacuums for bar 1 and bar3 (on bar 2 only 1 type) -- 2019.02.01 V2.002 FM Rewrite function CalcDispositionSubPieces to manage better information of vacuums type (by use table of tables ttBaseDataVac) -- 2019.02.04 V2.003 FM Define version 2 to indentificate the new mode to calculate vacuums: Machining_3v2.lua -- 2019.02.04 V2.004 FM Manage new Egt function to calculate vacuums position (that use region defined into vacuum nge file) -- 2019.02.08 V2.005 FM Fix bug into CalcDispositionSubPieces when it's missing a vacuum lock point on nge machien table, and print a log message too -- 2019.02.18 V2.006 FM Manage better bar position and calculate better the bars position according by overmaterial -- 2019.02.19 V2.007 FM Manage check door/jamb dimension by function CheckPieceDimension -- 2019.02.25 V2.008 FM Fix error on calculation bar disposition and menage better into CheckPieceDimension by shift door values -- 2019.02.25 V2.008 FM Modify error messages format into CheckPieceDimension -- 2019.03.22 V2.009 FM Change % values of middle bar into function CheckEnoughVacuums -- 2019.03.27 V2.00a FM Manage estimate time -- 2019.03.29 V2.00b FM Manage Edge break (EB) and Bevel Edge break (BVEB) profiles -- 2019.04.08 V2.00c FM Manage Blade groove machinings with lead-in lead-out to reduce MTABLE lines -- Now it uses 1 line for antisplint blade and 1 line for normal blade -- 2019.04.08 V2.00c FM Manage Blade groove function AdjustBladeVertCurve -- 2019.04.11 V2.00d FM Manage special arc vacuum disposition as standard vacuum check (that use vacuum region) by function InsertSpecialSubPiece -- 2019.05.28 V2.00e FM Fix problem on update all machining after reorder, now use EgtApplyAllMachinings instead of EgtUpdateAllMachinings -- 2019.07.02 V2.00f FM Fix error on AdjustProbeHole section, if its machining is not present into MTable it cause the flip door on 2nd phase -- 2019.07.09 V2.010 FM On Vacuum disposition now it consider also the external rectangular region of bottom face into StartVacVerify, -- ExecVacVerify, ExecVacShapeVerify, EndVacVerify. it uses the new CurrCamInfo dSafetyDistVacSide and -- dArcSafetyDistVacSide variables to compare the vacuum distance to external side path -- 2019.07.09 V2.010 FM Disable re-calculate bars position on 2nd phase (and next phases) -- 2019.07.09 V2.010 FM On 1st Mtable scan modify the condition about shifted door, before it skip also by narrow style door (because it results shifted door), -- Now it skip olny shifted doors but not in case the door is narrow stile -- 2019.07.09 V2.010 FM Modify the % of not disposed vacuum on middle bar, now is 55%. -- When external bar have enough vacuums, the middle bar can accept less vacuums -- 2019.07.09 V2.010 FM Insert Arc Vacuum also in case on the bar is admitted only 1 vacuum type (arc vacuum is a special vacuum that has another code) -- 2019.07.17 V2.011 FM Add Tolerance on horizontal drill by GangDrill: add nProbeMode variable to AdjustHorizDrillX and AdjustHorizDrillY function call -- 2019.07.18 V2.012 FM Manage better the rare case to invert a single thru path (machining on top) if all others paths are machined in second phase -- and the opposite case ( a single thru path machine on bottom and all other paths machined fist phase). near line 2296 -- 2019.09.12 V2.013 FM Manage machine with 2 or more tables -- 2019.09.16 V2.014 FM Manage properties definition into CurrDoorCustomData (as DGC. variables), and his identification into Main, stop here. -- 2019.09.16 V2.014 FM Stop Manage properties definition into CurrDoorCustomData (as DGC. variables), and his identification into Main -- 2019.10.17 V2.015 FM New Managing of materials (steel) and properties -- 2019.10.17 V2.016 FM Add note into piece of table used -- 2019.10.24 V2.017 FM Add blind geometries (made by components) into blind group -- 2019.11.12 V2.018 FM Manage disposition of Top Chamfer shape by using 3 number code (1st for top rectangle, 2nd for top arc, 3rd for top angle) -- 2019.11.14 V2.014 FM Manage door resize machining, only on sides not at reference -- 2019.11.27 V2.015 FM Write new error message into log file if vacuum model are too old and without region (into ExecVacShapeVerify function) -- 2019.12.03 V2.016 FM Basic collision detection for underneath aggregate with references -- include Reference Disposition on table (it need references data into CurrCamInfo) -- 2020.06.05 V2.020 FM Manage aluminum doors and frame disposition on narrow side and wide side -- 2020.06.11 V2.021 FM Manage number pods on any bars by CurrCamInfo variable ( tMainTabPar.NTVR) -- 2020.06.25 V2.021 FM Check better if table is set right (and show error message when happen error) -- 2020.07.02 V2.022 FM Manage clamp subpieces with jambs ( only with single jamb on first bar) -- 2020.10.02 V2.023 FM Manage frame disposition head by new CurrCamInfo parameter FrameTopSideDriveDisp -- 2020.10.14 V2.024 FM Set Piece Type info for machine post pprocessor (mlpe) -- 2020.11.03 V2.025 FM Extend values of CurrCamInfo FrameTopSideDriveDisp parameter to customize the header (frame top) disposition -- 2021.04.06 V2.100 FM Now int ExecVacShapeVerify function it search double pod region (1st is standard region as before, 2nd one region is for blind geometries) -- The 2nd region is bigger than 1st region and could be equal or bigger than base pod area -- 2021.05.03 V2.101 FM Manage simulation in background to verify collisions, if something collide, not generate CNC program -- 2021.05.04 V2.102 FM Manage new CurrCamInfo parameter (nDisableAutoCncName) to disable the automatic cnc name composed when generate cnc by GENERATE button -- to have always the same cnc file name -- 2021.05.20 V2.103 FM Manage new CurrCamInfo parameter (EnableCollisionDetect) to enable/disable the collision detect -- 2021.05.24 V2.104 FM Add the CurrCamInfo machine name as a note -- 2021.07.23 V2.105 FM Fix error on not return to Machining.lua the variable nNumGroup -- 2021.10.28 V2.106 FM Fix internal error when calculate Box with STANDARD parameter, now it uses EXACT parameter -- 2021.11.23 V2.107 FM Manage option side probing. Expand function number of CurrDoorCustomData DGC.Pms: 3 side probe on all hardware (for NE machines) ; -- 4: side probe on all hardware except hardware on hinge side (for machines with shuttles) -- 2022.01.17 V2.108 FM Manage Split door cut by new CurrCamInfo parameter sCutDirectionAdmitted: = 'H' for cut along door Height; -- = 'W' for cut along door Width -- 2022.01.18 V2.109 FM Manage rectangle CutOut clean corners by cone tool on tilting aggregate and generate machine stop before execute these machinings -- 2022.05.03 V2.110 FM Use EgtNumToString function instead of tostring -- 2022.07.06 V2.111 FM Fix error ino machining section on not check if exists the new path nNewIdEnt -- 2022.11.15 V2.112 FM Manage side groove region as throu path and not as blind region -- 2022.07.27 V2.114 FM Modification to use compiled code -- 2023.01.20 V2.115 FM Manage vacuums with custom type number -- 2023.03.07 V2.116 FM Fix error on manage region into StartVacVerify function -- 2023.03.29 V2.117 FM Fix error on calculate rough paths on Convex profile -- 2023.03.31 V2.118 FM Manage offsetted path ( by path note) to extra path of Convex profile -- 2023.04.03 V2.119 FM Manage Scrap piece removing -- 2023.05.12 V2.120 FM Manage virtual milling option into collision avoid check -- 2023.05.24 V2.121 FM Manage by new function AdjustVertAsOnHeads to modify anti split paths (of door heads) to be vertical on bevelled sides -- 2023.05.26 V2.122 FM Manage new CurrCamInfo parameter ExportTableView to export 3d table view ( disposed door + table) with html format -- or export piece view with png format -- 2023.12.01 V2.123 FM Manage small planes on Convex profile -- 2024.03.11 V2.124 FM Add to piece the further info (from CurrCamInfo): dAltRef, dTallRef -- 2024.03.14 V2.125 FM Manage new CurrCamInfo parameter dMaxPosMobBar to check if 2nd bar position not go over than max value -- 2024.06.19 V2.126 FM Manage new DGD.GHT to let with suffix '_HIDE' ( or '_2HIDE' to manage the machining geometries on different machines (like Five lakes machines)) -- 2024.12.03 V2.127 FM Fix error on checking the machining BBox3d, now also add :isEmpty() -- 2024.12.20 V2.128 FM Change error numbers ( used into main.lua): 26 -> 34, 28 -> 35 -- Intestazioni require( 'EgtBase') _ENV = EgtProtectGlobal() EgtEnableDebug( false) local MachiningLoc = {} -- Librerie particolari local sBaseDir = DGD.BASEDIR -- EgtGetSourceDir() EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua') require( 'EgtDoorsBase') require( 'EgtDoorsData') local EgtDoorsMsg = require( 'EgtDoorsMsg') local MB = require( 'MachiningBase') -- Impostazioni Cam per consentire forature con utensile più piccolo EgtMdbSetGeneralParam( MCH_GP.HOLEDIAMTOLER, -50) EgtMdbSave() ----------------- SETTAGGI ------------------------------------------------- -- Definizione disposizione pezzi ( a sinistra : 1, a destra : -1) local DISPMODE = -1 -- Variabile distanza minima tra pezzo finito e ventosa (in X) local DIST_MIN_VAC = 5.5 -- variabile numero tavole utilizzate (al momento utilizzata solo per smistare differenti materiali di porta) local NUMTABLE = 1 ----------------- COSTANTI ------------------------------------------------- -- Definizione possibilità di lavorare sottosquadra nei profili bevel ( true: non lavora sottosquadra, false: possibile lavorare sottosquadra) local NO_WORK_UNDERSQUARE = false -- Definizione possibilità di lavorare soprasquadra nei profili bevel ( true: non lavora soprasquadra, false: possibile lavorare soprasquadra) local NO_WORK_UPSQUARE = true -- variabili genarazione lavorazioni local GEN_MACH = false local NOT_GEN_MACH = true ---------------- VARIABILI GLOBALI ----------------------------------------- -- variabili disposizione porta local bPush local bFlip local bNoVertProf = false -- true: for 5 axif head, leave not vertical path (like bevel) false: for 4 axis head, modify not vertical path to vertical local bWorkUnder = true ----------------------------------------------------------------- -- *** Error write file *** ----------------------------------------------------------------- local function WriteErrFile( sFileErr, sDispMsg) local nIdFile = io.open( sFileErr, 'w') if nIdFile then if DGD.ERR == 0 then if DGD.ERM and #DGD.ERM > 0 then nIdFile:write( 'Err=' .. EgtNumToString( DGD.ERR, 0) .. '\n' .. DGD.ERM) else nIdFile:write( 'Err=' .. EgtNumToString( DGD.ERR, 0)) end else if DGD.EMC and #DGD.EMC > 0 then nIdFile:write( 'Err=' .. EgtNumToString( DGD.ERR, 0) .. DGD.EMC) else nIdFile:write( 'Err=' .. EgtNumToString( DGD.ERR, 0)) end end if sDispMsg and #sDispMsg > 0 then nIdFile:write('\n' .. sDispMsg) end nIdFile:close() end end local function GetChoice() local sChoice = 'CB:' sChoice = sChoice .. '1 : Top on Right' .. ',' .. '2 : Top on Left' local sChose local tChose = EgtDialogBox( 'Set Header Disposition', { 'Header Top dispose on: ', sChoice }) if tChose then sChose = tChose[1] else return end if sChose then local PosComm = sChose:find('1', 1, true) if PosComm and PosComm == 1 then return true else return false end else return end end ----------------------------------------------------------------- -- *** calculate door disposition by parameters *** ----------------------------------------------------------------- local function CalcTopPosition( nTopSideDriveDisp, bAtRight, dTopRadius, dTopAngle, sFrameName) local bTopOnRight -- controllo se la variabile ha la tripla cifra if nTopSideDriveDisp and nTopSideDriveDisp > 100 then -- se porta ad angolo if dTopAngle then -- guardo la cifra meno significativa nTopSideDriveDisp = nTopSideDriveDisp - 100 if nTopSideDriveDisp > 100 then nTopSideDriveDisp = nTopSideDriveDisp - 100 end nTopSideDriveDisp = nTopSideDriveDisp - 10 if nTopSideDriveDisp > 10 then nTopSideDriveDisp = nTopSideDriveDisp - 10 end if nTopSideDriveDisp == 1 then bTopOnRight = true else bTopOnRight = false end elseif dTopRadius then -- altrimenti se è una porta ad arco -- guardo la seconda cifra meno significativa nTopSideDriveDisp = nTopSideDriveDisp - 100 if nTopSideDriveDisp > 100 then nTopSideDriveDisp = nTopSideDriveDisp - 100 end if nTopSideDriveDisp >= 20 then bTopOnRight = false else bTopOnRight = true end else -- altrimenti è rettangolare if nTopSideDriveDisp >= 200 then bTopOnRight = false else bTopOnRight = true end end -- controllo se la variabile ha la doppia cifra elseif nTopSideDriveDisp and nTopSideDriveDisp > 10 then -- se porta ad arco o ad angolo if dTopRadius or dTopAngle then -- guardo la cifra meno significativa nTopSideDriveDisp = nTopSideDriveDisp - 10 if nTopSideDriveDisp > 10 then nTopSideDriveDisp = nTopSideDriveDisp - 10 end if nTopSideDriveDisp == 1 then bTopOnRight = true else bTopOnRight = false end else -- altrimenti porta rettangolare -- Nel caso della disposizione frame, se è il frame top (header) e ho la cifra più significativa == 1 ( quindi valori 11 o 12) -- allora lancio una richiesta di input all'utente. -- Se frame top e parametro coerende con disposizione personalizzata if sFrameName == 'frametop' and nTopSideDriveDisp >= 10 and nTopSideDriveDisp < 20 then -- lancio richiesta input utente bTopOnRight = GetChoice() -- se restituisce nill, scelgo il vecchio metodo if bTopOnRight == nil then if bAtRight then -- se serratura a destra bTopOnRight = true else bTopOnRight = false end end elseif nTopSideDriveDisp >= 20 then -- altrimenti se non è un frame mi baso sulla cifra più significativa -- guardo la cifra più significativa if nTopSideDriveDisp >= 20 then bTopOnRight = false else bTopOnRight = true end -- negli altri casi considero la cifra meno significatica else -- riduco ad una sola cifra repeat if nTopSideDriveDisp >= 10 then nTopSideDriveDisp = nTopSideDriveDisp -10 end until nTopSideDriveDisp < 10 if nTopSideDriveDisp == 2 then bTopOnRight = false else bTopOnRight = true end end end -- ha cifra singola: non si fanno distinzioni tra porte ad arco o ad angolo o normali elseif nTopSideDriveDisp then if nTopSideDriveDisp == 1 then bTopOnRight = true else bTopOnRight = false end else if bAtRight then -- se serratura a destra bTopOnRight = true else bTopOnRight = false end end return bTopOnRight end ----------------------------------------------------------------- -- *** Add Machining in table for second part *** ----------------------------------------------------------------- local function AddMachIntable( MTMachLine, tSecMcng, nIndexTab) if tSecMcng then if #tSecMcng > 0 then local bFound = false MTMachLine.Row = nIndexTab for k = 1, #tSecMcng do if MTMachLine == tSecMcng[k] then bFound = true end end -- se non trovato lo inserisco if not bFound then table.insert( tSecMcng,MTMachLine) end else MTMachLine.Row = nIndexTab table.insert( tSecMcng,MTMachLine) end end return tSecMcng end ----------------------------------------------------------------- -- *** Vacuums disposition *** ----------------------------------------------------------------- local ThroughId, BlindId, FaceDwId ----------------------------------------------------------------- local function StartVacVerify( nIdSolid, bFlipped, nProbeMode, dThDoor, bFlipFrame) -- regioni passante e cieca non definite EgtErase( ThroughId or GDB_ID.NULL) ThroughId = nil EgtErase( BlindId or GDB_ID.NULL) BlindId = nil EgtErase( FaceDwId or GDB_ID.NULL) FaceDwId = nil -- recupero le regioni sopra e sotto della porta messa in macchina local UpId, DwId local UpId2, DwId2 local DwIdExtraBlind = {} local sExtraBlindRegName local DwIdExtraGrvBlind = {} local sExtraGrvBlindRegName local dZedToMove -- se porta ribaltata if bFlipped or bFlipFrame then if nProbeMode == 2 then -- superficie a contatto con le ventose DwId = MB.FindGeomWithName( nIdSolid, 'FLAT_UP', true) -- superficie sopra UpId = MB.FindGeomWithName( nIdSolid, 'FLAT_DW', true) -- superficie a contatto con le ventose DwId2 = MB.FindGeomWithName( nIdSolid, 'FLAT_UP_2', true) -- superficie sopra UpId2 = MB.FindGeomWithName( nIdSolid, 'FLAT_DW_2', true) else -- superficie a contatto con le ventose DwId = MB.FindGeomWithName( nIdSolid, 'FLAT_UP', true) -- superficie sopra UpId = MB.FindGeomWithName( nIdSolid, 'FLAT_DW', true) end sExtraBlindRegName = 'FLAT_UP_BLIND' DwIdExtraBlind = MB.FindGeomWithName( nIdSolid, sExtraBlindRegName, false) sExtraGrvBlindRegName = 'FLAT_UP_SD_BLIND' DwIdExtraGrvBlind = MB.FindGeomWithName( nIdSolid, sExtraGrvBlindRegName, false) dZedToMove = dThDoor else if nProbeMode == 2 then -- superficie a contatto con le ventose DwId = MB.FindGeomWithName( nIdSolid, 'FLAT_DW', true) -- superficie sopra UpId = MB.FindGeomWithName( nIdSolid, 'FLAT_UP', true) -- superficie a contatto con le ventose DwId2 = MB.FindGeomWithName( nIdSolid, 'FLAT_DW_2', true) -- superficie sopra UpId2 = MB.FindGeomWithName( nIdSolid, 'FLAT_UP_2', true) else -- superficie a contatto con le ventose DwId = MB.FindGeomWithName( nIdSolid, 'FLAT_DW', true) -- superficie sopra UpId = MB.FindGeomWithName( nIdSolid, 'FLAT_UP', true) end sExtraBlindRegName = 'FLAT_DW_BLIND' DwIdExtraBlind = MB.FindGeomWithName( nIdSolid, sExtraBlindRegName, false) sExtraGrvBlindRegName = 'FLAT_DW_SD_BLIND' DwIdExtraGrvBlind = MB.FindGeomWithName( nIdSolid, sExtraGrvBlindRegName, false) dZedToMove = 0 end -- creo le regioni complementari local CompUpId if nProbeMode == 2 then local nRecId = EgtGetFirstNameInGroup( Pz, 'REC') local nCurveId = EgtExtractSurfFrChunkLoops( UpId2, 0, nRecId) -- prendo il contorno della regione piena CompUpId = EgtSurfFlatRegion( nIdSolid, nCurveId) -- creo regione rettangolare piena else local b3Up = EgtGetBBoxGlob( UpId, GDB_BB.EXACT) CompUpId = EgtSurfFrRectangle( nIdSolid, b3Up:getMin(), b3Up:getMax(), GDB_RT.GLOB) -- creo regione rettangolare piena end local vtNUp = EgtSurfFrNormVersor( UpId, GDB_ID.ROOT) local vtNCompUp = EgtSurfFrNormVersor( CompUpId, GDB_ID.ROOT) if not AreSameVectorApprox( vtNUp, vtNCompUp) then EgtInvertSurf( CompUpId) end EgtSurfFrSubtract( CompUpId, UpId) if not EgtExistsObj( CompUpId) then CompUpId = nil end local CompDwId if nProbeMode == 2 then local nRecId = EgtGetFirstNameInGroup( Pz, 'REC') local nCurveId = EgtExtractSurfFrChunkLoops( DwId2, 0, nRecId) CompDwId = EgtSurfFlatRegion( nIdSolid, nCurveId) else local b3Dw = EgtGetBBoxGlob( DwId, GDB_BB.EXACT) CompDwId = EgtSurfFrRectangle( nIdSolid, b3Dw:getMin(), b3Dw:getMax(), GDB_RT.GLOB) end -- faccio una copia per gli altri controlli local DownRegId = nil if CompDwId then DownRegId = EgtCopyGlob( CompDwId, nIdSolid) EgtInvertSurf( DownRegId) end local vtNDw = EgtSurfFrNormVersor( DwId, GDB_ID.ROOT) local vtNCompDw = EgtSurfFrNormVersor( CompDwId, GDB_ID.ROOT) if not AreSameVectorApprox( vtNDw, vtNCompDw) then EgtInvertSurf( CompDwId) end EgtSurfFrSubtract( CompDwId, DwId) if not EgtExistsObj( CompDwId) then CompDwId = nil end if CompDwId then EgtInvertSurf( CompDwId) end -- calcolo le regioni passante e cieca e contorno local ThroughRegId = nil local BlindRegId = nil -- se ci sono entrambe le regioni if CompUpId and CompDwId then -- per ottenere la regione passante faccio intersezione tra sopra e sotto EgtSurfFrIntersect( CompUpId, CompDwId) if EgtExistsObj( CompUpId) then ThroughRegId = CompUpId end -- per ottenere la regione cieca faccio differenza tra sotto e passante if ThroughRegId then EgtSurfFrSubtract( CompDwId, ThroughRegId) if EgtExistsObj( CompDwId) then BlindRegId = CompDwId end else BlindRegId = CompDwId end -- se c'è solo la regione sotto è già quella delle lavorazioni cieche elseif CompDwId then BlindRegId = CompDwId -- se c'è solo la sopra, non interessa e la cancello elseif CompUpId then EgtErase( CompUpId) end -- sistemazioni finali if ThroughRegId or #DwIdExtraGrvBlind > 0 then ThroughId = EgtGroup( GDB_ID.ROOT) EgtSetName( ThroughId, 'THROUGH') EgtSetColor( ThroughId, RED()) EgtSetLevel( ThroughId, GDB_LV.TEMP) local nChunk = 0 if ThroughRegId then while EgtExtractSurfFrChunkLoops( ThroughRegId, nChunk, ThroughId) do nChunk = nChunk + 1 end end -- aggiungo le regioni extra presenti (calcolate dai singoli componenti) for l = 1, #DwIdExtraGrvBlind do local nIdBl = DwIdExtraGrvBlind[l] if nIdBl then -- faccio la copia e la muovo alla Z bassa local nTempBlndReg = EgtCopyGlob ( nIdBl, nIdSolid) if nTempBlndReg then -- prendo il punto iniziale local pCenTmp = EgtCP( nTempBlndReg) if pCenTmp then EgtMove( nTempBlndReg, Point3d(0,0,dZedToMove) - Point3d(0,0,pCenTmp:getZ())) end -- estraggo i contorni e li aggiungo al gruppo blind nChunk = 0 while EgtExtractSurfFrChunkLoops( nTempBlndReg, nChunk, ThroughId) do nChunk = nChunk + 1 end -- cancello la copia locale EgtErase( nTempBlndReg) end end end EgtErase( ThroughRegId) --EgtSetName( ThroughRegId, 'THROUGH') --EgtSetColor( ThroughRegId, RED()) --EgtSetLevel( ThroughRegId, GDB_LV.TEMP) end if BlindRegId or #DwIdExtraBlind > 0 then BlindId = EgtGroup( GDB_ID.ROOT) EgtSetName( BlindId, 'BLIND') EgtSetColor( BlindId, BLUE()) EgtSetLevel( BlindId, GDB_LV.TEMP) local nChunk = 0 if BlindRegId then while EgtExtractSurfFrChunkLoops( BlindRegId, nChunk, BlindId) do nChunk = nChunk + 1 end end -- aggiungo le regioni extra presenti (calcolate dai singoli componenti) for l = 1, #DwIdExtraBlind do local nIdBl = DwIdExtraBlind[l] if nIdBl then -- faccio la copia e la muovo alla Z bassa local nTempBlndReg = EgtCopyGlob ( nIdBl, nIdSolid) if nTempBlndReg then -- prendo il punto iniziale local pCenTmp = EgtCP( nTempBlndReg) if pCenTmp then EgtMove( nTempBlndReg, Point3d(0,0,dZedToMove) - Point3d(0,0,pCenTmp:getZ())) end -- estraggo i contorni e li aggiungo al gruppo blind nChunk = 0 while EgtExtractSurfFrChunkLoops( nTempBlndReg, nChunk, BlindId) do nChunk = nChunk + 1 end -- cancello la copia locale EgtErase( nTempBlndReg) end end end if BlindRegId then EgtErase( BlindRegId) --EgtSetName( BlindRegId, 'BLIND') --EgtSetColor( BlindRegId, BLUE()) --EgtSetLevel( BlindRegId, GDB_LV.TEMP) end end if DownRegId then FaceDwId = EgtGroup( GDB_ID.ROOT) EgtSetName( FaceDwId, 'DWREG') EgtSetColor( FaceDwId, BLUE()) EgtSetLevel( FaceDwId, GDB_LV.TEMP) local nChunk = 0 while EgtExtractSurfFrChunkLoops( DownRegId, nChunk, FaceDwId) do nChunk = nChunk + 1 end EgtErase( DownRegId) --EgtSetName( DownRegId, 'DWREG') --EgtSetColor( DownRegId, GREEN()) --EgtSetLevel( DownRegId, GDB_LV.TEMP) end end ----------------------------------------------------------------- local function GetBoxViseRegion( nIdVise, sRegName) local nShapeId local nShapeMoveId local nAreaId local nAreaMoveId local tViseArea = {} if nIdVise then -- cerco l'id della geometria shape nAreaId = EgtGetFirstNameInGroup( nIdVise, 'BASE') nAreaMoveId = EgtGetFirstNameInGroup( nIdVise, 'MOBILE') if nAreaId then -- cerco il nome della regione nShapeId = EgtGetFirstNameInGroup( nAreaId, sRegName) end if nAreaMoveId then -- cerco il nome della regione nShapeMoveId = EgtGetFirstNameInGroup( nAreaMoveId, sRegName) end -- se ho le regioni provo a verificare if nShapeId and nShapeMoveId then local bBoxReg = EgtGetBBoxGlob ( nShapeId, GDB_BB.EXACT) table.insert( tViseArea, bBoxReg) bBoxReg = EgtGetBBoxGlob ( nShapeMoveId, GDB_BB.EXACT) table.insert( tViseArea, bBoxReg) end end return tViseArea end ----------------------------------------------------------------- local function VerifyIntersXYZ( bRefBox, bMachBox, dDeltaBody, bCheckZ) local bNoCollisionX local bNoCollisionY local bNoCollisionZ -- prendo punti box della lavorazione e del pezzo (riferimento/morsa) local pMinMach = bMachBox:getMin() local pMaxMach = bMachBox:getMax() local pMinRef = bRefBox:getMin() local pMaxRef = bRefBox:getMax() -- verifico collisioni if ( pMinRef:getX() - dDeltaBody > pMaxMach:getX()) or ( pMaxRef:getX() + dDeltaBody < pMinMach:getX()) then -- se non toccano in x bNoCollisionX = true else bNoCollisionX = false end if ( pMaxRef:getY() + dDeltaBody < pMinMach:getY()) or ( pMinRef:getY() - dDeltaBody > pMaxMach:getY()) then -- se non si toccano in y bNoCollisionY = true else bNoCollisionY = false end if bCheckZ then if ( pMinMach:getZ() - dDeltaBody) > pMaxRef:getZ() then -- se non toccano in z bNoCollisionZ = true else bNoCollisionZ = false end end return bNoCollisionX, bNoCollisionY, bNoCollisionZ end ----------------------------------------------------------------- local function RemoveSubPieceAtPos( sRawDisp, nPos, nNumPieceOnBar, DISPMODE, nNumChar) local sNewRow = '' local nNumTotChar = nNumPieceOnBar * nNumChar if #sRawDisp == nNumTotChar then -- se non in prima posizione compongo la parte iniziale if nPos > 1 then sNewRow = sNewRow .. string.sub ( sRawDisp, 1 , ( ( nPos * nNumChar) - nNumChar )) end -- aggiungo la posizione vuota sNewRow = sNewRow .. '0_' -- se non in ultima posizione compongo la parte finale if nPos < nNumPieceOnBar then sNewRow = sNewRow .. string.sub ( sRawDisp, ( ( nPos * nNumChar) + 1 )) end else sNewRow = sRawDisp end return sNewRow end ----------------------------------------------------------------- local function ReduceViseNumber( tIdViseDisp, nMinViseNumber, Pz, nNumPhase, DISPMODE, nNumPieceOnBar, sRawDisp, nNumChar) -- calcolo le distanze tra le ventose local nTotNumVise = #tIdViseDisp local nLastVise = tIdViseDisp[nTotNumVise][2] local nFirstVise = tIdViseDisp[1][2] local tDeleteVise = {} -- posizione intermedia tra le posizioni occupate local dMiddleDist = ( nFirstVise + nLastVise) / 2 local nMiddlePos = 0 local dMinDistance = 15 -- ciclo sulla tabella per trovare la posizione più vicina alla posizione media for i = 2, ( nTotNumVise -1) do local nPosLoc = tIdViseDisp[i][2] local nDist = abs( dMiddleDist - nPosLoc) if nDist < dMinDistance then dMinDistance = nDist nMiddlePos = i end end -- se trovata una posizione if nMiddlePos > 0 then -- ciclo per eliminare tutte le posizioni tranne (gli estremi) e la candidata for i = 2, ( nTotNumVise -1) do local nPosLoc = tIdViseDisp[i][2] if i ~= nMiddlePos then -- rimuovo la morsa dalla disposizione e anche nella tabella EgtRemoveFixture( tIdViseDisp[i][1]) table.insert( tDeleteVise, i) -- rimuovo la posizione dalla stringa delle posizioni sRawDisp = RemoveSubPieceAtPos( sRawDisp, tIdViseDisp[i][2], nNumPieceOnBar, DISPMODE, nNumChar) -- se stringa valida riscrivo la nota corretta if #sRawDisp > 0 then EgtSetInfo( Pz, 'FixVacRow_Phase_'..EgtNumToString( nNumPhase, 0), sRawDisp) end end end end -- cancello dalla tabella le morse eliminate for i = #tDeleteVise, 1, -1 do table.remove( tIdViseDisp, tDeleteVise[i]) end return sRawDisp end ----------------------------------------------------------------- local function VerifyViseCollision( tIdViseDisp, bMachBox, Pz, nNumPhase, DISPMODE, nNumPieceOnBar, sRawDisp, nNumChar) if tIdViseDisp and #tIdViseDisp > 0 then local tDeleteVise = {} for i = 1, #tIdViseDisp do local bOkCollision = true -- prendo gli ingombri delle regioni esterne e più in alto della morsa local tViseArea = GetBoxViseRegion( tIdViseDisp[i][1], 'REG_UP') if tViseArea then for j = 1, #tViseArea do -- verifico se c'è possibile collisione in X e/o Y local bNoCollisionX, bNoCollisionY, bNoCollisionZ = VerifyIntersXYZ( tViseArea[j], bMachBox, 1, true) -- controllo se c'è solo collisione in Y bOkCollision = bOkCollision and ( bNoCollisionX or bNoCollisionY or ( bNoCollisionX and bNoCollisionY and bNoCollisionZ)) end -- Se ho collisione rimuovo la morsa if not bOkCollision then -- ottengo la posizione della morsa local nPos = tIdViseDisp[i][2] -- rimuovo la morsa dalla disposizione e anche nella tabella EgtRemoveFixture( tIdViseDisp[i][1]) table.insert( tDeleteVise, i) -- rimuovo la posizione dalla stringa delle posizioni sRawDisp = RemoveSubPieceAtPos( sRawDisp, nPos, nNumPieceOnBar, DISPMODE, nNumChar) -- se stringa valida riscrivo la nota corretta if #sRawDisp > 0 then EgtSetInfo( Pz, 'FixVacRow_Phase_'..EgtNumToString( nNumPhase, 0), sRawDisp) end end end -- se non ho rimosso la morsa if bOkCollision then -- prendo gli ingombri delle regioni interne e più basse della morsa tViseArea = {} tViseArea = GetBoxViseRegion( tIdViseDisp[i][1], 'REG_0') if tViseArea then for j = 1, #tViseArea do -- verifico se c'è possibile collisione in X e/o Y local bNoCollisionX, bNoCollisionY, bNoCollisionZ = VerifyIntersXYZ( tViseArea[j], bMachBox, 1, true) -- controllo se c'è solo collisione in Y bOkCollision = bOkCollision and ( bNoCollisionX or bNoCollisionY or ( bNoCollisionX and bNoCollisionY and bNoCollisionZ)) end -- Se ho collisione rimuovo la morsa if not bOkCollision then -- ottengo la posizione della morsa local nPos = tIdViseDisp[i][2] -- rimuovo la morsa dalla disposizione e anche nella tabella EgtRemoveFixture( tIdViseDisp[i][1]) table.insert( tDeleteVise, i) -- rimuovo la posizione dalla stringa delle posizioni sRawDisp = RemoveSubPieceAtPos( sRawDisp, nPos, nNumPieceOnBar, DISPMODE, nNumChar) -- se stringa valida riscrivo la nota corretta if #sRawDisp > 0 then EgtSetInfo( Pz, 'FixVacRow_Phase_'..EgtNumToString( nNumPhase, 0), sRawDisp) end end end end end -- cancello dalla tabella le morse eliminate for i = #tDeleteVise, 1, -1 do table.remove( tIdViseDisp, tDeleteVise[i]) end end return sRawDisp end ----------------------------------------------------------------- local function VerifyRowCollision( tRefBox, bMachBox) local bOkCollisionX = true local bOkCollisionY = true local bOkCollision = true local dDeltaBody = 40 -- devono esserci almeno un box di un riferimento e il box lavorazione if ( tRefBox.ref1 or tRefBox.ref2 or tRefBox.ref3 or tRefBox.ref4) and bMachBox then if tRefBox.ref1 then bOkCollisionX, bOkCollisionY = VerifyIntersXYZ( tRefBox.ref1, bMachBox, dDeltaBody) bOkCollision = bOkCollision and ( bOkCollisionX or bOkCollisionY) end if tRefBox.ref2 then bOkCollisionX, bOkCollisionY = VerifyIntersXYZ( tRefBox.ref2, bMachBox, dDeltaBody) bOkCollision = bOkCollision and ( bOkCollisionX or bOkCollisionY) end if tRefBox.ref3 then bOkCollisionX, bOkCollisionY = VerifyIntersXYZ( tRefBox.ref3, bMachBox, dDeltaBody) bOkCollision = bOkCollision and ( bOkCollisionX or bOkCollisionY) end if tRefBox.ref4 then bOkCollisionX, bOkCollisionY = VerifyIntersXYZ( tRefBox.ref4, bMachBox, dDeltaBody) bOkCollision = bOkCollision and ( bOkCollisionX or bOkCollisionY) end end return bOkCollision end ----------------------------------------------------------------- local function FindRefInTable( nTab, sParzName) local tRefList = MB.FindGroupWithPartName( nTab, sParzName) local bBoxRef local tBoxRef = {} local tFoundRef = {} if tRefList then for i = 1, #tRefList do local sNameEnt = EgtGetName(tRefList[i]) local sNumRef = string.sub( sNameEnt, #sNameEnt) -- trasformo in numero local nLocNumRef = tonumber(sNumRef) if nLocNumRef == 1 then tFoundRef.r1 = tRefList[i] elseif nLocNumRef == 2 then tFoundRef.r2 = tRefList[i] elseif nLocNumRef == 3 then tFoundRef.r3 = tRefList[i] elseif nLocNumRef == 4 then tFoundRef.r4 = tRefList[i] end end if tFoundRef.r1 or tFoundRef.r2 or tFoundRef.r3 or tFoundRef.r4 then local nRefId if tFoundRef.r1 then -- ottengo il sottogruppo ref nRefId = EgtGetFirstNameInGroup( tFoundRef.r1, 'BASE2') if nRefId then tBoxRef.ref1 = EgtGetBBoxGlob ( nRefId, GDB_BB.EXACT) end end if tFoundRef.r2 then -- ottengo il sottogruppo ref nRefId = EgtGetFirstNameInGroup( tFoundRef.r2, 'BASE2') if nRefId then tBoxRef.ref2 = EgtGetBBoxGlob ( nRefId, GDB_BB.EXACT) end end if tFoundRef.r3 then -- ottengo il sottogruppo ref nRefId = EgtGetFirstNameInGroup( tFoundRef.r3, 'BASE2') if nRefId then tBoxRef.ref3 = EgtGetBBoxGlob ( nRefId, GDB_BB.EXACT) end end if tFoundRef.r4 then -- ottengo il sottogruppo ref nRefId = EgtGetFirstNameInGroup( tFoundRef.r4, 'BASE2') if nRefId then tBoxRef.ref4 = EgtGetBBoxGlob ( nRefId, GDB_BB.EXACT) end end end end return tBoxRef end ----------------------------------------------------------------- local function ExecVacVerify( ptVac, dDistVac) -- This function is not more used, now it uses ExecVacShapeVerify -- verifica con le regioni passanti local nId = EgtGetFirstInGroup( ThroughId or GDB_ID.NULL) while nId do local ptNear = EgtNP( nId, ptVac, GDB_ID.ROOT) if ptNear then local dDist = sqrt( ( ptNear[1] - ptVac[1]) * ( ptNear[1] - ptVac[1]) + ( ptNear[2] - ptVac[2]) * ( ptNear[2] - ptVac[2])) -- se distanza inferiore al limite ... if dDist < dDistVac + 15 then return false end end nId = EgtGetNext( nId) end -- verifica con le regioni cieche nId = EgtGetFirstInGroup( BlindId or GDB_ID.NULL) while nId do local ptNear = EgtNP( nId, ptVac, GDB_ID.ROOT) if ptNear then local dDist = sqrt( ( ptNear[1] - ptVac[1]) * ( ptNear[1] - ptVac[1]) + ( ptNear[2] - ptVac[2]) * ( ptNear[2] - ptVac[2])) -- se distanza inferiore al limite ... if dDist < dDistVac + 45 then return false end end nId = EgtGetNext( nId) end -- verifica con il contorno esterno inferiore nId = EgtGetFirstInGroup( FaceDwId or GDB_ID.NULL) while nId do local ptNear = EgtNP( nId, ptVac, GDB_ID.ROOT) if ptNear then local dDist = sqrt( ( ptNear[1] - ptVac[1]) * ( ptNear[1] - ptVac[1]) + ( ptNear[2] - ptVac[2]) * ( ptNear[2] - ptVac[2])) -- se distanza inferiore al contorno + una piccola distanza if dDist < dDistVac + 1 then return false end end nId = EgtGetNext( nId) end -- nessuna interferenza return true end ----------------------------------------------------------------- local function ExecViseShapeVerify( ptVac, sNameVac, tabOri, dDistThru, dDistBlind, dDistCont, dRotVal, dMove2) local nShapeId local nShapeMoveId local nAreaId local nAreaMoveId local nRetErr = 0 -- inserisco la ventosa e ne ottengo l'id local nFixVac = EgtAddFixture( sNameVac, ( ptVac - tabOri), dRotVal, dMove2) --debug -- EgtSaveFile() -- EgtMove(DGD.PZ, Point3d(0,0,nil) - ORIG()) if nFixVac then -- cerco l'id della geometria shape nAreaId = EgtGetFirstNameInGroup( nFixVac, 'BASE') nAreaMoveId = EgtGetFirstNameInGroup( nFixVac, 'MOBILE') if nAreaId then -- cerco il nome della regione nShapeId = EgtGetFirstNameInGroup( nAreaId, 'REG_UP') else if nFixVac then -- se inserita ventosa la rimuovo EgtRemoveFixture( nFixVac) end nRetErr = 1 return false, nRetErr end if nAreaMoveId then -- cerco il nome della regione nShapeMoveId = EgtGetFirstNameInGroup( nAreaMoveId, 'REG_UP') else if nFixVac then -- se inserita ventosa la rimuovo EgtRemoveFixture( nFixVac) end nRetErr = 1 return false, nRetErr end end -- se ho le regioni provo a verificare if nShapeId and nShapeMoveId then -- verifica se regione ventosa interferisce con le regioni passanti local nId = EgtGetFirstInGroup( ThroughId or GDB_ID.NULL) -- EgtSaveFile() while nId do local bDistBtwRegion = not EgtSurfFrTestExternal( nShapeId, nId, dDistThru) local bDistBtwRegionM = not EgtSurfFrTestExternal( nShapeMoveId, nId, dDistThru) if bDistBtwRegion or bDistBtwRegionM then -- se interferisce cancello ventosa ed esco EgtRemoveFixture( nFixVac) return false, nRetErr end nId = EgtGetNext( nId) end -- verifica se regione ventosa interferisce con le regioni cieche nId = EgtGetFirstInGroup( BlindId or GDB_ID.NULL) while nId do local bDistBtwRegion = not EgtSurfFrTestExternal( nShapeId, nId, dDistBlind) local bDistBtwRegionM = not EgtSurfFrTestExternal( nShapeMoveId, nId, dDistBlind) if bDistBtwRegion or bDistBtwRegionM then -- se interferisce cancello ventosa ed esco EgtRemoveFixture( nFixVac) return false, nRetErr, true end nId = EgtGetNext( nId) end -- verifica se regione ventosa interferisce con le regioni contorno nId = EgtGetFirstInGroup( FaceDwId or GDB_ID.NULL) while nId do local bDistBtwRegion = not EgtSurfFrTestExternal( nShapeId, nId, dDistCont) local bDistBtwRegionM = not EgtSurfFrTestExternal( nShapeMoveId, nId, dDistCont) if bDistBtwRegion or bDistBtwRegionM then -- se interferisce cancello ventosa ed esco EgtRemoveFixture( nFixVac) return false, nRetErr end nId = EgtGetNext( nId) end else -- regione non trovata if nFixVac then -- se inserita ventosa la rimuovo EgtRemoveFixture( nFixVac) end nRetErr = 2 return false, nRetErr end -- nessuna interferenza if nFixVac then -- se inserita ventosa la rimuovo EgtRemoveFixture( nFixVac) end return true, nRetErr end ----------------------------------------------------------------- local function ExecVacShapeVerify( ptVac, sNameVac, tabOri, dDistThru, dDistBlind, dDistCont, bCodeMobileVac, dRotVal, dMove2) local nShapeId local nShapeBlindId local nAreaId local dMoveLoc = EgtIf( bCodeMobileVac, dMove2, 0) local dRotLoc = EgtIf( bCodeMobileVac, dRotVal, 0) local dMaxMov = 0 local nRetErr = 0 local nCustomType -- inserisco la ventosa e ne ottengo l'id local nFixVac = EgtAddFixture( sNameVac, ( ptVac - tabOri), dRotLoc, dMoveLoc) if nFixVac then -- cerco l'id della geometria shape if bCodeMobileVac then nAreaId = EgtGetFirstNameInGroup( nFixVac, 'MOBILE') else nAreaId = EgtGetFirstNameInGroup( nFixVac, 'AREA') end -- leggo la nota del typo custom nCustomType = EgtGetInfo( nFixVac, 'CustomType', 'i') if nAreaId then if bCodeMobileVac then -- se mobile leggo la nota di movimento massimo dMaxMov = EgtGetInfo( nAreaId, 'MAXMOV', 'd') or 0 end -- cerco il nome della regione nShapeId = EgtGetFirstNameInGroup( nAreaId, 'SHAPE') -- cerco il nome della regione dedicata alle geometrie cieche nShapeBlindId = EgtGetFirstNameInGroup( nAreaId, 'SHAPE_BL') -- se non ho la doppia regione prendo l'unica if nShapeId and not nShapeBlindId then nShapeBlindId = nShapeId end else if nFixVac then -- se inserita ventosa la rimuovo EgtRemoveFixture( nFixVac) end nRetErr = 1 return false, nRetErr end end -- se ho la regione provo a verificare if nShapeId then -- se ventosa mobile controllo se la distanza di movimento è superiore a quella ammessa if bCodeMobileVac and dMoveLoc > dMaxMov then EgtRemoveFixture( nFixVac) return false, nRetErr end -- verifica se regione ventosa interferisce con le regioni passanti local nId = EgtGetFirstInGroup( ThroughId or GDB_ID.NULL) -- EgtSaveFile() while nId do local bDistBtwRegion = not EgtSurfFrTestExternal( nShapeId, nId, dDistThru) if bDistBtwRegion then -- se interferisce cancello ventosa ed esco EgtRemoveFixture( nFixVac) return false, nRetErr end nId = EgtGetNext( nId) end -- verifica se regione ventosa interferisce con le regioni cieche nId = EgtGetFirstInGroup( BlindId or GDB_ID.NULL) while nId do local bDistBtwRegion = not EgtSurfFrTestExternal( nShapeBlindId, nId, dDistBlind) if bDistBtwRegion then -- se interferisce cancello ventosa ed esco EgtRemoveFixture( nFixVac) return false, nRetErr, true end nId = EgtGetNext( nId) end -- verifica se regione ventosa interferisce con le regioni contorno nId = EgtGetFirstInGroup( FaceDwId or GDB_ID.NULL) while nId do local bDistBtwRegion = not EgtSurfFrTestExternal( nShapeId, nId, dDistCont) if bDistBtwRegion then -- se interferisce cancello ventosa ed esco EgtRemoveFixture( nFixVac) return false, nRetErr end nId = EgtGetNext( nId) end else -- regione non trovata if nFixVac then -- se inserita ventosa la rimuovo EgtRemoveFixture( nFixVac) end nRetErr = 2 return false, nRetErr end -- nessuna interferenza if nFixVac then -- se inserita ventosa la rimuovo EgtRemoveFixture( nFixVac) end return true, nRetErr, nil, nCustomType end ----------------------------------------------------------------- local function EndVacVerify() -- cancello regioni passante e cieca EgtErase( ThroughId or GDB_ID.NULL) ThroughId = nil EgtErase( BlindId or GDB_ID.NULL) BlindId = nil EgtErase( FaceDwId or GDB_ID.NULL) FaceDwId = nil end -------------------------------------------------------------------------------- -- * Abilitazione/disabilitazione geometrie * local function ShowHideGeom( nGroupId, sName, dVal) local nId = EgtGetFirstNameInGroup( nGroupId, sName) if nId then local dOldVal = EgtGetInfo( nId, 'Val', 'd') or 0.1 if dVal ~= dOldVal then if dVal > 0.5 then EgtSetStatus( nId, GDB_ST.ON) else EgtSetStatus( nId, GDB_ST.OFF) end EgtSetInfo( nId, 'Val', dVal) end end end local function SetInfoTable( tListEnt, sNameInfo, nValInfo) for j = 1, #tListEnt do if tListEnt[j] then EgtSetInfo( tListEnt[j], sNameInfo, nValInfo) end end end local function CheckExtSideMach( tListEnt) local sEdgeNote for j = 1, #tListEnt do if tListEnt[j] then sEdgeNote = EgtGetInfo( tListEnt[j], 'EdgeDoor') or '' if sEdgeNote == 'T' then -- se lavorato lato top DGD.MTS = 1 elseif sEdgeNote == 'B' then -- se lavorato lato bottom DGD.MBS = 1 elseif sEdgeNote == 'H' then -- se lavorato lato hinge DGD.MHS = 1 elseif sEdgeNote == 'L' then -- se lavorato lato lock DGD.MLS = 1 end end end end ----------------------------------------------------------------- -- *** Apply Machining by Mach number *** ----------------------------------------------------------------- local function InsertMachiningByMachNum ( tEndId, nMach, sLocName, nNumGroup, sMach, sMachUp, sMachDw, bOk, nNumMach, bModifyMacNote, bNotGenMachining, tMachining, dBladePerpLeadIn, dPercRedFeed, bCalMach) local dOverL = EgtGetInfo( tEndId[1], 'OL') local dOverR = EgtGetInfo( tEndId[1], 'OFFSTOPATH', 'd') local sKeepBackSet = EgtGetInfo( tEndId[1], 'KeepBackSet') local sProbeSide = EgtGetInfo( tEndId[1], 'ProbeSide') -- ProbeMachXY local nActiveStop = EgtGetInfo( tEndId[1], 'ActiveStopMach', 'i') local nSetMaxElev = EgtGetInfo( tEndId[1], 'SetMaxElev', 'i') local nOffsetDel = EgtIf( bNotGenMachining, 20, 0) local nOffsetDelFail = EgtIf( bNotGenMachining, 30, 0) local sKeepBackSetCode local sActiveStop local sSetMaxElev local sProbeSideCode -- determino in base alla disposizione quale codice KeepBackSet dare alla lavorazione if sKeepBackSet and not bNotGenMachining then if (bPush and bFlip) or ( not bPush and not bFlip) then -- se lato narrow è in basso (BD) if sKeepBackSet == 'c' then -- se devo stare in centro allo spessore porta setto per correggere Z di metà valore medio sKeepBackSetCode = 'CORR_Z_PROBE=1' -- codice moltiplicativo del valore di correzione (media/2) elseif sKeepBackSet == 'n' then -- se mantenere su lato narrow, setto per non correggere Z sKeepBackSetCode = 'CORR_Z_PROBE=0' -- codice moltiplicativo del valore di correzione (media/2) elseif sKeepBackSet == 'w' then -- se mantenere su lato wide, setto per correggere Z sKeepBackSetCode = 'CORR_Z_PROBE=2' -- codice moltiplicativo del valore di correzione (media/2) end else -- altrimenti lato narrow è in alto (BU) if sKeepBackSet == 'c' then -- se devo stare in centro allo spessore porta setto per correggere Z di metà valore medio sKeepBackSetCode = 'CORR_Z_PROBE=1' -- codice moltiplicativo del valore di correzione (media/2) elseif sKeepBackSet == 'n' then -- se mantenere su lato narrow, setto per correggere Z sKeepBackSetCode = 'CORR_Z_PROBE=2' -- codice moltiplicativo del valore di correzione (media/2) elseif sKeepBackSet == 'w' then -- se mantenere su lato wide, setto per non correggere Z sKeepBackSetCode = 'CORR_Z_PROBE=0' -- codice moltiplicativo del valore di correzione (media/2) end end end -- if sProbeSide and not bNotGenMachining then sProbeSideCode = 'CPBP' -- CORR_POS_BY_PROBE end -- if nActiveStop and not bNotGenMachining then sActiveStop = 'ActiveStopMach=1' end -- if nSetMaxElev and not bNotGenMachining then sSetMaxElev = 'MaxElev=0.0' end if nMach == 1 then local nRes, nMachId, sToolName = MB.AddAndDelMachining( sLocName .. '_G' .. EgtNumToString(nNumGroup, 0), sMach, tEndId, dOverL, sLocName, bNotGenMachining, sKeepBackSetCode, dBladePerpLeadIn, dPercRedFeed, sProbeSideCode, sActiveStop, sSetMaxElev, dOverR) if nRes < 0 then -- se la lavorazione ha fallito bOk = false if bModifyMacNote then -- setto nota per non lavorarla di nuovo nemmeno nella generazione reale SetInfoTable( tEndId, 'Mach', 11+ nOffsetDelFail) end if bNotGenMachining then -- setto nota per non lavorarla di nuovo nemmeno nella generazione reale SetInfoTable( tEndId, 'Mach', 11+ nOffsetDelFail) end elseif nRes == 0 then -- se lavorazione mancante if bModifyMacNote then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 11+ nOffsetDelFail) end if bNotGenMachining then -- setto nota per non lavorarla di nuovo nemmeno nella generazione reale SetInfoTable( tEndId, 'Mach', 11+ nOffsetDelFail) end else -- lavorazione ok if bModifyMacNote then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 11+ nOffsetDel) end if bNotGenMachining then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 11+ nOffsetDel) if bCalMach then SetInfoTable( tEndId, 'Machining', sMach) nNumMach = nNumMach + 1 end else if tMachining then table.insert( tMachining,{nMachId,sToolName}) end -- verifico se lavorati lati esterni porta CheckExtSideMach(tEndId) end end elseif nMach == 2 then local nRes, nMachId, sToolName = MB.AddAndDelMachining( sLocName .. '_G' .. EgtNumToString(nNumGroup, 0), sMachUp, tEndId, dOverL, sLocName, bNotGenMachining, sKeepBackSetCode, dBladePerpLeadIn, dPercRedFeed, sProbeSideCode, sActiveStop, sSetMaxElev, dOverR) if nRes < 0 then -- se la lavorazione ha fallito bOk = false if bModifyMacNote then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 12+ nOffsetDelFail) end if bNotGenMachining then -- setto nota per non lavorarla di nuovo nemmeno nella generazione reale SetInfoTable( tEndId, 'Mach', 12+ nOffsetDelFail) end elseif nRes == 0 then -- se lavorazione mancante if bModifyMacNote then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 12+ nOffsetDelFail) end if bNotGenMachining then -- setto nota per non lavorarla di nuovo nemmeno nella generazione reale SetInfoTable( tEndId, 'Mach', 12+ nOffsetDelFail) end else -- lavorazione ok if bModifyMacNote then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 12+ nOffsetDel) end if bNotGenMachining then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 12+ nOffsetDel) if bCalMach then SetInfoTable( tEndId, 'Machining', sMachUp) nNumMach = nNumMach + 1 end else if tMachining then table.insert( tMachining,{nMachId,sToolName}) end -- verifico se lavorati lati esterni porta CheckExtSideMach(tEndId) end end elseif nMach == 3 then local nRes, nMachId, sToolName = MB.AddAndDelMachining( sLocName .. '_G' .. EgtNumToString(nNumGroup, 0), sMachDw, tEndId, dOverL, sLocName, bNotGenMachining, sKeepBackSetCode, dBladePerpLeadIn, dPercRedFeed, sProbeSideCode, sActiveStop, sSetMaxElev, dOverR) if nRes < 0 then -- se la lavorazione ha fallito bOk = false if bModifyMacNote then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 13+ nOffsetDelFail) end if bNotGenMachining then -- setto nota per non lavorarla di nuovo nemmeno nella generazione reale SetInfoTable( tEndId, 'Mach', 13+ nOffsetDelFail) end elseif nRes == 0 then -- se lavorazione mancante if bModifyMacNote then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 13+ nOffsetDelFail) end if bNotGenMachining then -- setto nota per non lavorarla di nuovo nemmeno nella generazione reale SetInfoTable( tEndId, 'Mach', 13+ nOffsetDelFail) end else -- lavorazione ok if bModifyMacNote then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 13+ nOffsetDel) end if bNotGenMachining then -- setto nota per non lavorarla di nuovo SetInfoTable( tEndId, 'Mach', 13+ nOffsetDel) if bCalMach then SetInfoTable( tEndId, 'Machining', sMachDw) nNumMach = nNumMach + 1 end else if tMachining then table.insert( tMachining,{nMachId,sToolName}) end -- verifico se lavorati lati esterni porta CheckExtSideMach(tEndId) end end end return bOk, nNumMach, tMachining end ----------------------------------------------------------------- -- *** Calc Machining for same group *** ----------------------------------------------------------------- local function FindAndCalcGroupMachining( nEndId, nEndIdGhost, tLocTable, nNumMachFromTable, nMach, nNumGroup, nNumMach, bOk, dBladePerpLeadIn, dPercRedFeed ) local nParendId = EgtGetParent(nEndId) local EntListMain = MB.FindEntities( nParendId) -- ricavo tutte le entità che sono nello stesso gruppo local sLocMachId local bNotGenMachining = true -- ordinare lavorazioni navette come scritto su foglio nella documentazione for i = 1, #tLocTable do if tLocTable[i].On ~= 0 then sLocMachId = tLocTable[i].MachId if not sLocMachId then sLocMachId = 1 end if sLocMachId == nNumMachFromTable then -- Recupero le entità local EntList = MB.FindEntitiesWithNameFromTab( EntListMain, tLocTable[i].Name) -- Applico le lavorazioni for j = 1, #EntList do local nMachCk = EgtGetInfo( EntList[j], 'MachCk', 'i') or 1 if tLocTable[i].Oper == 'AdjustHead' and nMachCk > 0 and nMachCk < 10 then -- assegno la stessa nota nMach dell'entità del gruppo EgtSetInfo( EntList[j], 'Mach', nMach) -- duplico entià local nNewEntId = MB.MakeGhostCopy( EntList[j]) -- carico id entità in una tabella local tListSameMach = {} table.insert( tListSameMach, nNewEntId) bOk, nNumMach = InsertMachiningByMachNum( tListSameMach, nMach, tLocTable[i].Name, nNumGroup, tLocTable[i].Mach, tLocTable[i].MachUp, tLocTable[i].MachDw, bOk, nNumMach, true, bNotGenMachining, nil, dBladePerpLeadIn, dPercRedFeed) local nNewMach = EgtGetInfo( tListSameMach[1], 'Mach', 'i') or 1 if nNewMach > 30 and nNewMach < 40 then EgtSetInfo( EntList[j], 'Mach', nNewMach-20) -- assegno nota per non lavorarla di nuovo elseif nNewMach > 40 and nNewMach < 50 then EgtSetInfo( EntList[j], 'Mach', nNewMach-30) -- assegno nota per non lavorarla di nuovo end end end end end end return bOk, nNumMach end ----------------------------------------------------------------- -- *** Add Machining for same group *** ----------------------------------------------------------------- local function MakeGroupMachining( nEndId, nParendId, tLocTable, nMach, nNumGroup, nNumMach, bOk, sGhostName, dMaxDistToChain, EndLastMach, dBladePerpLeadIn, dPercRedFeed) local EntListMain = MB.FindEntities( nParendId) -- ricavo tutte le entità che sono nello stesso gruppo -- ordinare lavorazioni navette come scritto su foglio nella documentazione for i = 1, #tLocTable do -- Recupero le entità local EntList = MB.FindEntitiesWithNameFromTab( EntListMain, tLocTable[i].Name..sGhostName) -- Applico le lavorazioni for j = 1, #EntList do local nMachCk = EgtGetInfo( EntList[j], 'Mach', 'i') or 1 nMachCk = nMachCk - 30 -- se lavorazione corretta ottengo 1 local nMach2nd = EgtGetInfo( EntList[j], 'Mach2nd', 'i') or 0 if nMachCk > 0 and nMachCk < 10 then nMachCk = 1 end if nMachCk > 0 and nMachCk < 10 then local nNewEntId = EntList[j] local sMachining = EgtGetInfo( nNewEntId, 'Machining') if sMachining and nMach == 1 and nMach2nd == 0 and sMachining == tLocTable[i].Mach then -- cerco di unire più entità nella stessa lavorazione ( non da sotto e non oltre una certa distanza) local tListSameMach = MB.FindEntitiesCompMach( nNewEntId, EntList, sMachining, tLocTable[i].Join, dMaxDistToChain, true, true) -- se più di 1 entità le ordino if #tListSameMach > 1 then tListSameMach = MB.OrderEnt( tListSameMach, EndLastMach) EndLastMach = EgtSP( tListSameMach[#tListSameMach], GDB_ID.ROOT ) end bOk, nNumMach = InsertMachiningByMachNum( tListSameMach, nMach, tLocTable[i].Name, nNumGroup, tLocTable[i].Mach, tLocTable[i].MachUp, tLocTable[i].MachDw, bOk, nNumMach, true, GEN_MACH, nil, dBladePerpLeadIn, dPercRedFeed) -- se ho assegnato lavorazione a più entità, marco quelle che ho già fatto SetInfoTable( tListSameMach, 'Mach2nd', 1) local nNewMach = EgtGetInfo( tListSameMach[1], 'Mach', 'i') or 1 if nNewMach > 30 and nNewMach < 40 then SetInfoTable( tListSameMach, 'Mach', nNewMach-20) -- assegno nota per non lavorarla di nuovo elseif nNewMach > 40 and nNewMach < 50 then SetInfoTable( tListSameMach, 'Mach', nNewMach-30) -- assegno nota per non lavorarla di nuovo end end end end -- tolgo di mezzo le note secondarie for j = 1, #EntList do EgtRemoveInfo( EntList[j], 'Mach2nd') end end return bOk, nNumMach end ----------------------------------------------------------------- -- *** calc disposition references *** ----------------------------------------------------------------- local function CalcDispositionRef( bLeftPiece, bTopOnRight, dLeftOffs, dRightOffs, dTopOffs, dBottomOffs, bFlip, nKeepSideDoorInFront) local dExtraX, dExtraY, nCorner if DISPMODE > 0 then -- se disposizione a sinistra della tavola if bTopOnRight then -- se top a destra dExtraX = -dBottomOffs if ( bPush and bLeftPiece) or ( not bPush and not bLeftPiece) then nCorner = MCH_CR.BL dExtraY = EgtIf( bFlip, -dLeftOffs, -dRightOffs) else -- se orientamento teste definito if nKeepSideDoorInFront > 0 then nCorner = MCH_CR.BL else nCorner = MCH_CR.TL end dExtraY = EgtIf( bFlip, dRightOffs, dLeftOffs) end else -- se top a sinistra dExtraX = -dTopOffs if ( bPush and bLeftPiece) or ( not bPush and not bLeftPiece) then -- se orientamento teste definito if nKeepSideDoorInFront > 0 then nCorner = MCH_CR.BL else nCorner = MCH_CR.TL end dExtraY = EgtIf( bFlip, dLeftOffs, dRightOffs) else nCorner = MCH_CR.BL dExtraY = EgtIf( bFlip, -dRightOffs, -dLeftOffs) end end else -- altrimenti disposizione a destra della tavola if bTopOnRight then -- se top a destra dExtraX = dTopOffs if ( bPush and bLeftPiece) or ( not bPush and not bLeftPiece) then nCorner = MCH_CR.BR dExtraY = EgtIf( bFlip, -dLeftOffs, -dRightOffs) else -- se orientamento teste definito if nKeepSideDoorInFront > 0 then nCorner = MCH_CR.BR else nCorner = MCH_CR.TR end dExtraY = EgtIf( bFlip, dRightOffs, dLeftOffs) end else -- se top a sinistra dExtraX = dBottomOffs if ( bPush and bLeftPiece) or ( not bPush and not bLeftPiece) then -- se orientamento teste definito if nKeepSideDoorInFront > 0 then nCorner = MCH_CR.BR else nCorner = MCH_CR.TR end dExtraY = EgtIf( bFlip, dLeftOffs, dRightOffs) else nCorner = MCH_CR.BR dExtraY = EgtIf( bFlip, -dRightOffs, -dLeftOffs) end end end return dExtraX, dExtraY, nCorner end ----------------------------------------------------------------- -- *** calc disposition subpieces *** ----------------------------------------------------------------- local function CalcDispositionSubPieces( nNumB, nRowId, bFixSameVac, tsBaseNameVac, ttBaseDataVac, sInd, tnNumVacInsert, tnNumKindVac, tdYCommpos, nInd, tnCountFailed, tnMaxIniFailed, tnIniFailed, tnMaxMiddleFailed, tnMiddleFailed, tnMaxEndFailed, tnEndFailed, nNumTotVacRow, dLenCalc, bNarrowStile, tabOri, tnTypeSingleVacOnBar, bFrameOnNarrow, bUseViseOnFrameOnWide, dDimY) local ptPos -- punto posizioni ventose local bCanUp local tPosSubPiece = {} local tPosRowSubPieceRow = {} local nCenterId local nTypeVacSel = 0 local bCheckNext = true local nCountTypeVac = 1 local nVacErr local bBlindColl local nCustType -- se uso morsa if bUseViseOnFrameOnWide then nTypeVacSel = 1 -- inizio con il primo while nCountTypeVac <= #ttBaseDataVac do -- parto con il controllo del primo tipo di morsa if nTypeVacSel == nCountTypeVac and bCheckNext then nCenterId = EgtGetFirstNameInGroup( nRowId, ttBaseDataVac[nCountTypeVac][nNumB][1]..sInd) -- se nome punto di riferimento presente e numero tipi di ventose sulla barra non nullo if nCenterId and #ttBaseDataVac > 0 then local dDistThru = ttBaseDataVac[nCountTypeVac][nNumB][3] local dDistBlind = ttBaseDataVac[nCountTypeVac][nNumB][4] local dDistCont = ttBaseDataVac[nCountTypeVac][nNumB][5] ptPos = EgtSP( nCenterId, GDB_ID.ROOT) bBlindColl = false bCanUp, nVacErr, bBlindColl = ExecViseShapeVerify( ptPos, ttBaseDataVac[nCountTypeVac][nNumB][2], tabOri, dDistThru, dDistBlind, dDistCont, 0, dDimY) if not bCanUp and nVacErr > 0 then if nVacErr == 1 then DoorOutLog( 'Group Mobile or Area not found into Vise model: '.. ttBaseDataVac[nCountTypeVac][nNumB][2] .. '. Please update vise nge model', 0) else DoorOutLog( 'Region REG_x not found into vise model: '.. ttBaseDataVac[nCountTypeVac][nNumB][2] .. '. Please update vise nge model', 0) end end else bCanUp = false DoorOutLog( 'Point on .nge machine table not found: '.. ttBaseDataVac[nCountTypeVac][nNumB][1]..sInd, 0) end if bCanUp then -- è andata bene la ventosa if #tsBaseNameVac[nNumB][1] > 0 then -- ho già il tipo ventosa -- confermo questo tipo tnNumKindVac[nNumB] = tsBaseNameVac[nNumB][3] bCheckNext = false else -- setto il nuovo tipo (in questo caso è il primo) tsBaseNameVac[nNumB][1] = ttBaseDataVac[nCountTypeVac][nNumB][2] tsBaseNameVac[nNumB][2] = ttBaseDataVac[nCountTypeVac][nNumB][2] tsBaseNameVac[nNumB][3] = nTypeVacSel tdYCommpos[nNumB] = ptPos:getY() -- confermo questo tipo tnNumKindVac[nNumB] = tsBaseNameVac[nNumB][3] bCheckNext = false end end end nCountTypeVac = nCountTypeVac + 1 end -- end while else -- se ventosa fissa if bFixSameVac then if bNarrowStile and nNumB ~= 2 then nTypeVacSel = tnNumVacInsert[nNumB] -- setto pari al numero di tipi gestito (può essere 1, 2 ,3, ecc) else -- controllo se ho già il tipo di ventosa usata if #tsBaseNameVac[nNumB][1] > 0 then -- ho già il tipo ventosa nTypeVacSel = tsBaseNameVac[nNumB][3] else nTypeVacSel = 1 -- inizio con il primo end end elseif bNarrowStile and nNumB ~= 2 then -- se ho la proprietà per la narrow stile passo subito con quella più piccola nTypeVacSel = tnNumVacInsert[nNumB] -- setto pari al numero di tipi gestito (può essere 1, 2 ,3, ecc) else if tnTypeSingleVacOnBar[nNumB] and tnTypeSingleVacOnBar[nNumB] >= 0 then nTypeVacSel = tnTypeSingleVacOnBar[nNumB] else nTypeVacSel = 1 -- inizio con il primo end end while nCountTypeVac <= #ttBaseDataVac do -- parto con il controllo del primo tipo di ventosa if nTypeVacSel == nCountTypeVac and bCheckNext then nCenterId = EgtGetFirstNameInGroup( nRowId, ttBaseDataVac[nCountTypeVac][nNumB][1]..sInd) -- se nome punto di riferimento presente e numero tipi di ventose sulla barra non nullo if nCenterId and tnNumVacInsert[nNumB] > 0 then local dDistThru = ttBaseDataVac[nCountTypeVac][nNumB][4] local dDistBlind = ttBaseDataVac[nCountTypeVac][nNumB][5] local dDistCont = ttBaseDataVac[nCountTypeVac][nNumB][6] if bFrameOnNarrow then dDistThru = ttBaseDataVac[nCountTypeVac][nNumB][7] dDistBlind = ttBaseDataVac[nCountTypeVac][nNumB][8] dDistCont = ttBaseDataVac[nCountTypeVac][nNumB][9] end ptPos = EgtSP( nCenterId, GDB_ID.ROOT) bBlindColl = false bCanUp, nVacErr, bBlindColl, nCustType = ExecVacShapeVerify( ptPos, ttBaseDataVac[nCountTypeVac][nNumB][2], tabOri, dDistThru, dDistBlind, dDistCont) if not bCanUp and nVacErr > 0 then if nVacErr == 1 then DoorOutLog( 'Group Mobile or Area not found into Vacuum model: '.. ttBaseDataVac[nCountTypeVac][nNumB][2] .. '. Please update vacuum nge model', 0) else DoorOutLog( 'Region SHAPE not found into vacuum model: '.. ttBaseDataVac[nCountTypeVac][nNumB][2] .. '. Please update vacuum nge model', 0) end end else bCanUp = false DoorOutLog( 'Point on .nge machine table not found: '.. ttBaseDataVac[nCountTypeVac][nNumB][1]..sInd, 0) end if bCanUp then -- è andata bene la ventosa if #tsBaseNameVac[nNumB][1] > 0 then -- ho già il tipo ventosa -- se ventosa fissa e corrisponde con questo tipo, setto quella fissa if bFixSameVac and tsBaseNameVac[nNumB][3] == nTypeVacSel then -- confermo questo tipo tnNumKindVac[nNumB] = nCustType or tsBaseNameVac[nNumB][3] bCheckNext = false elseif not( bNarrowStile and nNumB ~= 2) then -- se non è tipo narrow stile setto questa tsBaseNameVac[nNumB][1] = ttBaseDataVac[nCountTypeVac][nNumB][2] tsBaseNameVac[nNumB][2] = ttBaseDataVac[nCountTypeVac][nNumB][3] tsBaseNameVac[nNumB][3] = nTypeVacSel tdYCommpos[nNumB] = ptPos:getY() -- confermo questo tipo tnNumKindVac[nNumB] = nCustType or tsBaseNameVac[nNumB][3] bCheckNext = false elseif ( bNarrowStile and nNumB ~= 2) then -- se tipo narrow stile if tnNumVacInsert[nNumB] == nTypeVacSel then -- se sono all'ultimo tipo ventosa la confermo tsBaseNameVac[nNumB][1] = ttBaseDataVac[nCountTypeVac][nNumB][2] tsBaseNameVac[nNumB][2] = ttBaseDataVac[nCountTypeVac][nNumB][3] tsBaseNameVac[nNumB][3] = nTypeVacSel tdYCommpos[nNumB] = ptPos:getY() -- confermo questo tipo tnNumKindVac[nNumB] = nCustType or tsBaseNameVac[nNumB][3] bCheckNext = false elseif tnNumVacInsert[nNumB] > nTypeVacSel then nTypeVacSel = nTypeVacSel + 1 end end else -- setto il nuovo tipo (in questo caso è il primo) tsBaseNameVac[nNumB][1] = ttBaseDataVac[nCountTypeVac][nNumB][2] tsBaseNameVac[nNumB][2] = ttBaseDataVac[nCountTypeVac][nNumB][3] tsBaseNameVac[nNumB][3] = nTypeVacSel tdYCommpos[nNumB] = ptPos:getY() -- confermo questo tipo tnNumKindVac[nNumB] = nCustType or tsBaseNameVac[nNumB][3] if bFixSameVac then -- se ventosa fissa if bNarrowStile and nNumB ~= 2 then -- se narrow stile if tnNumVacInsert[nNumB] == nTypeVacSel then -- se ultima ventosa bCheckNext = false elseif tnNumVacInsert[nNumB] > nTypeVacSel then nTypeVacSel = nTypeVacSel + 1 end else -- non è narrow bCheckNext = false end end end else if nCountTypeVac < #ttBaseDataVac then if bFixSameVac or not( bNarrowStile and nNumB ~= 2) then -- se ventose uguali o non ha propietà narrow stile -- se posso incrementare il tipo ventosa if tnNumVacInsert[nNumB] > nTypeVacSel then nTypeVacSel = nTypeVacSel + 1 end end end end end nCountTypeVac = nCountTypeVac + 1 end -- end while end -- eventuale abilitazione parte fissa if bCanUp then -- se sottopezzo da inserire local nCodVac nCodVac = tnNumKindVac[nNumB] -- inserisco la ventosa sul fisso tPosSubPiece[1] = ptPos tPosSubPiece[2] = nCodVac tPosRowSubPieceRow = { tPosSubPiece[1], tPosSubPiece[2]} -- interrompo le serie negative if nInd > 1 then tnCountFailed[nNumB] = 0 if tnMaxIniFailed[nNumB] < tnIniFailed[nNumB] then tnMaxIniFailed[nNumB] = tnIniFailed[nNumB] end if tnMaxMiddleFailed[nNumB] < tnMiddleFailed[nNumB] then tnMaxMiddleFailed[nNumB] = tnMiddleFailed[nNumB] end if tnMaxEndFailed[nNumB] < tnEndFailed[nNumB] then tnMaxEndFailed[nNumB] = tnEndFailed[nNumB] end tnIniFailed[nNumB] = 0 tnMiddleFailed[nNumB] = 0 tnEndFailed[nNumB] = 0 end else -- sottopezzo non inserito if nNumB == 2 then -- se barra intermedia scrivo lo stesso la posizione tPosSubPiece[1] = ptPos else tPosSubPiece[1] = '' end tPosSubPiece[2] = 0 tPosRowSubPieceRow = { tPosSubPiece[1], tPosSubPiece[2]} tnCountFailed[nNumB] = tnCountFailed[nNumB] + 1 if nInd == 1 then -- setto solo il fallimento iniziale tnIniFailed[nNumB] = tnCountFailed[nNumB] elseif nInd == nNumTotVacRow or dLenCalc <= 0 then -- setto solo quello finale e annullo il medio tnEndFailed[nNumB] = tnCountFailed[nNumB] if tnMaxEndFailed[nNumB] < tnEndFailed[nNumB] then tnMaxEndFailed[nNumB] = tnEndFailed[nNumB] end tnMiddleFailed[nNumB] = 0 else -- se fallisce riga intermedia aggiorno solo i contatori già iniziati if tnIniFailed[nNumB] > 0 then tnIniFailed[nNumB] = tnCountFailed[nNumB] elseif tnEndFailed[nNumB] > 0 then tnEndFailed[nNumB] = tnCountFailed[nNumB] - 1 else tnMiddleFailed[nNumB] = tnCountFailed[nNumB] end end end return tPosRowSubPieceRow, bBlindColl end ----------------------------------------------------------------- -- *** insert special subpieces *** ----------------------------------------------------------------- local function InsertSpecialSubPiece( tPosRowSubPieceRow, nNumTotVacRow, bTopOnRight, tsSpecialNameVac, tabOri, dDistThru, dDistBlind, dDistSide, pPiecePos, nNumB, tnMaxIniFailed, tnMaxMiddleFailed, tnMaxEndFailed, DISPMODE) local bFound = false local bRotVac = EgtIf( bTopOnRight, true, false) local dMove = 0 local nFoundFirst = 0 local nPrecVacType = 0 local nVacErr for l = 1, nNumTotVacRow do local nIndVac = EgtIf( not bTopOnRight, l, ( nNumTotVacRow - l + 1)) local tnCodVac = tPosRowSubPieceRow[nIndVac] if tnCodVac then -- se codice presente if nFoundFirst == 0 then nFoundFirst = EgtIf( bTopOnRight, nIndVac, l) end if bRotVac then dMove = pPiecePos:getX() - tnCodVac[1]:getX() else dMove = tnCodVac[1]:getX() - pPiecePos:getX() end nPrecVacType = tnCodVac[2] -- provo ad inserire la ventosa con il codice collisione local bCanUp, nVacErr = ExecVacShapeVerify( tnCodVac[1], tsSpecialNameVac, tabOri, dDistThru, dDistBlind, dDistSide, true, EgtIf( bRotVac, 180, 0), dMove) if bCanUp then tnCodVac[2] = EgtIf( bRotVac, 6, 5) bFound = true if nFoundFirst == l then -- se prima ventosa trovata dalla parte finale ( a sinistra) if DISPMODE > 0 then -- se porta disposta a sinistra if nPrecVacType == 0 then -- se ventosa precedente vuota if tnMaxIniFailed[nNumB] > 0 then tnMaxMiddleFailed[nNumB] = tnMaxMiddleFailed[nNumB] + tnMaxIniFailed[nNumB] - 1 tnMaxIniFailed[nNumB] = 0 end end else if nPrecVacType == 0 then -- se ventosa precedente vuota if tnMaxEndFailed[nNumB] > 0 then tnMaxMiddleFailed[nNumB] = tnMaxMiddleFailed[nNumB] + tnMaxEndFailed[nNumB] - 1 tnMaxEndFailed[nNumB] = 0 end end end -- se ( top a sinistra e ultima ventosa trovata ( a destra)) o ( top a destra e prima ventosa dalla parte iniziale ( a destra)) elseif (not bTopOnRight and l == nIndVac) or ( bTopOnRight and nFoundFirst == nIndVac) then if DISPMODE > 0 then -- se porta disposta a sinistra if nPrecVacType == 0 then -- se ventosa precedente vuota if tnMaxEndFailed[nNumB] > 0 then tnMaxMiddleFailed[nNumB] = tnMaxMiddleFailed[nNumB] + tnMaxEndFailed[nNumB] - 1 tnMaxEndFailed[nNumB] = 0 end end else if nPrecVacType == 0 then -- se ventosa precedente vuota if tnMaxIniFailed[nNumB] > 0 then tnMaxMiddleFailed[nNumB] = tnMaxMiddleFailed[nNumB] + tnMaxIniFailed[nNumB] - 1 tnMaxIniFailed[nNumB] = 0 end end end else -- se sono in posizione intermedia if nPrecVacType == 0 then -- se ventosa vuota -- se ( porta a sinistra e top a destra) o ( porta a destra e top a sinistra) if ( DISPMODE > 0 and bTopOnRight) or ( DISPMODE < 0 and not bTopOnRight) then if tnMaxEndFailed[nNumB] > 0 then tnMaxMiddleFailed[nNumB] = tnMaxMiddleFailed[nNumB] + ( tnMaxEndFailed[nNumB] - ( nFoundFirst - nIndVac + 1)) tnMaxEndFailed[nNumB] = nFoundFirst - nIndVac - 1 -- sottraggo ancora 1 perché la base occupa due spazi end else if tnMaxIniFailed[nNumB] > 0 then tnMaxMiddleFailed[nNumB] = tnMaxMiddleFailed[nNumB] + ( tnMaxIniFailed[nNumB] - ( nIndVac - nFoundFirst + 1)) tnMaxIniFailed[nNumB] = nIndVac - nFoundFirst - 1 -- sottraggo ancora 1 perché la base occupa due spazi end end -- if tnMaxMiddleFailed[nNumB] > 0 then -- tnMaxMiddleFailed[nNumB] = tnMaxMiddleFailed[nNumB] - 1 -- end end end else if nVacErr == 1 then DoorOutLog( 'Group Mobile or Area not found into Vacuum model: '.. tsSpecialNameVac .. '. Please update vacuum nge model', 0) break elseif nVacErr > 1 then DoorOutLog( 'Region SHAPE not found into vacuum model: '.. tsSpecialNameVac .. '. Please update vacuum nge model', 0) break end end end if bFound then break end end return tPosRowSubPieceRow, bFound end ----------------------------------------------------------------- -- *** disposition subpieces *** ----------------------------------------------------------------- local function DispositionSubPieces( nNumB, nIndVac, tPosRowSubPieceRow, bFixSameVac, tsBaseNameVac, tdYCommpos, ttBaseDataVac, nIndOri, tabOri, tsNoteRow, nDispId, tsSpecialNameVac, pPiecePos, Pz, bInsSpecVac, bUseViseOnFrameOnWide, dDimY) local tnCodVac = tPosRowSubPieceRow[nIndVac] local sCodVac local sNameV, sNameVSld local dMove = 0 local nFixVac if tnCodVac then -- se codice presente if tnCodVac[2] == 0 then sCodVac = '0_' else if bInsSpecVac and tnCodVac[2] >= 5 and bFixSameVac then -- se ho inserito la ventosa speciale ma ho il codice di uniformare tutte le ventose, lo disabilito bFixSameVac = false end if bUseViseOnFrameOnWide then sNameV = ttBaseDataVac[1][nNumB][2] sNameVSld = ttBaseDataVac[1][nNumB][2] sCodVac = 'V_' dMove = dDimY elseif bFixSameVac and #tsBaseNameVac[nNumB][1] > 0 then -- se fissa sulla stessa ventosa sNameV = tsBaseNameVac[nNumB][1] sNameVSld = tsBaseNameVac[nNumB][2] sCodVac = string.format( '%s_', tsBaseNameVac[nNumB][3]) tnCodVac[1] = Point3d{ tnCodVac[1]:getX(), tdYCommpos[nNumB], tnCodVac[1]:getZ()} elseif tnCodVac[2] == 1 then sNameV = ttBaseDataVac[1][nNumB][2] sNameVSld = ttBaseDataVac[1][nNumB][3] sCodVac = '1_' elseif tnCodVac[2] == 2 then sNameV = ttBaseDataVac[2][nNumB][2] sNameVSld = ttBaseDataVac[2][nNumB][3] sCodVac = '2_' elseif tnCodVac[2] == 3 then sNameV = ttBaseDataVac[3][nNumB][2] sNameVSld = ttBaseDataVac[3][nNumB][3] sCodVac = '3_' elseif tnCodVac[2] == 5 then sNameV = tsSpecialNameVac sNameVSld = tsSpecialNameVac sCodVac = '5_' dMove = tnCodVac[1]:getX() - pPiecePos:getX() -- scrivo una nota con la posizione della ventosa ad arco EgtSetInfo( Pz, 'TopVacArcPos', Point3d( pPiecePos:getX(), tnCodVac[1]:getY(),0)) elseif tnCodVac[2] == 6 then sNameV = tsSpecialNameVac sNameVSld = tsSpecialNameVac sCodVac = '6_' dMove = pPiecePos:getX() - tnCodVac[1]:getX() -- scrivo una nota con la posizione della ventosa ad arco EgtSetInfo( Pz, 'TopVacArcPos', Point3d( pPiecePos:getX(), tnCodVac[1]:getY(),0)) elseif tnCodVac[2] == 7 then sNameV = ttBaseDataVac[3][nNumB][2] sNameVSld = ttBaseDataVac[3][nNumB][3] sCodVac = '7_' end -- inserisco la ventosa local sNameVac = EgtIf( fmod( nIndOri, 2) == 1, sNameVSld, sNameV) nFixVac = EgtAddFixture( sNameVac, ( tnCodVac[1] - tabOri), EgtIf( tnCodVac[2] == 6, 180,0), dMove) EgtSetInfo( nDispId, 'POS'..EgtNumToString( nNumB, 0)..'_'..EgtNumToString( nIndVac, 0), ( tnCodVac[1] - tabOri)) EgtSetInfo( nDispId, 'MOD'..EgtNumToString( nNumB, 0)..'_'..EgtNumToString( nIndVac, 0), sNameVac) EgtSetInfo( nDispId, 'COD'..EgtNumToString( nNumB, 0)..'_'..EgtNumToString( nIndVac, 0), sCodVac) end tsNoteRow[nNumB] = EgtIf( DISPMODE > 0, tsNoteRow[nNumB] .. sCodVac, sCodVac .. tsNoteRow[nNumB]) else tsNoteRow[nNumB] = EgtIf( DISPMODE > 0, tsNoteRow[nNumB] .. '0_', '0_' .. tsNoteRow[nNumB]) EgtRemoveInfo( nDispId, 'POS'..EgtNumToString( nNumB, 0)..'_'..EgtNumToString( nIndVac, 0)) EgtRemoveInfo( nDispId, 'MOD'..EgtNumToString( nNumB, 0)..'_'..EgtNumToString( nIndVac, 0)) EgtRemoveInfo( nDispId, 'COD'..EgtNumToString( nNumB, 0)..'_'..EgtNumToString( nIndVac, 0)) end return nFixVac end ----------------------------------------------------------------- -- *** disposition references *** ----------------------------------------------------------------- local function DispositionReferences( sNameRef, ptPosRef, nRotRef) if sNameRef and ptPosRef and nRotRef then local ptLoc = Point3d( ptPosRef) local nRef = EgtAddFixture( sNameRef, ptLoc, nRotRef, 0) end end local function CheckEnoughVacuums( nInd, nIdVac, tnMaxIniFailed, tnMaxMiddleFailed, tnMaxEndFailed, bUseOnly2Bars, dTopRadius, bTopOnRight, bUseVise, tIdViseDisp) local bOk = true local sMess = '' if nIdVac == 0 then -- se codice per porta if bUseOnly2Bars then -- in caso di due barre, inferiore e media if nInd > 0 and (( tnMaxIniFailed[1] == nInd or tnMaxMiddleFailed[1] == nInd or tnMaxEndFailed[1] == nInd) or ( tnMaxIniFailed[2] == nInd or tnMaxMiddleFailed[2] == nInd or tnMaxEndFailed[2] == nInd)) then -- tutte le ventose basse sMess = ' ' .. EgtDoorsMsg[531] bOk = false elseif nInd > 0 and ( tnMaxIniFailed[1] / nInd > 0.25) and ( tnMaxIniFailed[2] / nInd > 0.25) then -- ventose iniziali ( parte sinistra) local nNumMsg = EgtIf( DISPMODE > 0, 532, 534) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif nInd > 0 and ( tnMaxMiddleFailed[1] / nInd > 0.45) and ( tnMaxMiddleFailed[2] / nInd > 0.45) then -- ventose centrali sMess = ' ' .. EgtDoorsMsg[533] bOk = false elseif nInd > 0 and ( tnMaxEndFailed[1] / nInd > 0.25) and ( tnMaxEndFailed[2] / nInd > 0.25) then -- ventose finali ( parte destra) local nNumMsg = EgtIf( DISPMODE > 0, 534, 532) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif (( tnMaxIniFailed[1] + tnMaxMiddleFailed[1] + tnMaxEndFailed[1]) >= nInd/2) and (( tnMaxIniFailed[2] + tnMaxMiddleFailed[2] + tnMaxEndFailed[2]) >= nInd/2) then -- somma di vari intervalli sMess = ' ' .. EgtDoorsMsg[531] bOk = false end else -- casi di scarse ventose: solo per le file esterne, quella centrale le considero solo per le porte ad arco -- perché è capitato che la disposizione porta risultasse corretta con solo la fila centrale if nInd > 0 and (( tnMaxIniFailed[1] == nInd or tnMaxMiddleFailed[1] == nInd or tnMaxEndFailed[1] == nInd) or -- ( tnMaxIniFailed[2] == nInd or tnMaxMiddleFailed[2] == nInd or tnMaxEndFailed[2] == nInd) or ( tnMaxIniFailed[3] == nInd or tnMaxMiddleFailed[3] == nInd or tnMaxEndFailed[3] == nInd)) then -- tutte le ventose basse sMess = ' ' .. EgtDoorsMsg[531] bOk = false elseif nInd > 0 and not dTopRadius and ( tnMaxIniFailed[1] / nInd > 0.25) and -- ( tnMaxIniFailed[2] / nInd > 0.25) and ( tnMaxIniFailed[3] / nInd > 0.25) then -- ventose iniziali ( parte destra) senza top ad arco local nNumMsg = EgtIf( DISPMODE > 0, 532, 534) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif nInd > 0 and dTopRadius and not bTopOnRight and ( tnMaxIniFailed[1] / nInd > 0.25) and -- ( tnMaxIniFailed[2] / nInd > 0.25) and ( tnMaxIniFailed[3] / nInd > 0.25) then -- ventose iniziali ( parte destra) top ad arco opposto local nNumMsg = EgtIf( DISPMODE > 0, 532, 534) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif nInd > 0 and dTopRadius and bTopOnRight and not ( tnMaxIniFailed[1] / nInd <= 0.35 and tnMaxIniFailed[2] / nInd <= 0.55 and tnMaxIniFailed[3] / nInd <= 0.35) then -- ventose iniziali ( parte destra) top ad arco su questo lato local nNumMsg = EgtIf( DISPMODE > 0, 532, 534) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif nInd > 0 and ( tnMaxMiddleFailed[1] / nInd > 0.45) and -- ( tnMaxMiddleFailed[2] / nInd > 0.45) and ( tnMaxMiddleFailed[3] / nInd > 0.45) then -- ventose centrali sMess = ' ' .. EgtDoorsMsg[533] bOk = false elseif nInd > 0 and not dTopRadius and ( tnMaxEndFailed[1] / nInd > 0.25) and -- ( tnMaxEndFailed[2] / nInd > 0.25) and ( tnMaxEndFailed[3] / nInd > 0.25) then -- ventose finali ( parte sinistra) senza top ad arco local nNumMsg = EgtIf( DISPMODE > 0, 534, 532) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif nInd > 0 and dTopRadius and bTopOnRight and ( tnMaxEndFailed[1] / nInd > 0.25) and -- ( tnMaxEndFailed[2] / nInd > 0.25) and ( tnMaxEndFailed[3] / nInd > 0.25) then -- ventose finali ( parte sinistra) top ad arco opposto local nNumMsg = EgtIf( DISPMODE > 0, 534, 532) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif nInd > 0 and dTopRadius and not bTopOnRight and not ( tnMaxEndFailed[1] / nInd <= 0.35 and tnMaxEndFailed[2] / nInd <= 0.55 and tnMaxEndFailed[3] / nInd <= 0.35) then -- ventose finali ( parte sinistra) top ad arco su questo lato local nNumMsg = EgtIf( DISPMODE > 0, 534, 532) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif (( tnMaxIniFailed[1] + tnMaxMiddleFailed[1] + tnMaxEndFailed[1]) >= nInd/2) and -- (( tnMaxIniFailed[2] + tnMaxMiddleFailed[2] + tnMaxEndFailed[2]) >= nInd/2) and (( tnMaxIniFailed[3] + tnMaxMiddleFailed[3] + tnMaxEndFailed[3]) >= nInd/2) then -- somma di vari intervalli sMess = ' ' .. EgtDoorsMsg[531] bOk = false end end else -- altrimenti frame if bUseVise then -- numero morse insufficente if tIdViseDisp and #tIdViseDisp < 3 then sMess = ' ' .. EgtDoorsMsg[683] bOk = false elseif nInd > 0 and ( tnMaxIniFailed[nIdVac] > 2) then local nNumMsg = EgtIf( DISPMODE > 0, 684, 685) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif nInd > 0 and ( tnMaxEndFailed[nIdVac] > 2) then local nNumMsg = EgtIf( DISPMODE > 0, 685, 684) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false end else -- casi di scarse ventose: solo per la fila 1 if nInd > 0 and ( tnMaxIniFailed[nIdVac] == nInd or tnMaxMiddleFailed[nIdVac] == nInd or tnMaxEndFailed[nIdVac] == nInd) then sMess = ' ' .. EgtDoorsMsg[531] bOk = false elseif nInd > 0 and ( tnMaxIniFailed[nIdVac] / nInd > 0.25) then local nNumMsg = EgtIf( DISPMODE > 0, 532, 534) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif nInd > 0 and ( tnMaxMiddleFailed[nIdVac] / nInd > 0.45) then sMess = ' ' .. EgtDoorsMsg[533] bOk = false elseif nInd > 0 and ( tnMaxEndFailed[nIdVac] / nInd > 0.25) then local nNumMsg = EgtIf( DISPMODE > 0, 534, 532) sMess = ' ' .. EgtDoorsMsg[nNumMsg] bOk = false elseif (( tnMaxIniFailed[nIdVac] + tnMaxMiddleFailed[nIdVac] + tnMaxEndFailed[nIdVac]) >= nInd/2) then sMess = ' ' .. EgtDoorsMsg[531] bOk = false end end end return bOk, sMess end local function MakeBoxFromSolidLayer( nSolidLayer, nProbeMode, nAuxLayer) -- Box solido: lo ottengo dalla somma delle varie superfici della porta local tListFaces = {} if nProbeMode == 2 then table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'FLAT_UP_2')) table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'FLAT_DW_2')) else table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'FLAT_UP')) table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'FLAT_DW')) end table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE_LF')) table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE_RH')) table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE_BT')) table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE_TP')) table.insert( tListFaces, EgtGetFirstNameInGroup( nSolidLayer, 'SIDE')) -- aggiungo anche il layer AUX escludendo il testo if nAuxLayer then local nIdGeom = EgtGetFirstInGroup(nAuxLayer) local nTypeEnt while nIdGeom do -- se elemento passato è un testo lo escludo nTypeEnt = EgtGetType( nIdGeom) if nTypeEnt ~= GDB_TY.EXT_TEXT then table.insert( tListFaces, nIdGeom) end nIdGeom = EgtGetNext(nIdGeom) end end local b3fx = BBox3d() -- inizializzo il box nullo for i = 1, #tListFaces do if tListFaces[i] then local b3f1 = EgtGetBBoxGlob( tListFaces[i], GDB_BB.EXACT) b3fx:Add(b3f1) end end return b3fx end local function CheckPieceDimension ( bFrame, dLengthDoor, dWidthDoor, dThickDoor, OffsXSovr, OffsYSovr, ShiftXOri, ShiftYOri) local bFailDim = false local sErrMess = '' local dLimitToCheck local nNumMess nNumMess = EgtIf( bFrame, 623, 622) dLimitToCheck = EgtIf( bFrame, tMainTabPar.MnJL, ( tMainTabPar.MnDL - abs(ShiftXOri))) if ( dLengthDoor + OffsXSovr) < dLimitToCheck then -- se lunghezza inferiore bFailDim = true sErrMess = string.format(EgtDoorsMsg[617], EgtDoorsMsg[nNumMess], EgtToUiUnits(dLengthDoor), EgtToUiUnits(OffsXSovr), EgtToUiUnits(dLengthDoor+OffsXSovr), EgtToUiUnits(abs(ShiftXOri)), EgtToUiUnits(dLimitToCheck)) if #DGD.EMC > 0 then DGD.EMC = DGD.EMC .. '\n'.. sErrMess else DGD.EMC = '\n'.. sErrMess end end dLimitToCheck = EgtIf( bFrame, tMainTabPar.MxJL, ( tMainTabPar.MxDL - abs(ShiftXOri))) if ( dLengthDoor + OffsXSovr) > dLimitToCheck then -- se lunghezza superiore bFailDim = true sErrMess = string.format(EgtDoorsMsg[616], EgtDoorsMsg[nNumMess], EgtToUiUnits(dLengthDoor), EgtToUiUnits(OffsXSovr), EgtToUiUnits(dLengthDoor+OffsXSovr), EgtToUiUnits(abs(ShiftXOri)), EgtToUiUnits(dLimitToCheck)) if #DGD.EMC > 0 then DGD.EMC = DGD.EMC .. '\n'.. sErrMess else DGD.EMC = '\n'.. sErrMess end end dLimitToCheck = EgtIf( bFrame, tMainTabPar.MnJW, ( tMainTabPar.MnDW - abs(2*ShiftYOri))) if ( dWidthDoor + (2*OffsYSovr)) < dLimitToCheck then -- se larghezza inferiore bFailDim = true sErrMess = string.format(EgtDoorsMsg[619], EgtDoorsMsg[nNumMess], EgtToUiUnits(dWidthDoor), EgtToUiUnits(2*OffsYSovr), EgtToUiUnits(dWidthDoor+(2*OffsYSovr)), EgtToUiUnits(abs(2*ShiftYOri)), EgtToUiUnits(dLimitToCheck)) if #DGD.EMC > 0 then DGD.EMC = DGD.EMC .. '\n'.. sErrMess else DGD.EMC = '\n'.. sErrMess end end dLimitToCheck = EgtIf( bFrame, tMainTabPar.MxJW, ( tMainTabPar.MxDW - abs(2*ShiftYOri))) if ( dWidthDoor + (2*OffsYSovr)) > dLimitToCheck then -- se larghezza superiore bFailDim = true sErrMess = string.format(EgtDoorsMsg[618], EgtDoorsMsg[nNumMess], EgtToUiUnits(dWidthDoor), EgtToUiUnits(2*OffsYSovr), EgtToUiUnits(dWidthDoor+(2*OffsYSovr)), EgtToUiUnits(abs(2*ShiftYOri)), EgtToUiUnits(dLimitToCheck)) if #DGD.EMC > 0 then DGD.EMC = DGD.EMC .. '\n'.. sErrMess else DGD.EMC = '\n'.. sErrMess end end dLimitToCheck = EgtIf( bFrame, tMainTabPar.MnJT, tMainTabPar.MnDT) if dThickDoor < dLimitToCheck then -- se spessore inferiore bFailDim = true sErrMess = string.format(EgtDoorsMsg[621], EgtDoorsMsg[nNumMess], EgtToUiUnits(dThickDoor), EgtToUiUnits(dLimitToCheck)) if #DGD.EMC > 0 then DGD.EMC = DGD.EMC .. '\n'.. sErrMess else DGD.EMC = '\n'.. sErrMess end end dLimitToCheck = EgtIf( bFrame, tMainTabPar.MxJT, tMainTabPar.MxDT) if dThickDoor > dLimitToCheck then -- se spessore superiore bFailDim = true sErrMess = string.format(EgtDoorsMsg[620], EgtDoorsMsg[nNumMess], EgtToUiUnits(dThickDoor), EgtToUiUnits(dLimitToCheck)) if #DGD.EMC > 0 then DGD.EMC = DGD.EMC .. '\n'.. sErrMess else DGD.EMC = '\n'.. sErrMess end end return bFailDim end ----------------------------------------------------------------- -- *** Funzione di generazione lavorazioni *** ----------------------------------------------------------------- function MachiningLoc.Calc( tPz, tsAssemb, nNumMachFromTable, nNumMachFromCam, nNumGroup) --local nTime -- inizializzo il contatore --EgtStartCounter() -- macchina e tabella di default -- tabella parametri d'uso per variabili CurrcamInfo tMainTabPar = {} -- Machine name tMainTabPar.MN = 'Multiax-' -- id 1 -- Machinings Table local MachiningsTable = 'MachStdTable' local MachiningsTableOrd = 'MachStdTable_Ord' -- References on table (respect Zero machine) -- Y Table -- shift value local vShift = Vector3d(0,0,0) local vShiftVac = Vector3d(0,0,0) local vNullShift = Vector3d(0,0,0) -- utilizzo la tabella dati cam local sPathCurrMachtabOri = 'CurrCamInfo' local mCamData = require( sPathCurrMachtabOri) -- resetto la macchinata (riporto il pezzo in area disegno) EgtResetCurrMachGroup() -- setto nuova variabile suffisso ghost DGD.GHT DGD.GHT = '_HIDE' -- elimino percorsi eventualmente creati dal Mach -- cancello i percorsi ghost e tutti i percorsi di sgrossatura local DelList = MB.FindEntitiesWithPartName( tPz, DGD.GHT) -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end DelList = MB.FindEntitiesWithPartName( tPz, 'ROUGH_') -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end -------------------------------------------------------------------------------- -- Dati del pezzo (porta, frame) local tsProperties = {} local tsRadiusProf = {} local tsPlaneProf = {} local tsDispJambByMat = {} local tsStringData = {} local tsDoubleData = {} local tsBoolData = {} local nProbeMode local nPostProbeSet -- Box pezzo local Ls local Aux local b3Part, b3Solid local tb3Part = {} local tb3Solid = {} -- Project path, name, extension local sFilePath = EgtGetCurrFilePath() local sFileDir, sFileName, sFileExt = EgtSplitPath( sFilePath) -------------------------------------------------------------------------------- -- variabili CAM local TAB local MachinesName -- *** settaggi CAM *** -- Mtable 2 local TABORD -- variabili disposizione su più tavole local nNumTblForOthMat = 2 local nForceAsMultiTbl -------------------------------------------------------------------------------- -- variabili sottopezzi local nTabId, nMobId1, nMobId2, nFixId, nDispId local dFixval, dOldVal, dNewVal_2, dNewVal_1, dCalcLen local tRefArea = {} -- Interasse minimo gruppi ventose local dMinDistGroup = 139.5 -------------------------------------------------------------------------------- -- assegnazione variabili CurrCamInfo -- imposto i dati macchina secondo le informazioni del file cam tMainTabPar.MN = mCamData[nNumMachFromCam].MachName -- MachName tMainTabPar.MxDL = mCamData[nNumMachFromCam].MaxDoorLength -- dMaxDoorLength tMainTabPar.MnDL = mCamData[nNumMachFromCam].MinDoorLength -- dMinDoorLength tMainTabPar.MxDW = mCamData[nNumMachFromCam].MaxDoorWidth -- dMaxDoorWidth tMainTabPar.MnDW = mCamData[nNumMachFromCam].MinDoorWidth -- dMinDoorWidth tMainTabPar.MxDT = mCamData[nNumMachFromCam].MaxDoorThick -- dMaxDoorThick tMainTabPar.MnDT = mCamData[nNumMachFromCam].MinDoorThick -- dMinDoorThick tMainTabPar.MxJL = mCamData[nNumMachFromCam].MaxJambLength -- dMaxJambLength tMainTabPar.MnJL = mCamData[nNumMachFromCam].MinJambLength -- dMinJambLength tMainTabPar.MxJW = mCamData[nNumMachFromCam].MaxJambWidth -- dMaxJambWidth tMainTabPar.MnJW = mCamData[nNumMachFromCam].MinJambWidth -- dMinJambWidth tMainTabPar.MxJT = mCamData[nNumMachFromCam].MaxJambThick -- dMaxJambThick tMainTabPar.MnJT = mCamData[nNumMachFromCam].MinJambThick -- dMinJambThick tMainTabPar.AR = mCamData[nNumMachFromCam].dAltRef -- dAltRef tMainTabPar.TR = mCamData[nNumMachFromCam].dTallRef -- dTallRef tMainTabPar.LS = mCamData[nNumMachFromCam].sLocSecure -- sLocSecure tMainTabPar.MOM = mCamData[nNumMachFromCam].MaxOverMat -- dMaxOverMat tMainTabPar.SOM = mCamData[nNumMachFromCam].StepOverMat or 10 -- dStepOverMat tMainTabPar.TDD = mCamData[nNumMachFromCam].TopSideDriveDisp -- nTopSideDriveDisp tMainTabPar.MDC = mCamData[nNumMachFromCam].MaxDistToChain -- dMaxDistToChain tMainTabPar.FPB = mCamData[nNumMachFromCam].FramePosBar -- dPosBarForJamb tMainTabPar.FVR = mCamData[nNumMachFromCam].nFixSameVacOnRaw == 1 -- bFixSameVac tMainTabPar.NTVB1 = mCamData[nNumMachFromCam].nNumTypeVacOnBar1 -- nNumTypeVacOnBar1 tMainTabPar.NTVB2 = mCamData[nNumMachFromCam].nNumTypeVacOnBar2 -- nNumTypeVacOnBar2 tMainTabPar.NTVB3 = mCamData[nNumMachFromCam].nNumTypeVacOnBar3 -- nNumTypeVacOnBar3 tMainTabPar.TSVB1 = mCamData[nNumMachFromCam].nTypeSingleVacOnBar1 -- new tMainTabPar.TSVB2 = mCamData[nNumMachFromCam].nTypeSingleVacOnBar2 -- new tMainTabPar.TSVB3 = mCamData[nNumMachFromCam].nTypeSingleVacOnBar3 -- new -- nomi punti associati ai tipi ventosa sulle barre tMainTabPar.P1T = mCamData[nNumMachFromCam].sNamePntOnBarsType1 -- new tMainTabPar.P2T = mCamData[nNumMachFromCam].sNamePntOnBarsType2 -- new tMainTabPar.P3T = mCamData[nNumMachFromCam].sNamePntOnBarsType3 -- new -- tolleranza di ricerca per ventose tMainTabPar.DTG = mCamData[nNumMachFromCam].dSafetyDistVacThru or 15 -- new tMainTabPar.DBG = mCamData[nNumMachFromCam].dSafetyDistVacBlind or 45 -- new tMainTabPar.DSG = mCamData[nNumMachFromCam].dSafetyDistVacSide or 1 -- new tMainTabPar.DTGN = mCamData[nNumMachFromCam].dSafetyDistVacThruOnSide or 5 -- new tMainTabPar.DBGN = mCamData[nNumMachFromCam].dSafetyDistVacBlindOnSide or 15 -- new tMainTabPar.DSGN = mCamData[nNumMachFromCam].dSafetyDistVacSideOnSide or 1 -- new -- primo tipo ventose tMainTabPar.V1T1 = mCamData[nNumMachFromCam].sNameVacOnFixBarType1 -- new tMainTabPar.V2T1 = mCamData[nNumMachFromCam].sNameVacOnMob1BarType1 -- new tMainTabPar.V3T1 = mCamData[nNumMachFromCam].sNameVacOnMob2BarType1 -- new tMainTabPar.V1T1E = mCamData[nNumMachFromCam].sNameVacElvOnFixBarType1 -- new tMainTabPar.V2T1E = mCamData[nNumMachFromCam].sNameVacElvOnMob1BarType1 -- new tMainTabPar.V3T1E = mCamData[nNumMachFromCam].sNameVacElvOnMob2BarType1 -- new -- secondo tipo ventose tMainTabPar.V1T2 = mCamData[nNumMachFromCam].sNameVacOnFixBarType2 -- new tMainTabPar.V2T2 = mCamData[nNumMachFromCam].sNameVacOnMob1BarType2 -- new tMainTabPar.V3T2 = mCamData[nNumMachFromCam].sNameVacOnMob2BarType2 -- new tMainTabPar.V1T2E = mCamData[nNumMachFromCam].sNameVacElvOnFixBarType2 -- new tMainTabPar.V2T2E = mCamData[nNumMachFromCam].sNameVacElvOnMob1BarType2 -- new tMainTabPar.V3T2E = mCamData[nNumMachFromCam].sNameVacElvOnMob2BarType2 -- new -- terzo tipo ventose tMainTabPar.V1T3 = mCamData[nNumMachFromCam].sNameVacOnFixBarType3 -- new tMainTabPar.V2T3 = mCamData[nNumMachFromCam].sNameVacOnMob1BarType3 -- new tMainTabPar.V3T3 = mCamData[nNumMachFromCam].sNameVacOnMob2BarType3 -- new tMainTabPar.V1T3E = mCamData[nNumMachFromCam].sNameVacElvOnFixBarType3 -- new tMainTabPar.V2T3E = mCamData[nNumMachFromCam].sNameVacElvOnMob1BarType3 -- new tMainTabPar.V3T3E = mCamData[nNumMachFromCam].sNameVacElvOnMob2BarType3 -- new tMainTabPar.ETM = mCamData[nNumMachFromCam].ExtraThruDepthMachining -- dExtraThruDepth tMainTabPar.OR1 = mCamData[nNumMachFromCam].Ori1 -- Ori1 tMainTabPar.OR2 = mCamData[nNumMachFromCam].Ori2 -- Ori2 tMainTabPar.OR1f = mCamData[nNumMachFromCam].Ori1f -- Ori1f tMainTabPar.OR2f = mCamData[nNumMachFromCam].Ori2f -- Ori2f tMainTabPar.OR1fv = mCamData[nNumMachFromCam].Ori1fv -- Ori1fv tMainTabPar.OR2fv = mCamData[nNumMachFromCam].Ori2fv -- Ori2fv tMainTabPar.OR3f = mCamData[nNumMachFromCam].Ori3f -- Ori3f tMainTabPar.OR4f = mCamData[nNumMachFromCam].Ori4f -- Ori4f tMainTabPar.OR5f = mCamData[nNumMachFromCam].Ori5f -- Ori5f tMainTabPar.OR6f = mCamData[nNumMachFromCam].Ori6f -- Ori6f tMainTabPar.SH1 = mCamData[nNumMachFromCam].Shift1 -- vShiftAct tMainTabPar.SHL = mCamData[nNumMachFromCam].ShiftLck -- vShiftLockSide not used tMainTabPar.DVL = mCamData[nNumMachFromCam].dDistanceVacLeft -- new tMainTabPar.DVR = mCamData[nNumMachFromCam].dDistanceVacRight -- new tMainTabPar.EZPB = mCamData[nNumMachFromCam].dExtraZedProbeBevels -- new tMainTabPar.PTK = mCamData[nNumMachFromCam].dProbeThickness -- new tMainTabPar.MJT = mCamData[nNumMachFromCam].MachineJambsTogether -- MachineJambsTogether -- nome ventosa ad arco e parametri di sicurezza tMainTabPar.AVNM = mCamData[nNumMachFromCam].ArcVacuumName_Mob1 -- new tMainTabPar.ADTG = mCamData[nNumMachFromCam].dArcSafetyDistVacThru or 3 -- new tMainTabPar.ADBG = mCamData[nNumMachFromCam].dArcSafetyDistVacBlind or 45 -- new tMainTabPar.ADSG = mCamData[nNumMachFromCam].dArcSafetyDistVacSide or 1 -- new tMainTabPar.GCDN = mCamData[nNumMachFromCam].nGenCncAsDdfName or 1 -- new tMainTabPar.DACN = mCamData[nNumMachFromCam].nDisableAutoCncName or 0 -- new tMainTabPar.BPLI = mCamData[nNumMachFromCam].BladePerpLeadIn or (3*25.4) -- new tMainTabPar.PRF = mCamData[nNumMachFromCam].PercRedFeed or 0.3 -- new dMinDistGroup = mCamData[nNumMachFromCam].dMinDistBetweenBars or dMinDistGroup -- new tMainTabPar.MPMB = mCamData[nNumMachFromCam].dMaxPosMobBar or 1100.000 -- new DISPMODE = mCamData[nNumMachFromCam].SideDoorDispose or DISPMODE -- SideDoorDispose NUMTABLE = mCamData[nNumMachFromCam].nNumTableOnMachine or NUMTABLE -- new nNumTblForOthMat = mCamData[nNumMachFromCam].nNumTableForOtherMaterial or nNumTblForOthMat -- new nForceAsMultiTbl = mCamData[nNumMachFromCam].nForceUseAsMultiTable or nForceAsMultiTbl -- new tMainTabPar.CUC = mCamData[nNumMachFromCam].nCheckUnderNCollision or 0 -- new tMainTabPar.REF1 = mCamData[nNumMachFromCam].tDefinitionRef1 -- new tMainTabPar.REF2 = mCamData[nNumMachFromCam].tDefinitionRef2 -- new tMainTabPar.REF3 = mCamData[nNumMachFromCam].tDefinitionRef3 -- new tMainTabPar.REF4 = mCamData[nNumMachFromCam].tDefinitionRef4 -- new tMainTabPar.FWHB = mCamData[nNumMachFromCam].nWoodForceHorizMachOnBevelProf -- new tMainTabPar.FSHB = mCamData[nNumMachFromCam].nSteelForceHorizMachOnBevelProf -- new tMainTabPar.FAHB = mCamData[nNumMachFromCam].nAluminForceHorizMachOnBevelProf -- new tMainTabPar.FFHB = mCamData[nNumMachFromCam].nFiberGForceHorizMachOnBevelProf -- new tMainTabPar.NTVR = mCamData[nNumMachFromCam].nNumTotVacRow or 15 -- new tMainTabPar.UVFF = mCamData[nNumMachFromCam].nUseViseForFrames or 0 -- new -- primo tipo morse tMainTabPar.VSF1 = mCamData[nNumMachFromCam].sNameViseOnFixBarType1 -- new -- tolleranza di ricerca per morse tMainTabPar.DTGV = mCamData[nNumMachFromCam].dSafetyDistVisThru or 15 -- new tMainTabPar.DBGV = mCamData[nNumMachFromCam].dSafetyDistVisBlind or 45 -- new tMainTabPar.DSGV = mCamData[nNumMachFromCam].dSafetyDistVisSide or 1 -- new -- codice disposizione frames tMainTabPar.FTDD = mCamData[nNumMachFromCam].FrameTopSideDriveDisp or 0 -- new -- abilitazione collision detect tMainTabPar.ECD = mCamData[nNumMachFromCam].EnableCollisionDetect or 0 -- new -- flag che indica la direzione taglio porta tMainTabPar.CDA = mCamData[nNumMachFromCam].sCutDirectionAdmitted or '' -- new -- parametri per gestione scrap mode (limita le sgrossature solo all'ultima passata) tMainTabPar.RSM = mCamData[nNumMachFromCam].RemoveScrapMode or 0 -- new tMainTabPar.MSV = mCamData[nNumMachFromCam].MinScrapValue or 0 -- new -- parametro esportazione vista tavola tMainTabPar.ETV = mCamData[nNumMachFromCam].ExportTableView or 0 -- new -------------------------------------------------------------------------------- local MTable, MTableOrd local sLocMachId local bOk = true local bFirstStep = true local bShiftMchng = false local bSmallShiftedDoor = false local sDispMode local sNotePhase local sTotDispMode = '' local sNumGroup = '' local bGenFirstStep = false local nIndexStartMach = 1 local bWork = true local sIdList = '' -- variabili utilizzate dentro al ciclo local tMchId = {} local nMchId local sTab local sTabx local tabOri local Ori local vExtraYDelta local ColA local nRaw local tnRaw = {} local bSetTable local bMoveRaw local bTopOnRight local bFrame local bHingeOnRef local bTopOnRef -- variabili per disposizione sottopezzi local dMobOffs1 local dMobOffs2 local dDistMinX local dDistMaxX local dVacOn local dInterAx local bUseOnly2Bars local OffsXSovr = 0 local OffsYSovr = 0 local bUseVise -- variabile per tool setup local bSetUp local MSetup local sSetup local tListError local sListTool -- variabili calcolo box local b3SolidPiece = {} local b3SolidPiece2 = {} local b3SolidOnTab local pMin local pMinRecalc local pMax local dOffsX = 0 local dOffsY = 0 -- variabili conteggio lavorazioni profilatura bevel e saltate local nNumMachSkip = 0 local bLocMach local tsMachProf = {} -- variabile per conteggio lavorazioni local nNumMach = 0 local nNumSkip local tSecMachTab = {} local tSecMachTabOrd = {} -- variabili per fase local nNumPhase local nPrevPhase local nNumCycle = 1 -- variabili per gestione ripresa porta local bFlipFirst local bTopOnRightFirst local sProfiles = '' local nNumGeomBottom = 0 local nNumGeomTop = 0 local pDistToMove local dAngleToAlign = 0 -- variabile materiale porta local bWoodDoor local bSteelDoor local bAlumDoor -- variabili proprietà speciali local bSkinned local bExtruded local bNarrowStile -- variabile check dimensioni porta local bFailDim = false -- variabile forza lavorazioni bevel orizzontali local bForceHorizontalDir = false -- variabile disposizione jambs local nDispJambsMode = 0 -- variabile per disposizione frame local bFlipFrame local bFrameOnNarrow -- tabella lavorazioni local tLocMach = {} local tLocMachOrd = {} local tSplitDoorEnt = {} local tSplitDataInf = {} local bEnBreak = false local bGetSplitCuts = false local nNumProbeZ -- Set Current Machine: si setta sulla fase 1 EgtSetCurrMachine( tMainTabPar.MN) -- raccolgo gli id dei pezzi for v = 1, #tPz do sIdList = sIdList .. '_' .. EgtNumToString(tPz[v],0) end -- faccio tutte le fasi while bWork do -- per ogni pezzo passato for v = 1, #tPz do --nTime = EgtStopCounter() --if not DGD or not DGD.NCGEN then -- EgtOutBox( string.format( 'tempo calcolato sec: %s', (nTime/1000)), 'Time1', 'Time1') --end -- inizializzo il contatore --EgtStartCounter() Pz = tPz[v] sAssemb = tsAssemb[v] -- assegnamento variabili bFrame = sAssemb and string.find( sAssemb, 'frame') == 1 Ls = EgtGetFirstNameInGroup( Pz, 'SOLID') Aux = EgtGetFirstNameInGroup( Pz, 'AUX') tsStringData.sCode = EgtGetInfo( Pz, 'Code') tsDoubleData.dWidthDoor = EgtGetInfo( Pz, 'W', 'd') tsDoubleData.dLengthDoor = EgtGetInfo( Pz, 'H', 'd') tsDoubleData.dThickDoor = EgtGetInfo( Pz, 'T', 'd') tsStringData.sSwing = EgtGetInfo( Pz, 'Swing') tsStringData.sSecure = EgtGetInfo( Pz, 'Secure') tsStringData.sDoorMaterial = EgtGetInfo( Pz, 'Material') tsProperties = EgtSplitString( EgtGetInfo( Pz, 'Properties') or '') tsDoubleData.TypePiece = EgtGetInfo( Pz, 'Piece Type', 'i') tsStringData.sHingeTrim = EgtGetInfo( Pz, 'hingeedge_trimming') tsStringData.sLockTrim = EgtGetInfo( Pz, 'lockedge_trimming') tsStringData.sTopTrim = EgtGetInfo( Pz, 'top_trimming') tsStringData.sBottomTrim = EgtGetInfo( Pz, 'bottom_trimming') tsBoolData.bHingeMach = EgtGetInfo( Pz, 'hingeedge_machining', 'b') tsBoolData.bLockMach = EgtGetInfo( Pz, 'lockedge_machining', 'b') tsBoolData.bTopMach = EgtGetInfo( Pz, 'top_machining', 'b') tsBoolData.bBottomMach = EgtGetInfo( Pz, 'bottom_machining', 'b') tsDoubleData.dTopRadius = EgtGetInfo( Pz, 'top_radius', 'd') tsDoubleData.dTopAngle = EgtGetInfo( Pz, 'top_angle', 'd') tsDoubleData.dTopxDeltapos = EgtGetInfo( Pz, 'top_xdeltapos', 'd') tsBoolData.bSwingDriveDisp = EgtGetInfo( Pz, 'SwingDriveDisp', 'b') tsBoolData.bFrameOnWide = EgtGetInfo( Pz, 'FrameDispositionOnSide', 'b') tsRadiusProf[1] = EgtGetInfo( Pz, 'RadHingeProfile', 'd') tsRadiusProf[2] = EgtGetInfo( Pz, 'RadLockProfile', 'd') tsRadiusProf[3] = EgtGetInfo( Pz, 'RadTopProfile', 'd') tsRadiusProf[4] = EgtGetInfo( Pz, 'RadBottomProfile', 'd') tsPlaneProf[1] = EgtGetInfo( Pz, 'PlnHingeProfile', 'd') tsPlaneProf[2] = EgtGetInfo( Pz, 'PlnLockProfile', 'd') tsPlaneProf[3] = EgtGetInfo( Pz, 'PlnTopProfile', 'd') tsPlaneProf[4] = EgtGetInfo( Pz, 'PlnBottomProfile', 'd') tsDispJambByMat[1] = EgtGetInfo( Pz, 'DisposeWJambsOnSide', 'i') tsDispJambByMat[2] = EgtGetInfo( Pz, 'DisposeSJambsOnSide', 'i') tsDispJambByMat[3] = EgtGetInfo( Pz, 'DisposeAJambsOnSide', 'i') tsDispJambByMat[4] = EgtGetInfo( Pz, 'DisposeFJambsOnSide', 'i') nProbeMode = EgtGetInfo( Pz, 'ProbeMode', 'i') or 0 nPostProbeSet = EgtGetInfo( Pz, 'PostProbeSet', 'i') or 0 tsDoubleData.dLeftOffs = EgtGetInfo( EgtGetFirstNameInGroup( Pz, 'Left') or GDB_ID.NULL, 'Offs', 'd') or 0 tsDoubleData.dRightOffs = EgtGetInfo( EgtGetFirstNameInGroup( Pz, 'Right') or GDB_ID.NULL, 'Offs', 'd') or 0 tsDoubleData.dTopOffs = EgtGetInfo( EgtGetFirstNameInGroup( Pz, 'Top') or GDB_ID.NULL, 'Offs', 'd') or 0 tsDoubleData.dBottomOffs = EgtGetInfo( EgtGetFirstNameInGroup( Pz, 'Bottom') or GDB_ID.NULL, 'Offs', 'd') or 0 -- flag posizione serratura ( vero se serratura a destra) tsBoolData.bAtRight = ( tsStringData.sSwing:sub(1,1) == 'L') -- setto il movimento di apertura della porta if tsStringData.sSwing == 'RH' or tsStringData.sSwing == 'RHA' or tsStringData.sSwing == 'RHI' or tsStringData.sSwing == 'LH' or tsStringData.sSwing == 'LHI' or tsStringData.sSwing == 'LHA' then bPush = true else bPush = false end if bFirstStep and not bShiftMchng then if v == 1 and tMainTabPar.GCDN == 0 then -- solo il primo pezzo e se il flag ha valore nullo -- assegno al nome file il nome del campo Code del ddf -- di default è uguale al nome del file ddf sFileName = tsStringData.sCode end -- determino se la porta ha il materiale bWoodDoor = FindMaterial( tsStringData.sDoorMaterial, 'wood') -- per wood ddors bSteelDoor = FindMaterial( tsStringData.sDoorMaterial, 'steel') -- old nNumProperties = 4 -- per steeldoors bAlumDoor = FindMaterial( tsStringData.sDoorMaterial, 'aluminum') -- per aluminum doors if bWoodDoor then ColA = Color3d( 255, 165, 0, 25) -- setto forzatura lavorazioni orizzontali in base alla variabile nel CurrCamInfo inerente al materiale if tMainTabPar.FWHB and tMainTabPar.FWHB > 0 then bForceHorizontalDir = true end -- setto disposizione frame in base alla nota del pezzo (proviene dal file CurrDoorCustomData) if tsDispJambByMat[1] then nDispJambsMode = tsDispJambByMat[1] end elseif bSteelDoor then ColA = Color3d( 167,196,197, 25) -- setto forzatura lavorazioni orizzontali in base alla variabile nel CurrCamInfo inerente al materiale if tMainTabPar.FSHB and tMainTabPar.FSHB > 0 then bForceHorizontalDir = true end -- setto disposizione frame in base alla nota del pezzo (proviene dal file CurrDoorCustomData) if tsDispJambByMat[2] then nDispJambsMode = tsDispJambByMat[2] end elseif bAlumDoor then ColA = Color3d( 208,213,217, 25) -- setto forzatura lavorazioni orizzontali in base alla variabile nel CurrCamInfo inerente al materiale if tMainTabPar.FAHB and tMainTabPar.FAHB > 0 then bForceHorizontalDir = true end -- setto disposizione frame in base alla nota del pezzo (proviene dal file CurrDoorCustomData) if tsDispJambByMat[3] then nDispJambsMode = tsDispJambByMat[3] end else ColA = Color3d( 255, 165, 0, 25) -- setto forzatura lavorazioni orizzontali in base alla variabile nel CurrCamInfo inerente al materiale if tMainTabPar.FFHB and tMainTabPar.FFHB > 0 then bForceHorizontalDir = true end -- setto disposizione frame in base alla nota del pezzo (proviene dal file CurrDoorCustomData) if tsDispJambByMat[4] then nDispJambsMode = tsDispJambByMat[4] end end -- se pezzo ( porta o telaio) in alluminio o acciaio if bAlumDoor or bSteelDoor then -- setto a 0 tutti i sovramateriali e li segno da non lavorare tsDoubleData.dLeftOffs = 0 tsDoubleData.dRightOffs = 0 tsDoubleData.dTopOffs = 0 tsDoubleData.dBottomOffs = 0 tsBoolData.bHingeMach = false tsBoolData.bLockMach = false tsBoolData.bTopMach = false tsBoolData.bBottomMach = false end -- determino se la porta ha speciali proprietà bSkinned = FindProperty( tsProperties, 'skinned') -- old nNumProperties = 1 -- per skinned bExtruded = FindProperty( tsProperties, 'extruded') -- old nNumProperties = 2 -- per extruded bNarrowStile = FindProperty( tsProperties, 'narrowstile') -- old nNumProperties = 3 -- per narrowstile -- ottengo la tabella corrente del primo pezzo MachiningsTable = EgtGetInfo( tPz[1], 'MTable') -- Box pezzo table.insert( tb3Part, v, EgtGetBBoxGlob( Pz, GDB_BB.EXACT)) local b3fx = BBox3d() -- inizializzo il box nullo b3fx = MakeBoxFromSolidLayer( Ls, nProbeMode, Aux) table.insert( tb3Solid, v, b3fx) end -- assegno i box del pezzo b3Part = tb3Part[v] b3Solid = tb3Solid[v] if v == 1 then -- solo il primo pezzo if bFirstStep and not bShiftMchng then -- *** settaggi CAM *** -- Mtable 1 if not MachiningsTable then -- se non c'è il nome della MTable esco DGD.ERR = 34 local sErrMess = string.format(EgtDoorsMsg[597], MachiningsTable) DGD.EMC = DGD.EMC .. '\n' .. sErrMess WriteErrFile( sFileDir..sFileName..'.txt') DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) DoorOutLog( sErrMess, 0) -- errore, file di tabella non trovato -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then EgtOutBox( sErrMess, EgtDoorsMsg[476], EgtDoorsMsg[477]) end return false end EgtAddToPackagePath( sBaseDir .. 'MTables\\?.mtl') if EgtExistsFile( sBaseDir .. 'MTables\\' .. MachiningsTable .. '.mtl') then TAB = require( MachiningsTable) if not TAB then DGD.ERR = 27 local sErrMess = string.format(EgtDoorsMsg[490], sBaseDir .. 'MTables\\' .. MachiningsTable .. '.mtl') DGD.EMC = DGD.EMC .. '\n' .. sErrMess WriteErrFile( sFileDir..sFileName..'.txt') DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) DoorOutLog( sErrMess, 0) -- errore tabella non trovata nel file if not DGD or not DGD.NCGEN then EgtOutBox( sErrMess, EgtDoorsMsg[476], EgtDoorsMsg[477]) end return false end else DGD.ERR = 35 local sErrMess = string.format(EgtDoorsMsg[597], sBaseDir .. 'MTables\\' .. MachiningsTable .. '.mtl') DGD.EMC = DGD.EMC .. '\n' .. sErrMess WriteErrFile( sFileDir..sFileName..'.txt') DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) DoorOutLog( sErrMess, 0) -- errore, file di tabella non trovato -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then EgtOutBox( sErrMess, EgtDoorsMsg[476], EgtDoorsMsg[477]) end return false end MachinesName = TAB.MMachineData if not MachinesName then DGD.ERR = 29 local sErrMess = string.format(EgtDoorsMsg[491], '') DGD.EMC = DGD.EMC .. '\n' .. sErrMess WriteErrFile( sFileDir..sFileName..'.txt') DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) DoorOutLog( sErrMess, 0) -- Errore! Nome macchina: non presente in MTable if not DGD or not DGD.NCGEN then EgtOutBox( sErrMess, EgtDoorsMsg[476], EgtDoorsMsg[477]) end return false end -- *** settaggi CAM *** -- Mtable 2 MachiningsTableOrd = MachiningsTable..'_'..EgtNumToString(nNumMachFromTable, 0) EgtAddToPackagePath( sBaseDir .. 'MTables\\?.otl') if EgtExistsFile( sBaseDir .. 'MTables\\' .. MachiningsTableOrd .. '.otl') then TABORD = require( MachiningsTableOrd) if not TABORD then DGD.ERR = 30 local sErrMess = string.format(EgtDoorsMsg[490], sBaseDir .. 'MTables\\' .. MachiningsTableOrd .. '.otl') DGD.EMC = DGD.EMC .. '\n' .. sErrMess WriteErrFile( sFileDir..sFileName..'.txt') DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) DoorOutLog( sErrMess, 0) -- errore tabella non trovata nel file -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then EgtOutBox( sErrMess, EgtDoorsMsg[476], EgtDoorsMsg[477]) end return false end else DGD.ERR = 31 local sErrMess = string.format(EgtDoorsMsg[597], sBaseDir .. 'MTables\\' .. MachiningsTableOrd .. '.otl') DGD.EMC = DGD.EMC .. '\n' .. sErrMess WriteErrFile( sFileDir..sFileName..'.txt') DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) DoorOutLog( sErrMess, 0) -- errore, file di tabella non trovato -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then EgtOutBox( sErrMess, EgtDoorsMsg[476], EgtDoorsMsg[477]) end return false end -- se non devo generare il cn esco subito if MachinesName[nNumMachFromTable].NcGenerate ~= nil and not MachinesName[nNumMachFromTable].NcGenerate then DoorOutLog( string.format(EgtDoorsMsg[492], tMainTabPar.MN), 0) -- warning. Cnc generation disable return true end if tsStringData.sHingeTrim ~= 'SQ' and tsStringData.sHingeTrim ~= 'EB' and bNarrowStile then DGD.ERR = 32 local sErrMess = string.format(EgtDoorsMsg[636], '') DGD.EMC = DGD.EMC .. '\n' .. sErrMess WriteErrFile( sFileDir..sFileName..'.txt') DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) DoorOutLog( sErrMess, 0) -- errore, la proprietà narrow stile è compatibile solo con lato bevel -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then EgtOutBox( sErrMess, EgtDoorsMsg[476], EgtDoorsMsg[477]) end return false end MTable = TAB.MTable MTableOrd = TABORD.MTable end end sDispMode = '' if bFirstStep and not bShiftMchng then if v == 1 then nNumGroup = nNumGroup + 1 end -- Set Machining Group if not sAssemb then -- se pezzo unico nMchId = EgtAddMachGroup( 'Mach_' .. EgtNumToString(nNumGroup, 0) .. '_' .. tMainTabPar.MN) else -- creo gruppo lavoro if v == 1 then nMchId = EgtAddMachGroup( 'Ids'.. sIdList ..'_'..'Mach_' .. EgtNumToString(nNumGroup, 0) .. '_' .. tMainTabPar.MN) end end if nMchId then if tMainTabPar.DACN == 1 then local sLocNumGroup = '' if nNumGroup > 1 then sLocNumGroup = '_'..EgtNumToString(nNumGroup, 0) end EgtSetInfo( nMchId, 'NcName', sFileName .. sLocNumGroup .. EgtIf( nProbeMode ~= 1,'.cnc','.prb')) end -- assegno al gruppo di lavoro l'info relativo allo stato del controllo collisione EgtSetInfo( nMchId, 'EnableCollisionDetect', tMainTabPar.ECD) -- Simulation for collision check if tMainTabPar.ECD == 1 then EgtSetInfo( nMchId, 'Vm', '1') end -- metto il gruppo lavorazione nella tabella table.insert( tMchId, { tMainTabPar.MN, nMchId, Pz}) end nNumPhase = EgtGetCurrPhase() else if v == 1 then -- -- se non c'è probe mode (prod) e abilitata la tastatura di fianco filtro le geometrie che si trovano sopra e sotto -- if nProbeMode == 0 and nPostProbeSet >= 3 then -- -- Cancello i percorsi _HIDE di sideprobe perchè se viene ribaltata la porta la posizione del percorso _HIDE viene a -- -- trovarsi a filo ventose -- local DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint_HIDE') -- -- ciclo su tutte le entità trovate -- for j = 1, #DelList do -- EgtErase( DelList[j] ) -- end -- end -- se nessuna lavorazione riutilizzo la vecchia fase if nNumMach == 0 then -- elimino i vecchi grezzi for t = 1, #tnRaw do EgtRemoveRawPart( tnRaw[t]) -- elimino il grezzo end -- elimino la disposizione dei sottopezzi local nNumFix = EgtGetFirstFixture() while nNumFix do EgtRemoveFixture( nNumFix) nNumFix = EgtGetFirstFixture() end else nPrevPhase = nNumPhase nNumPhase = EgtAddPhase() -- creo nuova fase end end -- rendo corrente la fase if nNumPhase then EgtSetCurrPhase(nNumPhase) end end ----------------------------------------------------------------------- -- Calcolo dei sovramateriali e definizione e posizionamento del grezzo ----------------------------------------------------------------------- if bFirstStep and not bShiftMchng then -- se check macchina settato per non gestire grezzo if MachinesName[nNumMachFromTable].MakeRaw ~= nil and not MachinesName[nNumMachFromTable].MakeRaw then tsDoubleData.dLeftOffs = 0 tsDoubleData.dRightOffs = 0 tsDoubleData.dTopOffs = 0 tsDoubleData.dBottomOffs = 0 end else -- fase successiva ribaltata o spostata -- i profili con lavorazione disabilitata li posso mettere subito a zero if ( not tsBoolData.bLockMach and tsBoolData.bAtRight) or ( not tsBoolData.bHingeMach and not tsBoolData.bAtRight) then -- lavorazione lato destro disabilitata tsDoubleData.dRightOffs = 0 end if ( not tsBoolData.bLockMach and not tsBoolData.bAtRight) or ( not tsBoolData.bHingeMach and tsBoolData.bAtRight) then -- lavorazione lato sinistro disabilitata tsDoubleData.dLeftOffs = 0 end if not tsBoolData.bTopMach then -- lavorazione lato top disabilitata tsDoubleData.dTopOffs = 0 end if not tsBoolData.bBottomMach then -- lavorazione lato top disabilitata tsDoubleData.dBottomOffs = 0 end -- azzero i sovramateriali dei profili che sono stati lavorati if tsMachProf and #tsMachProf[v] > 0 then local sListProf = EgtSplitString( tsMachProf[v], ',') for m = 1, #sListProf do if string.lower( sListProf[m]) == 'left' then tsDoubleData.dLeftOffs = 0 elseif string.lower( sListProf[m]) == 'right' then tsDoubleData.dRightOffs = 0 elseif string.lower( sListProf[m]) == 'top' then tsDoubleData.dTopOffs = 0 elseif string.lower( sListProf[m]) == 'bottom' then tsDoubleData.dBottomOffs = 0 end end end end -- in base ai valori di sovramateriale sui lati, se tutti sono al di sotto di 3 volte il valore di attivazione della sgrossatura -- allora disabilito lo scrapmode if tsDoubleData.dLeftOffs < tMainTabPar.MSV and tsDoubleData.dRightOffs < tMainTabPar.MSV and tsDoubleData.dTopOffs < tMainTabPar.MSV and tsDoubleData.dBottomOffs < tMainTabPar.MSV then tMainTabPar.RSM = 0 end -- se sono in ribaltamento e in rebuild della porta devo ruotare la porta -- con il lato opposto parallelo a Y (prima della disposizione) if not bFirstStep and nProbeMode == 2 then local nRecId = EgtGetFirstNameInGroup( Pz, 'REC') local nSideToAlign local sSideToAlign local nSideToAlignMid local sSideToAlignMid local nSideToAlignTop local sSideToAlignTop local bInvert if ( bFlipFirst and bTopOnRightFirst) or ( not bFlipFirst and not bTopOnRightFirst) then sSideToAlign = 'Right' sSideToAlignMid = 'RightMid' sSideToAlignTop = 'RightTop' bInvert = false else sSideToAlign = 'Left' sSideToAlignMid = 'LeftMid' sSideToAlignTop = 'LeftTop' bInvert = true end nSideToAlign = EgtGetFirstNameInGroup( nRecId, sSideToAlign) nSideToAlignMid = EgtGetFirstNameInGroup( nRecId, sSideToAlignMid) nSideToAlignTop = EgtGetFirstNameInGroup( nRecId, sSideToAlignTop) local vVectorToAlign if nSideToAlign then if bInvert then vVectorToAlign = EgtSV( nSideToAlign) dAngleToAlign = atan(vVectorToAlign:getX(),vVectorToAlign:getY()) - 180 else vVectorToAlign = EgtSV( nSideToAlign) dAngleToAlign = atan(vVectorToAlign:getX(),vVectorToAlign:getY()) end -- allineo il pezzo prendendo il riferimento del lato opposto al lato riferito nella prima fase EgtRotate( Pz , ORIG(), Z_AX(), dAngleToAlign ) -- muovo la porta nelle origini if ( bFlipFirst and bTopOnRightFirst) or ( not bFlipFirst and not bTopOnRightFirst) then -- lato allineato right if tsBoolData.bAtRight then -- se serratura a destra if tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BU' or tsStringData.sLockTrim == 'BDEB' or tsStringData.sLockTrim == 'BUEB' then -- se profilo bevel if bPush then -- se porta a spingere prendo come riferimento lato bottom pDistToMove = EgtSP(nSideToAlign, GDB_ID.ROOT) else -- prendo riferimento da lato top pDistToMove = EgtSP(nSideToAlignTop, GDB_ID.ROOT) end elseif tsStringData.sLockTrim == 'CV' then -- prendo riferimento da lato bottom (o top) pDistToMove = EgtSP(nSideToAlign, GDB_ID.ROOT) else -- prendo riferimento da lato medio pDistToMove = EgtSP(nSideToAlignMid, GDB_ID.ROOT) end else if tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BU' or tsStringData.sHingeTrim == 'BDEB' or tsStringData.sHingeTrim == 'BUEB' then -- se profilo bevel if bPush then -- se porta a spingere prendo come riferimento lato bottom pDistToMove = EgtSP(nSideToAlign, GDB_ID.ROOT) else -- prendo riferimento da lato top pDistToMove = EgtSP(nSideToAlignTop, GDB_ID.ROOT) end elseif tsStringData.sHingeTrim == 'CV' then -- prendo riferimento da lato bottom (o top) pDistToMove = EgtSP(nSideToAlign, GDB_ID.ROOT) else -- prendo riferimento da lato medio pDistToMove = EgtSP(nSideToAlignMid, GDB_ID.ROOT) end end else -- lato allineato left if tsBoolData.bAtRight then -- se serratura a destra if tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BU' or tsStringData.sHingeTrim == 'BDEB' or tsStringData.sHingeTrim == 'BUEB' then -- se profilo bevel if bPush then -- se porta a spingere prendo come riferimento lato bottom pDistToMove = EgtEP(nSideToAlign, GDB_ID.ROOT) else -- prendo riferimento da lato top pDistToMove = EgtEP(nSideToAlignTop, GDB_ID.ROOT) end elseif tsStringData.sHingeTrim == 'CV' then -- prendo riferimento da lato bottom (o top) pDistToMove = EgtEP(nSideToAlign, GDB_ID.ROOT) else -- prendo riferimento da lato medio pDistToMove = EgtEP(nSideToAlignMid, GDB_ID.ROOT) end else if tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BU' or tsStringData.sLockTrim == 'BDEB' or tsStringData.sLockTrim == 'BUEB' then -- se profilo bevel if bPush then -- se porta a spingere prendo come riferimento lato bottom pDistToMove = EgtEP(nSideToAlign, GDB_ID.ROOT) else -- prendo riferimento da lato top pDistToMove = EgtEP(nSideToAlignTop, GDB_ID.ROOT) end elseif tsStringData.sLockTrim == 'CV' then -- prendo riferimento da lato bottom (o top) pDistToMove = EgtEP(nSideToAlign, GDB_ID.ROOT) else -- prendo riferimento da lato medio pDistToMove = EgtEP(nSideToAlignMid, GDB_ID.ROOT) end end end -- muovo il pezzo sull'origine EgtMove( Pz, ORIG() - Point3d( pDistToMove:getX(), pDistToMove:getY(), 0), GDB_RT.GLOB) -- ricalcolo il box del solido b3Solid = MakeBoxFromSolidLayer( Ls, nProbeMode, Aux) -- ricalcolo il box del pezzo b3Part = EgtGetBBoxGlob( Pz, GDB_BB.EXACT) end -- bEnBreak = true -- bWork = false -- break end if bFirstStep then table.insert( b3SolidPiece, EgtGetBBoxGlob( Pz, GDB_BB.EXACT)) else table.insert( b3SolidPiece2, EgtGetBBoxGlob( Pz, GDB_BB.EXACT)) end if b3SolidPiece[v] and b3SolidPiece2[v] and nProbeMode ~= 2 then dOffsX = b3SolidPiece2[v]:getMin():getX() - b3SolidPiece[v]:getMin():getX() dOffsY = b3SolidPiece2[v]:getMin():getY() - b3SolidPiece[v]:getMin():getY() else dOffsX = 0 dOffsY = 0 end nRaw = EgtAddRawPart( Point3d(0,0,0),b3Solid:getDimX() + tsDoubleData.dLeftOffs + tsDoubleData.dRightOffs, b3Solid:getDimY() + tsDoubleData.dTopOffs + tsDoubleData.dBottomOffs, b3Solid:getDimZ(), ColA) table.insert( tnRaw, v, nRaw) EgtAddPartToRawPart( Pz, b3Part:getMin() - b3Solid:getMin() + Vector3d( tsDoubleData.dLeftOffs + dOffsX, tsDoubleData.dBottomOffs + dOffsY, 0), nRaw) if not bFirstStep and nProbeMode == 2 then -- contromovimento e controrotazione del pezzo per riportarlo nelle condizioni originarie EgtResetCurrMachGroup() EgtMove( Pz, Point3d( pDistToMove:getX(), pDistToMove:getY(), 0) - ORIG(), GDB_RT.GLOB) EgtRotate( Pz , ORIG(), Z_AX(), -dAngleToAlign ) EgtSetCurrMachGroup() EgtSetCurrPhase(nNumPhase) end if bFirstStep then -- se pezzo del telaio faccio l'opportuna rotazione -- nDispJambsMode = 1: geometria verso il basso; = 2: geometria verso l'alto if bFrame then if nDispJambsMode > 0 then bFlipFrame = false if sAssemb == 'framesx' and not tsBoolData.bFrameOnWide then bFrameOnNarrow = true if (bPush and nDispJambsMode == 1) or (not bPush and nDispJambsMode == 2) then EgtRotateRawPart( nRaw , Y_AX(), 90) EgtRotateRawPart( nRaw , Z_AX(), 180) else EgtRotateRawPart( nRaw , Y_AX(), -90) EgtRotateRawPart( nRaw , Z_AX(), 180) bFlipFrame = true end elseif sAssemb == 'framedx' and not tsBoolData.bFrameOnWide then bFrameOnNarrow = true if (bPush and nDispJambsMode == 1) or (not bPush and nDispJambsMode == 2) then EgtRotateRawPart( nRaw , Y_AX(), -90) EgtRotateRawPart( nRaw , Z_AX(), 180) else EgtRotateRawPart( nRaw , Y_AX(), 90) EgtRotateRawPart( nRaw , Z_AX(), 180) bFlipFrame = true end elseif sAssemb == 'frametop' and not tsBoolData.bFrameOnWide then bFrameOnNarrow = true if (bPush and nDispJambsMode == 1) or (not bPush and nDispJambsMode == 2) then EgtRotateRawPart( nRaw , Y_AX(), 90) EgtRotateRawPart( nRaw , Z_AX(), 180) else EgtRotateRawPart( nRaw , Y_AX(), -90) EgtRotateRawPart( nRaw , Z_AX(), 180) bFlipFrame = true end elseif sAssemb == 'framebot' and not tsBoolData.bFrameOnWide then bFrameOnNarrow = true if (bPush and nDispJambsMode == 1) or (not bPush and nDispJambsMode == 2) then EgtRotateRawPart( nRaw , Y_AX(), -90) EgtRotateRawPart( nRaw , Z_AX(), 180) else EgtRotateRawPart( nRaw , Y_AX(), 90) EgtRotateRawPart( nRaw , Z_AX(), 180) bFlipFrame = true end end end -- se non è un frame disposto sul lato narrow verifico se il flag abilita le morse if not bFrameOnNarrow then bUseVise = tMainTabPar.UVFF and tMainTabPar.UVFF == 1 end end end if bFirstStep and nProbeMode == 2 then local dtempX = EgtIf( abs(b3Solid:getMin():getX()) < abs(b3Solid:getMax():getX()), b3Solid:getMin():getX(), b3Solid:getMax():getX()) local dtempY = EgtIf( abs(b3Solid:getMin():getY()) < abs(b3Solid:getMax():getY()), b3Solid:getMin():getY(), b3Solid:getMax():getY()) pMinRecalc = Point3d( dtempX, dtempY, 0) else pMinRecalc = Point3d( 0, 0, 0) end -- fase premach, in base al profilo cerniere e/o serratura, e se ci sono lavorazioni sopra o sotto o entrambe, -- decido su quale lato disporre la porta per evitare inutili ribaltamenti -- ricavo minimo e massimo del solido del pezzo b3SolidOnTab = EgtGetBBoxGlob( Ls, GDB_BB.EXACT) pMin = b3SolidOnTab:getMin() pMax = b3SolidOnTab:getMax() if v == 1 then -- solo il primo pezzo if bFirstStep then tLocMach = MTable tLocMachOrd = MTableOrd if not bShiftMchng then nIndexStartMach = 1 end else tLocMach = tSecMachTab tLocMachOrd = MTableOrd if not bShiftMchng then nIndexStartMach = 1 end end end if bFirstStep and not bShiftMchng then tsMachProf[v] = '' end if v == #tPz then -- solo all'ultimo pezzo -- solo il primo giro, prendo nota dei profili tipo bevel -- verifico se cave da sotto o da sopra -- verifico se trovate lavorazioni applicate con 'shift' if bFirstStep and not bShiftMchng then local nUnderGeom local tGeomThruUp = {} local tGeomThruDw = {} local tGeomBlindUp = {} local tGeomBlindDw = {} for i = 1, #tLocMach do if tLocMach[i].On ~= 0 then sLocMachId = tLocMach[i].MachId -- se non c'è il campo macchina setto di default la 1 if not sLocMachId then sLocMachId = 1 end -- se macchina corrispondente if sLocMachId == nNumMachFromTable then -- prendo i profili bevel direttamente dalla tabella local sUpperProfName = string.upper(tLocMach[i].Name) if tLocMach[i].Oper and tLocMach[i].Oper == 'AdjustBevel' then if not string.find( sProfiles, sUpperProfName .. ',') then sProfiles = sProfiles .. sUpperProfName .. ',' end end -- Recupero le entità local EntList = MB.FindEntitiesWithName( tPz, tLocMach[i].Name) -- se è una porta if not bFrame then -- se flag non ancora settato e trovata geometria e l'associazione è shiftata .. -- setto il flag di disposizione iniziale Traslata if not bSmallShiftedDoor and #EntList > 0 and tLocMach[i].Shift and tLocMach[i].Shift > 0 then bSmallShiftedDoor = true end end -- Test delle lavorazioni for j = 1, #EntList do local nTypeGeom = 0 -- OPERAZIONI if tLocMach[i].Oper == 'AdjustThrouIsle' then bLocMach, nUnderGeom, nTypeGeom = MB.TestThrouIsle( EntList[j], b3Solid:getDimZ(), pMin, pMax, bWorkUnder) if bLocMach then if nUnderGeom and nUnderGeom == 1 then nNumGeomBottom = nNumGeomBottom + 1 elseif nUnderGeom and nUnderGeom == -1 then nNumGeomTop = nNumGeomTop + 1 end end if nTypeGeom == 1 then -- se passante up table.insert( tGeomThruUp, EntList[j]) elseif nTypeGeom == 2 then -- se passante dw table.insert( tGeomThruDw, EntList[j]) elseif nTypeGeom == 3 then -- se cieca up table.insert( tGeomBlindUp, EntList[j]) elseif nTypeGeom == 4 then -- se cieca dw table.insert( tGeomBlindDw, EntList[j]) end elseif tLocMach[i].Oper == 'AdjustVertHole' then bLocMach, nUnderGeom, nTypeGeom = MB.TestVertHole( EntList[j], b3Solid:getDimZ(), pMin, pMax, bWorkUnder) if bLocMach then if nUnderGeom and nUnderGeom == 1 then nNumGeomBottom = nNumGeomBottom + 1 elseif nUnderGeom and nUnderGeom == -1 then nNumGeomTop = nNumGeomTop + 1 end end if nTypeGeom == 1 then -- se passante up table.insert( tGeomThruUp, EntList[j]) elseif nTypeGeom == 2 then -- se passante dw table.insert( tGeomThruDw, EntList[j]) elseif nTypeGeom == 3 then -- se cieca up table.insert( tGeomBlindUp, EntList[j]) elseif nTypeGeom == 4 then -- se cieca dw table.insert( tGeomBlindDw, EntList[j]) end elseif tLocMach[i].Oper == 'AdjustBevel' then table.insert( tGeomThruUp, EntList[j]) elseif tLocMach[i].Oper == 'AdjustThrouCurve' then table.insert( tGeomThruUp, EntList[j]) elseif tLocMach[i].Oper == 'AdjPrfThrouCurve' then table.insert( tGeomThruUp, EntList[j]) end end end end end -- in base al tipo e al numero geometrie, vedo se invertire una sola geometria if #tGeomThruUp == 1 and #tGeomThruDw == 0 and #tGeomBlindUp == 0 and #tGeomBlindDw > 1 then -- se condizione per invertire l'unica geometria UP if nNumGeomBottom > 0 then MB.InvertGeom(tGeomThruUp[1]) end end if #tGeomThruDw == 1 and #tGeomThruUp == 0 and #tGeomBlindDw == 0 and #tGeomBlindUp > 1 then -- se condizione per invertire l'unica geometria UP if nNumGeomTop > 0 then MB.InvertGeom(tGeomThruDw[1]) end end elseif not bFirstStep and not bShiftMchng then -- se porta ribaltata for i = 1, #tLocMach do if tLocMach[i].On ~= 0 then sLocMachId = tLocMach[i].MachId -- se non c'è il campo macchina setto di default la 1 if not sLocMachId then sLocMachId = 1 end if sLocMachId == nNumMachFromTable then -- Recupero le entità local EntList = MB.FindEntitiesWithName( tPz, tLocMach[i].Name) -- se è una porta if not bFrame then -- se flag non ancora settato e trovata geometria e l'associazione è shiftata -- setto il flag di disposizione iniziale Traslata if not bSmallShiftedDoor and #EntList > 0 and tLocMach[i].Shift and tLocMach[i].Shift > 0 then bSmallShiftedDoor = true end end end end end end -- se porta da disporre subito traslata o attiva proprietà narrow stile, setto i flag if bSmallShiftedDoor or ( not bFrame and bNarrowStile) then -- se narrowstile attiva, ricalcolo il valore dello shift -- come differenza tra l'origine della porta e l'origine della barra fissa if bNarrowStile then if DISPMODE > 0 then -- se porta disposta a sinistra tMainTabPar.SH1 = tMainTabPar.OR1f - tMainTabPar.OR1 else -- altrimenti porta disposta a destra tMainTabPar.SH1 = tMainTabPar.OR2f - tMainTabPar.OR2 end end bShiftMchng = true -- porta traslata bGenFirstStep = true -- flag per saltare il primo giro end end ----------------------- -- *** Disposizione *** ----------------------- if v == 1 then -- solo il primo pezzo local sTabPrev = sTab -- Scelta della tavola (per ora gestisco max 2 tavole) if NUMTABLE and NUMTABLE > 1 then -- se ho la seconda tavola if nForceAsMultiTbl and nForceAsMultiTbl > 0 then sTab = string.format( 'Tab%s', nForceAsMultiTbl) -- setto la tavola EgtSetInfo( Pz, 'TableUsed', nForceAsMultiTbl) else -- altrimenti assegno la tavola in base al materiale if bWoodDoor then -- se ho una wood door la metto sulla prima -- se altro materiale messo sulla tavola 1 lo standard lo metto sulla seconda if nNumTblForOthMat and nNumTblForOthMat == 1 then -- se ho il numero tavola per altro materiale sTab = string.format( 'Tab%s', NUMTABLE) -- setto la tavola EgtSetInfo( Pz, 'TableUsed', NUMTABLE) else -- altrimenti forzo sulla prima tavola sTab = 'Tab1' -- setto la prima tavola EgtSetInfo( Pz, 'TableUsed', 1) end elseif bSteelDoor then -- se ho una steel door la metto sulla seconda tavola if nNumTblForOthMat and nNumTblForOthMat > 0 then -- se ho il numero tavola per altro materiale sTab = string.format( 'Tab%s', nNumTblForOthMat) -- setto la tavola EgtSetInfo( Pz, 'TableUsed', nNumTblForOthMat) else -- altrimenti forzo sulla seconda tavola sTab = 'Tab2' -- setto la seconda EgtSetInfo( Pz, 'TableUsed', 2) end else -- altrimenti materiale standard -- se altro materiale messo sulla tavola 1 lo standard lo metto sulla seconda if nNumTblForOthMat and nNumTblForOthMat == 1 then -- se ho il numero tavola per altro materiale sTab = string.format( 'Tab%s', NUMTABLE) -- setto la tavola EgtSetInfo( Pz, 'TableUsed', NUMTABLE) else -- altrimenti forzo sulla prima tavola sTab = 'Tab1' -- setto la prima tavola EgtSetInfo( Pz, 'TableUsed', 1) end end end else -- se macchina ha solo una tavola -- se uso macchina con due tavole ma forzata a una sola tavola (solo la 1) if nForceAsMultiTbl then if nForceAsMultiTbl > 0 then sTab = string.format( 'Tab%s', nForceAsMultiTbl) -- setto la tavola EgtSetInfo( Pz, 'TableUsed', nForceAsMultiTbl) else sTab = 'Tab1' -- setto la prima tavola EgtSetInfo( Pz, 'TableUsed', 1) sTabx = 'Tab' end else sTab = 'Tab' EgtSetInfo( Pz, 'TableUsed', 1) end end if bFirstStep then bSetTable = EgtSetTable( sTab) if not bSetTable then -- se sono nel caso che ho una sola tavola, probabilmente usa il nome semplice della tavola if sTabx and sTabx ~= sTab then sTab = sTabx bSetTable = EgtSetTable( sTab) end if not bSetTable then bOk = false DGD.EMC = ' ' .. EgtDoorsMsg[676]..EgtDoorsMsg[682] -- Error in table setting. break end end else if sTabPrev ~= sTab then sTab = sTabPrev end end -- Origine tavola corrente rispetto a Zero macchina (anche se la macchina ha 2 tavole si deve mettere l'indice 1) tabOri = EgtGetTableRef( 1) end -- Rotazione porta in base alla macchina bMoveRaw = false local nCodeVacDisp = 0 -- definito col cliente: prima comanda il lato hinge, se ha il bevel lo si dispone secondo quello che c'è nel ddf -- se il lato hinge non ha profilo bevel si guarda il profilo lock, se ha un bevel allora guardo quello. -- in caso di inactive doors con bevel paralleli comanda ovviamente il lato hinge -- in caso nessuno dei due lati ha un profilo bevel, utilizzo il parametro Secure passato nel ddf -- se non c'è il parametro considero la porta come se avesse bevel down -- ed effettuo il ribaltamento e rotazioni in base allo swing ( con DGD.SwDD = 1 nel file EgtDoorsData) local sNumPhase if nNumPhase and nNumPhase < 10 then sNumPhase = '0'.. EgtNumToString( nNumPhase, 0) elseif nNumPhase then sNumPhase = EgtNumToString( nNumPhase, 0) else sNumPhase = '0' end if bFirstStep then local bOkDisp = false nNumProbeZ = 0 if bFrame then bOkDisp = true bFlip = false bTopOnRight = CalcTopPosition( tMainTabPar.FTDD, not tsBoolData.bAtRight, nil, nil, sAssemb) -- if not bFrameOnNarrow then if sAssemb == 'frametop' then -- modifico rotazione per avere sempre lato porta verso l'alto if tMainTabPar.FTDD == 0 then -- se mantengo il lato porta sul fronte -- forzo per a true bTopOnRight = true if bPush then bTopOnRight = not bTopOnRight end end elseif sAssemb == 'framebot' then -- modifico rotazione per avere sempre lato porta verso il basso if tMainTabPar.FTDD == 0 then -- se mantengo il lato porta sul fronte -- forzo per a true bTopOnRight = true if bPush then bTopOnRight = not bTopOnRight end end end -- end else -- prima controllo che il lato cerniere abbia un bevel (da lavorare), se no passo al lato serratura, -- se non ha bevel nemmeno il lato serratura considero il parametro secure if tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BU' or tsStringData.sHingeTrim == 'BDEB' or tsStringData.sHingeTrim == 'BUEB' then -- se profilo cerniera indicato bevel -- verifico se i profili risultanti sono presenti in tabella if bPush and tsStringData.sHingeTrim == 'BD' and string.find( sProfiles, 'BU,') then bOkDisp = true elseif bPush and tsStringData.sHingeTrim == 'BDEB' and string.find( sProfiles, 'BU,') then bOkDisp = true elseif not bPush and tsStringData.sHingeTrim == 'BD' and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and tsStringData.sHingeTrim == 'BDEB'and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and tsStringData.sHingeTrim == 'BU' and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and tsStringData.sHingeTrim == 'BUEB' and string.find( sProfiles, 'BD,') then bOkDisp = true elseif bPush and tsStringData.sHingeTrim == 'BU' and string.find( sProfiles, 'BU,') then bOkDisp = true elseif bPush and tsStringData.sHingeTrim == 'BUEB' and string.find( sProfiles, 'BU,') then bOkDisp = true end if bOkDisp then -- casi in cui il bevel indicato nel ddf non corrisponde al bevel generato dallo swing -- devo ribaltare la porta e la parte top va posizionata in base al parametro presente nel currcaminfo if ( bPush and ( tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BDEB')) or ( not bPush and ( tsStringData.sHingeTrim == 'BU' or tsStringData.sHingeTrim == 'BUEB')) then bFlip = true bTopOnRight = CalcTopPosition( tMainTabPar.TDD, tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) -- in caso la porta è ad arco, dispongo la porta -- gli altri casi in cui il bevel indicato corrisponde al bevel generato dallo swing -- non devo ribaltare la porta e la parte top va posizionata in base al parametro presente nel curcaminfo else bFlip = false bTopOnRight = CalcTopPosition( tMainTabPar.TDD, not tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) end end end -- se profilo serratura indicato bevel (e da lavorare) if not bOkDisp and ( tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BU' or tsStringData.sLockTrim == 'BDEB' or tsStringData.sLockTrim == 'BUEB') then -- verifico se i profili risultanti sono presenti in tabella if bPush and tsStringData.sLockTrim == 'BD' and string.find( sProfiles, 'BU,') then bOkDisp = true elseif bPush and tsStringData.sLockTrim == 'BDEB' and string.find( sProfiles, 'BU,') then bOkDisp = true elseif bPush and tsStringData.sLockTrim == 'BD' and not string.find( sProfiles, 'BD,') then bOkDisp = true elseif bPush and tsStringData.sLockTrim == 'BDEB' and not string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and tsStringData.sLockTrim == 'BU' and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and tsStringData.sLockTrim == 'BUEB' and string.find( sProfiles, 'BD,') then bOkDisp = true elseif bPush and tsStringData.sLockTrim == 'BU' and string.find( sProfiles, 'BU,') then bOkDisp = true elseif bPush and tsStringData.sLockTrim == 'BUEB' and string.find( sProfiles, 'BU,') then bOkDisp = true end if bOkDisp then -- casi in cui il bevel indicato nel ddf non corrisponde al bevel generato dallo swing -- devo ribaltare la porta e la parte top va posizionata in base al parametro presente nel curcaminfo if ( bPush and ( tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BDEB')) or ( not bPush and ( tsStringData.sLockTrim == 'BU' or tsStringData.sLockTrim == 'BUEB')) then bFlip = true bTopOnRight = CalcTopPosition( tMainTabPar.TDD, tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) -- gli altri casi in cui il bevel indicato corrisponde al bevel generato dallo swing -- non devo ribaltare la porta e la parte top va posizionata in base al parametro presente nel curcaminfo else bFlip = false bTopOnRight = CalcTopPosition( tMainTabPar.TDD, not tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) end end end -- se arco abilitato e profilo top indicato bevel (e da lavorare) if not bOkDisp and ( tsStringData.sTopTrim == 'BD' or tsStringData.sTopTrim == 'BD_H' or tsStringData.sTopTrim == 'BU' or tsStringData.sTopTrim == 'BU_H' or tsStringData.sTopTrim == 'BDEB' or tsStringData.sTopTrim == 'BDEB_H' or tsStringData.sTopTrim == 'BUEB' or tsStringData.sTopTrim == 'BUEB_H') then -- verifico se i profili risultanti sono presenti in tabella if bPush and ( tsStringData.sTopTrim == 'BD' or tsStringData.sTopTrim == 'BD_H') and string.find( sProfiles, 'BU,') then bOkDisp = true elseif bPush and ( tsStringData.sTopTrim == 'BDEB' or tsStringData.sTopTrim == 'BDEB_H') and string.find( sProfiles, 'BU,') then bOkDisp = true elseif not bPush and ( tsStringData.sTopTrim == 'BD' or tsStringData.sTopTrim == 'BD_H') and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and ( tsStringData.sTopTrim == 'BDEB' or tsStringData.sTopTrim == 'BDEB_H') and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and ( tsStringData.sTopTrim == 'BU' or tsStringData.sTopTrim == 'BU_H') and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and ( tsStringData.sTopTrim == 'BUEB' or tsStringData.sTopTrim == 'BUEB_H') and string.find( sProfiles, 'BD,') then bOkDisp = true elseif bPush and ( tsStringData.sTopTrim == 'BU' or tsStringData.sTopTrim == 'BU_H') and string.find( sProfiles, 'BU,') then bOkDisp = true elseif bPush and ( tsStringData.sTopTrim == 'BUEB' or tsStringData.sTopTrim == 'BUEB_H') and string.find( sProfiles, 'BU,') then bOkDisp = true end if bOkDisp then -- casi in cui il bevel indicato nel ddf non corrisponde al bevel generato dallo swing -- devo ribaltare la porta e la parte top va posizionata in base al parametro presente nel curcaminfo if ( bPush and ( tsStringData.sTopTrim == 'BD' or tsStringData.sTopTrim == 'BD_H' or tsStringData.sTopTrim == 'BDEB' or tsStringData.sTopTrim == 'BDEB_H')) or ( not bPush and ( tsStringData.sTopTrim == 'BU' or tsStringData.sTopTrim == 'BU_H' or tsStringData.sTopTrim == 'BUEB' or tsStringData.sTopTrim == 'BUEB_H')) then bFlip = true bTopOnRight = CalcTopPosition( tMainTabPar.TDD, tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) -- gli altri casi in cui il bevel indicato corrisponde al bevel generato dallo swing -- non devo ribaltare la porta e la parte top va posizionata in base al parametro presente nel curcaminfo else bFlip = false bTopOnRight = CalcTopPosition( tMainTabPar.TDD, not tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) end end end -- se profilo top indicato bevel (e da lavorare) if not bOkDisp and ( tsStringData.sBottomTrim == 'BD' or tsStringData.sBottomTrim == 'BD_H' or tsStringData.sBottomTrim == 'BU' or tsStringData.sBottomTrim == 'BU_H' or tsStringData.sBottomTrim == 'BDEB' or tsStringData.sBottomTrim == 'BDEB_H' or tsStringData.sBottomTrim == 'BUEB' or tsStringData.sBottomTrim == 'BUEB_H') then -- verifico se i profili risultanti sono presenti in tabella if bPush and ( tsStringData.sBottomTrim == 'BD' or tsStringData.sBottomTrim == 'BD_H') and string.find( sProfiles, 'BU,') then bOkDisp = true elseif bPush and ( tsStringData.sBottomTrim == 'BDEB' or tsStringData.sBottomTrim == 'BDEB_H') and string.find( sProfiles, 'BU,') then bOkDisp = true elseif not bPush and ( tsStringData.sBottomTrim == 'BD' or tsStringData.sBottomTrim == 'BD_H') and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and ( tsStringData.sBottomTrim == 'BDEB' or tsStringData.sBottomTrim == 'BDEB_H') and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and ( tsStringData.sBottomTrim == 'BU' or tsStringData.sBottomTrim == 'BU_H') and string.find( sProfiles, 'BD,') then bOkDisp = true elseif not bPush and ( tsStringData.sBottomTrim == 'BUEB' or tsStringData.sBottomTrim == 'BUEB_H') and string.find( sProfiles, 'BD,') then bOkDisp = true elseif bPush and ( tsStringData.sBottomTrim == 'BU' or tsStringData.sBottomTrim == 'BU_H') and string.find( sProfiles, 'BU,') then bOkDisp = true elseif bPush and ( tsStringData.sBottomTrim == 'BUEB' or tsStringData.sBottomTrim == 'BUEB_H') and string.find( sProfiles, 'BU,') then bOkDisp = true end if bOkDisp then -- casi in cui il bevel indicato nel ddf non corrisponde al bevel generato dallo swing -- devo ribaltare la porta e la parte top va posizionata in base al parametro presente nel curcaminfo if ( bPush and ( tsStringData.sBottomTrim == 'BD' or tsStringData.sBottomTrim == 'BD_H' or tsStringData.sBottomTrim == 'BDEB' or tsStringData.sBottomTrim == 'BDEB_H')) or ( not bPush and ( tsStringData.sBottomTrim == 'BU' or tsStringData.sBottomTrim == 'BU_H' or tsStringData.sBottomTrim == 'BUEB' or tsStringData.sBottomTrim == 'BUEB_H')) then bFlip = true bTopOnRight = CalcTopPosition( tMainTabPar.TDD, tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) -- gli altri casi in cui il bevel indicato corrisponde al bevel generato dallo swing -- non devo ribaltare la porta e la parte top va posizionata in base al parametro presente nel curcaminfo else bFlip = false bTopOnRight = CalcTopPosition( tMainTabPar.TDD, not tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) end end end end -- in caso non ci sia nessun profilo bevel verifico il parametro Secure if not bOkDisp then -- se il parametro secure è passato con valore '0' prendo quello del CurCamInfo atrimenti do errore if tsStringData.sSecure and string.upper(tsStringData.sSecure) == '0' then -- se parametro da CurrcamInfo non è valido do errore if not tMainTabPar.LS or ( string.upper(tMainTabPar.LS) ~= 'UP' and string.upper(tMainTabPar.LS) ~= 'DN') then bOk = false DGD.EMC = ' ' .. EgtDoorsMsg[590] break else tsStringData.sSecure = tMainTabPar.LS end end -- se lato secure va sopra il ribaltamento è obbligato if tsStringData.sSecure and string.upper(tsStringData.sSecure) == 'UP' then bFlip = true bTopOnRight = CalcTopPosition( tMainTabPar.TDD, tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) elseif tsStringData.sSecure and string.upper(tsStringData.sSecure) == 'DN' then bFlip = false bTopOnRight = CalcTopPosition( tMainTabPar.TDD, not tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) -- altrimenti la preferenza sembrerebbe essere ( non è ancora confermata) qualla di considerare la porta bevel down -- quindi se è una reverse non deve essere ribaltata, mentre se è normale deve essere ribaltata -- ed effettuo il ribaltamento e rotazioni in base allo swing ( con DGD.SwDD = 1 nel file EgtDoorsData) else if tsBoolData.bSwingDriveDisp then -- se metodo di posizionamento guidato dallo swing -- se porta a spingere ( dovrebbe avere bevel up) la ribalto per essere bevel down if bPush then bFlip = true bTopOnRight = CalcTopPosition( tMainTabPar.TDD, tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) -- se porta a tirare non la ribalto perché si presta già ad essere bevel down else bFlip = false bTopOnRight = CalcTopPosition( tMainTabPar.TDD, not tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) end -- in attesa delle considerazioni del cliente, in base alle geometrie trovate ribalto oppure no la porta else if nNumGeomBottom > nNumGeomTop then bFlip = true bTopOnRight = CalcTopPosition( tMainTabPar.TDD, tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) elseif nNumGeomTop >= nNumGeomBottom then bFlip = false bTopOnRight = CalcTopPosition( tMainTabPar.TDD, not tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) else -- altrimenti vecchio metodo bFlip = true bTopOnRight = CalcTopPosition( tMainTabPar.TDD, tsBoolData.bAtRight, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) end end end end -- Scelta dell'origine (ora espressa rispetto Zero Tavola) if sAssemb == 'framesx' then if bPush then if bTopOnRight then -- se top a destra if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else if tMainTabPar.MJT == 0 then -- se da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 if tMainTabPar.FTDD == 0 then -- se mantengo il lato porta sul fronte bTopOnRight = true end else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR5f, tMainTabPar.OR6f) nCodeVacDisp = 3 end end else if bTopOnRight then -- se top a destra if tMainTabPar.MJT == 0 then -- se da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 if tMainTabPar.FTDD == 0 then -- se mantengo il lato porta sul fronte bTopOnRight = false end else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR5f, tMainTabPar.OR6f) nCodeVacDisp = 3 end else if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 end end elseif sAssemb == 'framedx' then if bPush then if bTopOnRight then -- se top a destra if tMainTabPar.MJT == 0 then -- se da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 if tMainTabPar.FTDD == 0 then -- se mantengo il lato porta sul fronte bTopOnRight = false end else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR5f, tMainTabPar.OR6f) nCodeVacDisp = 3 end else if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 end else if bTopOnRight then -- se top a destra if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else if tMainTabPar.MJT == 0 then -- se da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 if tMainTabPar.FTDD == 0 then -- se mantengo il lato porta sul fronte bTopOnRight = true end else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR5f, tMainTabPar.OR6f) nCodeVacDisp = 3 end end end elseif sAssemb == 'frametop' then if tMainTabPar.MJT == 0 then -- da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 if tMainTabPar.FTDD == 0 then -- se mantengo il lato porta sul fronte bTopOnRight = not bTopOnRight end else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR3f, tMainTabPar.OR4f) nCodeVacDisp = 2 end elseif sAssemb == 'framebot' then if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 -- door else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1, tMainTabPar.OR2) end if v == #tPz then -- solo all'ultimo pezzo -- se porta da traslare setto lo shift da applicare if bShiftMchng then vShift = tMainTabPar.SH1 else vShift = vNullShift end Ori = Ori + vShift end -- faccio le rotazioni della porta if bFlip then EgtRotateRawPart( nRaw, Y_AX(), 180) sDispMode = sDispMode .. EgtDoorsMsg[511] .. sNumPhase .. ' ' .. EgtIf( bFrame, EgtDoorsMsg[610], EgtDoorsMsg[479]) else sDispMode = sDispMode .. EgtDoorsMsg[511] .. sNumPhase .. ' ' .. EgtIf( bFrame, EgtDoorsMsg[611], EgtDoorsMsg[480]) end if bTopOnRight then EgtRotateRawPart( nRaw, Z_AX(), -90) sDispMode = sDispMode .. EgtDoorsMsg[481] else EgtRotateRawPart( nRaw, Z_AX(), 90) sDispMode = sDispMode .. EgtDoorsMsg[482] end if bShiftMchng then sDispMode = sDispMode .. EgtDoorsMsg[510] end -- sTotDispMode = sTotDispMode .. ' ' .. sDispMode .. '\n' -- se c'è probe mode (prod) filtro le geometrie che si trovano sotto if nProbeMode == 1 then if bFlip then DelList = MB.FindEntitiesWithPartName( tPz, 'ProbePoint_keyway') else DelList = MB.FindEntitiesWithPartName( tPz, 'ProbePoint_secure') end -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint_secure') -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint_keyway') -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end -- rinomino i rimenenti if bFlip then DelList = MB.FindEntitiesWithPartName( tPz, 'ProbePoint_secure') else DelList = MB.FindEntitiesWithPartName( tPz, 'ProbePoint_keyway') end -- mi tengo via il numero di probe in Z nNumProbeZ = #DelList -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtSetName( DelList[j], 'ProbePoint') end -- se non c'è probe mode (prod) e abilitata la tastatura di fianco filtro le geometrie che si trovano sopra e sotto elseif nProbeMode == 0 and nPostProbeSet >= 3 then DelList = MB.FindEntitiesWithPartName( tPz, 'ProbePoint_secure') -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end DelList = MB.FindEntitiesWithPartName( tPz, 'ProbePoint_keyway') -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end if bFlip then DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint_keyway') else DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint_secure') end -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end -- rinomino i rimenenti if bFlip then DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint_secure') else DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint_keyway') end -- mi tengo via il numero di probe sul fianco nNumProbeZ = #DelList -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtSetName( DelList[j], 'ProbeSidePoint') end else -- se non c'è il probe point elimino tutti i percorsi di probe (in Z e xy) DelList = MB.FindEntitiesWithPartName( tPz, 'ProbePoint') -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint') -- ciclo su tutte le entità trovate for j = 1, #DelList do EgtErase( DelList[j] ) end end ------------------------------------------------------------------ -- calcolo delta Y in base al profilo e al ribaltamento del pezzo ------------------------------------------------------------------ local dExtraY = 0 local dExtraYOppo = 0 local dDeltaProbe = 0 local dDeltaProf = 0 local dDeltaProfOppo = 0 -- variabili per note relative al lato hinges local nHingeMach = 0 -- setto default non lavorato local nLockMach = 0 -- setto default non lavorato local nSideType = -1 -- 0 per profili SQ local nSideOppoType = -1 -- 0 per profili SQ local sProfName local sProfOppoName -- nome profilo lato opposto alla battuta local bCalcProf = false local bCalcProfOppo = false -- per i frame non calcolo distanza profilo su finito if bFrame then bCalcProf = false bCalcProfOppo = false else -- se profilo hinge è da lavorare annullo il delta Y e setto il valore della nota if tsBoolData.bHingeMach then nHingeMach = 1 end -- se profilo lock da lavorare setto la variabile per la nota if tsBoolData.bLockMach then nLockMach = 1 end -- se il profilo hinge è in battuta if ( not bFlip and bTopOnRight and not tsBoolData.bAtRight) or ( not bFlip and not bTopOnRight and tsBoolData.bAtRight) or ( bFlip and bTopOnRight and tsBoolData.bAtRight) or ( bFlip and not bTopOnRight and not tsBoolData.bAtRight) then sProfName = tsStringData.sHingeTrim sProfOppoName = tsStringData.sLockTrim tsDoubleData.dRadiusPrf = tsRadiusProf[1] tsDoubleData.dPlanePrf = tsPlaneProf[1] bHingeOnRef = true -- se il profilo hinge non è da lavorare if not tsBoolData.bHingeMach then bCalcProf = true end -- se il profilo lock non è da lavorare if not tsBoolData.bLockMach then bCalcProfOppo = true end else -- altrimenti è il profilo lock in battuta sProfName = tsStringData.sLockTrim sProfOppoName = tsStringData.sHingeTrim tsDoubleData.dRadiusPrf = tsRadiusProf[2] tsDoubleData.dPlanePrf = tsPlaneProf[2] bHingeOnRef = false -- se il profilo lock non è da lavorare if not tsBoolData.bLockMach then bCalcProf = true end -- se il profilo hinge non è da lavorare if not tsBoolData.bHingeMach then bCalcProfOppo = true end end bTopOnRef = ( bTopOnRight and DISPMODE < 0) or ( not bTopOnRight and DISPMODE > 0) if nProbeMode == 2 then bCalcProf = false bCalcProfOppo = false end end -- se devo calcolare eventuale spostamento dato dal profilo in battuta if bCalcProf then if sProfName == 'SQ' or sProfName == 'EB' then nSideType = 0 -- se disposizione bevel down uso il riferimento in alto elseif sProfName == 'BD' or sProfName == 'BDEB' then nSideType = 1 if tsDoubleData.dThickDoor > tMainTabPar.AR then dExtraY = ( tsDoubleData.dThickDoor - tMainTabPar.AR) * TAN3 end -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo errore del probe tastando dallo spessore - il parametro z extra probe dDeltaProf = tMainTabPar.EZPB * TAN3 else -- calcolo errore del probe tastando a metà spessore - il parametro z extra probe dDeltaProf = ((( tsDoubleData.dThickDoor / 2) - tMainTabPar.EZPB) * TAN3) end dDeltaProbe = dDeltaProf - dExtraY -- dato che viene compensato il dDeltaProbe nella tastatura. il dDeltaProf risulta essere uguale a dExtraY dDeltaProf = dExtraY -- se disposizione bevel up uso il riferimento in basso elseif sProfName == 'BU' or sProfName == 'BUEB' then nSideType = 2 dExtraY = ( tMainTabPar.AR - tMainTabPar.TR) * TAN3 -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo errore del probe tastando dallo spessore - il parametro z extra probe dDeltaProf = (( tsDoubleData.dThickDoor - tMainTabPar.EZPB) * TAN3) else -- calcolo errore del probe tastando a metà spessore + il parametro z extra probe dDeltaProf = ((( tsDoubleData.dThickDoor / 2) + tMainTabPar.EZPB) * TAN3) end dDeltaProbe = dDeltaProf - dExtraY -- dato che viene compensato il dDeltaProbe nella tastatura. il dDeltaProf risulta essere uguale a dExtraY dDeltaProf = dExtraY -- se profilo bull nose verifico in base al raggio elseif sProfName == '1B' or sProfName == '2B' or sProfName == '3B' or sProfName == '4B' or sProfName == '5B' or sProfName == '6B' or sProfName == '7B' or sProfName == '8B' then nSideType = 3 -- calcolo punto massimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 local dAltcalc = 0 -- se punto max è sotto il minimo riferimento if dAltProf < ( tMainTabPar.AR - tMainTabPar.TR) then dAltcalc = tMainTabPar.AR - tMainTabPar.TR - dAltProf -- se punto max è sopra il massimo riferimento elseif dAltProf > tMainTabPar.AR then dAltcalc = dAltProf - tMainTabPar.AR end -- se punto massimo profilo non è compreso nel riferimento calcolo il delta Y if dAltcalc > 0 then dExtraY = tsDoubleData.dRadiusPrf - sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltcalc*dAltcalc)) end -- calcolo errore del probe tastando a metà spessore dDeltaProbe = -dExtraY -- dato che viene compensato il dDeltaProbe nella tastatura. il dDeltaProf risulta essere uguale a dExtraY dDeltaProf = dExtraY -- se profilo convex verifico in base al raggio elseif sProfName == 'CV' then nSideType = 4 -- calcolo punto minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 local dAltcalc = (tMainTabPar.TR/2) -- calcolo il delta Y massimo del minimo ingombro profilo local dMaxInsPrf = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-((dAltProf-tsDoubleData.dPlanePrf)*(dAltProf-tsDoubleData.dPlanePrf))) -- se riferimento è sul max ingombro porta if ( tsDoubleData.dThickDoor < tMainTabPar.AR) and ( tsDoubleData.dThickDoor > ( tMainTabPar.AR - tMainTabPar.TR)) then dAltcalc = 0 -- se punto minimo ingombro profilo è sotto all'altezza media del riferimento elseif dAltProf < ( tMainTabPar.AR - (tMainTabPar.TR/2)) then dAltcalc = tMainTabPar.AR - dAltProf -- se punto minimo ingombro profilo è sopra all'altezza media del riferimento elseif dAltProf > ( tMainTabPar.AR - (tMainTabPar.TR/2)) then dAltcalc = dAltProf - tMainTabPar.AR + tMainTabPar.TR end -- calcolo il delta Y if dAltcalc > 0 then dExtraY = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltcalc*dAltcalc)) - dMaxInsPrf end -- calcolo errore del probe tastando a metà spessore dDeltaProbe = tsDoubleData.dRadiusPrf - (dExtraY + dMaxInsPrf) -- dato che viene compensato il dDeltaProbe nella tastatura. il dDeltaProf risulta essere uguale a dExtraY dDeltaProf = dExtraY end end if bCalcProfOppo then if sProfOppoName == 'SQ' or sProfOppoName == 'EB' then nSideOppoType = 0 -- se disposizione bevel down ( il nome è riferito alla prima disposizione) uso il riferimento in alto elseif sProfOppoName == 'BD' or sProfOppoName == 'BDEB' then nSideOppoType = 1 -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo errore del probe tastando dallo spessore - il parametro z extra probe dDeltaProfOppo = tMainTabPar.EZPB * TAN3 else -- calcolo errore del probe tastando a metà spessore - il parametro z extra p dDeltaProfOppo = ((( tsDoubleData.dThickDoor / 2) - tMainTabPar.EZPB) * TAN3) end -- se disposizione bevel up uso il riferimento in basso elseif sProfOppoName == 'BU' or sProfOppoName == 'BUEB' then nSideOppoType = 2 -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo errore del probe tastando dallo spessore - il parametro z extra probe dDeltaProfOppo = (( tsDoubleData.dThickDoor - tMainTabPar.EZPB) * TAN3) else -- calcolo errore del probe tastando a metà spessore + il parametro z extra probe dDeltaProfOppo = ((( tsDoubleData.dThickDoor / 2) + tMainTabPar.EZPB) * TAN3) end -- se profilo bull nose verifico in base al raggio elseif sProfOppoName == '1B' or sProfOppoName == '2B' or sProfOppoName == '3B' or sProfOppoName == '4B' or sProfOppoName == '5B' or sProfOppoName == '6B' or sProfOppoName == '7B' or sProfOppoName == '8B' then nSideOppoType = 3 -- se profilo convex verifico in base al raggio elseif sProfOppoName == 'CV' then nSideOppoType = 4 local dAltProfOppo local dAltProfOppoTh local dExtraYOppoTh -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo punto minimo ingombro profilo dAltProfOppoTh = tsDoubleData.dThickDoor/2 - tsDoubleData.dPlanePrf -- calcolo errore del probe tastando a spessore completo - extra z dAltProfOppo = (tsDoubleData.dThickDoor/2) - tMainTabPar.EZPB - tsDoubleData.dPlanePrf -- calcolo il delta Y massimo del minimo ingombro profilo dExtraYOppo = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltProfOppo*dAltProfOppo)) dExtraYOppoTh = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltProfOppoTh*dAltProfOppoTh)) -- calcolo errore del probe tastando dallo spessore - quota extra z dDeltaProfOppo = dExtraYOppo - dExtraYOppoTh else -- calcolo punto minimo ingombro profilo dAltProfOppo = tsDoubleData.dThickDoor/2 - tsDoubleData.dPlanePrf -- calcolo il delta Y massimo del minimo ingombro profilo dExtraYOppo = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltProfOppo*dAltProfOppo)) -- calcolo errore del probe tastando a metà spessore dDeltaProfOppo = tsDoubleData.dRadiusPrf - dExtraYOppo end end end vExtraYDelta = Vector3d(0,-dExtraY,0) -- scrivo le note EgtSetInfo( Pz, 'Piece Type', tsDoubleData.TypePiece) EgtSetInfo( Pz, 'ExtraCalcMoveY', dExtraY) EgtSetInfo( Pz, 'DoorProbeErrorY', dDeltaProbe) EgtSetInfo( Pz, 'DoorProbeExtraPosZ', tMainTabPar.EZPB) EgtSetInfo( Pz, 'DoorProbeThick', tMainTabPar.PTK) EgtSetInfo( Pz, 'DoorProfErrorY', dDeltaProf) EgtSetInfo( Pz, 'DoorProfOppoErrorY', dDeltaProfOppo) EgtSetInfo( Pz, 'SideDisposition', DISPMODE) EgtSetInfo( Pz, 'UseViseWithFrame', bUseVise) -- scrivo nota lavorazione lato hinge EgtSetInfo( Pz, 'SideHingeMach', nHingeMach) -- per compatibilità scrivo nota tipo profilo su lato in battuta (inizialmente il lato hinge era sempre in battuta) EgtSetInfo( Pz, 'SideHingeProf', nSideType) -- scrivo profilo lato in battuta EgtSetInfo( Pz, 'SideProfOnRef', nSideType) -- scrivo profilo lato opposto EgtSetInfo( Pz, 'SideProfOnOppo', nSideOppoType) -- scrivo nota lavorazione lato lock EgtSetInfo( Pz, 'SideLockMach', nLockMach) -- scrivo nota con numero geometrie di ProbeZ o probeXY (in base ai settaggi di nProbeMode e nPostProbeSet) EgtSetInfo( Pz, 'NumProbeZ', nNumProbeZ) -- scrivo nota flag modalita remove scrap EgtSetInfo( Pz, 'RemoveScrapMode', tMainTabPar.RSM) -- scrivo nota altezza riferimento e spessore riferimento EgtSetInfo( Pz, 'ReferenceHeight', tMainTabPar.AR) EgtSetInfo( Pz, 'ReferenceTall', tMainTabPar.TR) -- scrivo posizioni riferimenti EgtSetInfo( Pz, 'ReferencePos1', tMainTabPar.REF1) EgtSetInfo( Pz, 'ReferencePos2', tMainTabPar.REF2) EgtSetInfo( Pz, 'ReferencePos3', tMainTabPar.REF3) EgtSetInfo( Pz, 'ReferencePos4', tMainTabPar.REF4) local vExtraXY local dExtraX = 0 dExtraY = 0 local nCorner = MCH_CR.BL if sAssemb == 'framesx' then dExtraX , dExtraY, nCorner = CalcDispositionRef( true, bTopOnRight, tsDoubleData.dLeftOffs, tsDoubleData.dRightOffs, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs, bFlip, tMainTabPar.FTDD) vExtraXY = Vector3d( dExtraX, dExtraY, 0) -- Muovo frame nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta + vExtraXY), nCorner) elseif sAssemb == 'framedx' then dExtraX , dExtraY, nCorner = CalcDispositionRef( false, bTopOnRight, tsDoubleData.dLeftOffs, tsDoubleData.dRightOffs, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs, bFlip, tMainTabPar.FTDD) vExtraXY = Vector3d( dExtraX, dExtraY, 0) -- Muovo frame nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta + vExtraXY), nCorner) elseif sAssemb == 'frametop' then dExtraX , dExtraY, nCorner = CalcDispositionRef( true, bTopOnRight, tsDoubleData.dLeftOffs, tsDoubleData.dRightOffs, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs, bFlip, tMainTabPar.FTDD) vExtraXY = Vector3d( dExtraX, dExtraY, 0) -- Muovo frame nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta + vExtraXY), nCorner) elseif sAssemb == 'framebot' then dExtraX , dExtraY, nCorner = CalcDispositionRef( false, bTopOnRight, tsDoubleData.dLeftOffs, tsDoubleData.dRightOffs, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs, bFlip, tMainTabPar.FTDD) vExtraXY = Vector3d( dExtraX, dExtraY, 0) -- Muovo frame nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta + vExtraXY), nCorner) else -- Muovo porta con l'angolo in basso a ( destra o sinistra) nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta), EgtIf( DISPMODE > 0, MCH_CR.BL, MCH_CR.BR)) if nProbeMode == 2 then local btempX = EgtIf( bTopOnRight, bFlip, not bFlip) bMoveRaw = EgtMoveRawPart( nRaw, Vector3d( EgtIf( bTopOnRight, pMinRecalc:getY(), -pMinRecalc:getY()), EgtIf( btempX, pMinRecalc:getX(), -pMinRecalc:getX()), 0)) end end -- memorizzo i flag per le fasi successive bFlipFirst = bFlip bTopOnRightFirst = bTopOnRight else -- se sono in ribaltamento porta if bFrame then if sAssemb == 'frametop' then -- modifico rotazione per avere sempre lato porta verso l'alto if bPush then bTopOnRight = not bTopOnRight end elseif sAssemb == 'framebot' then -- modifico rotazione per avere sempre lato porta verso il basso if bPush then bTopOnRight = not bTopOnRight end end else -- posizioni opposte local nSelDisp = 0 bTopOnRight = CalcTopPosition( tMainTabPar.TDD, not bTopOnRightFirst, tsDoubleData.dTopRadius, tsDoubleData.dTopAngle) end bFlip = not bFlipFirst nNumProbeZ = 0 -- Scelta dell'origine (ora espressa rispetto Zero Tavola) if sAssemb == 'framesx' then if bPush then if bTopOnRight then -- se top a destra if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else if tMainTabPar.MJT == 0 then -- se da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR5f, tMainTabPar.OR6f) nCodeVacDisp = 3 end end else if bTopOnRight then -- se top a destra if tMainTabPar.MJT == 0 then -- se da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR5f, tMainTabPar.OR6f) nCodeVacDisp = 3 end else if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 end end elseif sAssemb == 'framedx' then if bPush then if bTopOnRight then -- se top a destra if tMainTabPar.MJT == 0 then -- se da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR5f, tMainTabPar.OR6f) nCodeVacDisp = 3 end else if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 end else if bTopOnRight then -- se top a destra if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else if tMainTabPar.MJT == 0 then -- se da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR5f, tMainTabPar.OR6f) nCodeVacDisp = 3 end end end elseif sAssemb == 'frametop' then if tMainTabPar.MJT == 0 then -- da lavorare uno alla volta if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR3f, tMainTabPar.OR4f) nCodeVacDisp = 2 end elseif sAssemb == 'framebot' then if bUseVise then Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1fv, tMainTabPar.OR2fv) else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1f, tMainTabPar.OR2f) end nCodeVacDisp = 1 else Ori = EgtIf( DISPMODE > 0, tMainTabPar.OR1, tMainTabPar.OR2) end if v == #tPz then -- solo all'ultimo pezzo -- se porta da traslare setto lo shift da applicare if bShiftMchng then vShift = tMainTabPar.SH1 else vShift = vNullShift end Ori = Ori + vShift end -- faccio le rotazioni della porta if bFlip then EgtRotateRawPart( nRaw, Y_AX(), 180) sDispMode = sDispMode .. EgtDoorsMsg[511] .. sNumPhase .. ' ' .. EgtIf( bFrame, EgtDoorsMsg[610], EgtDoorsMsg[479]) else sDispMode = sDispMode .. EgtDoorsMsg[511] .. sNumPhase .. ' ' .. EgtIf( bFrame, EgtDoorsMsg[611], EgtDoorsMsg[480]) end if bTopOnRight then EgtRotateRawPart( nRaw, Z_AX(), -90) sDispMode = sDispMode .. EgtDoorsMsg[481] else EgtRotateRawPart( nRaw, Z_AX(), 90) sDispMode = sDispMode .. EgtDoorsMsg[482] end if bShiftMchng then sDispMode = sDispMode .. EgtDoorsMsg[510] end -- sTotDispMode = sTotDispMode .. ' ' .. sDispMode .. '\n' -- -- se non c'è probe mode (prod) e abilitata la tastatura di fianco filtro le geometrie che si trovano sopra e sotto -- if nProbeMode == 0 and nPostProbeSet >= 3 then -- DelList = MB.FindEntitiesWithName( tPz, 'NO_ProbeSidePoint') -- -- ciclo su tutte le entità trovate -- for j = 1, #DelList do -- EgtSetName( DelList[j], 'ProbeSidePoint') -- end -- DelList = MB.FindEntitiesWithName( tPz, 'ProbeSidePoint') -- -- ciclo su tutte le entità trovate -- for j = 1, #DelList do -- -- se prima non era flippata -- if bFlip then -- EgtSetName( DelList[j], 'ProbeSidePoint_keyway') -- else -- EgtSetName( DelList[j], 'ProbeSidePoint_secure') -- end -- end -- -- rinomino i rimenenti -- if bFlip then -- DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint_secure') -- else -- DelList = MB.FindEntitiesWithPartName( tPz, 'ProbeSidePoint_keyway') -- end -- -- mi tengo via il numero di probe sul fianco -- nNumProbeZ = #DelList -- -- ciclo su tutte le entità trovate -- for j = 1, #DelList do -- EgtSetName( DelList[j], 'ProbeSidePoint') -- end -- end ------------------------------------------------------------------ -- calcolo delta Y in base al profilo e al ribaltamento del pezzo ------------------------------------------------------------------ local dExtraY = 0 local dExtraYOppo = 0 local dDeltaProbe = 0 local dDeltaProf = 0 local dDeltaProfOppo = 0 -- variabili per note relative al lato hinges local nHingeMach = 0 -- setto default non lavorato local nLockMach = 0 -- setto default non lavorato nSideType = -1 -- 0 per profili SQ local nSideOppoType = -1 -- 0 per profili SQ local sProfName -- nome profilo in battuta local sProfOppoName -- nome profilo lato opposto alla battuta local bCalcProf = false local bCalcProfOppo = false -- per i frame non calcolo distanza profilo su finito if bFrame then bCalcProf = false bCalcProfOppo = false else -- se profilo hinge è da lavorare e non è stato lavorato setto il valore della nota if tsBoolData.bHingeMach and not DGD.MHS then nHingeMach = 1 end -- se profilo lock é da lavorare e non è stato lavorato setto la variabile per la nota if tsBoolData.bLockMach and not DGD.MLS then nLockMach = 1 end -- se il profilo hinge è in battuta if ( not bFlip and bTopOnRight and not tsBoolData.bAtRight) or ( not bFlip and not bTopOnRight and tsBoolData.bAtRight) or ( bFlip and bTopOnRight and tsBoolData.bAtRight) or ( bFlip and not bTopOnRight and not tsBoolData.bAtRight) then sProfName = tsStringData.sHingeTrim sProfOppoName = tsStringData.sLockTrim tsDoubleData.dRadiusPrf = tsRadiusProf[1] tsDoubleData.dPlanePrf = tsPlaneProf[1] bHingeOnRef = true -- se il profilo hinge non è da lavorare o è già stato lavorato if not tsBoolData.bHingeMach or DGD.MHS then bCalcProf = true end -- se il profilo lock non è da lavorare o è già stato lavorato if not tsBoolData.bLockMach or DGD.MLS then bCalcProfOppo = true end else -- altrimenti è il profilo lock in battuta sProfName = tsStringData.sLockTrim sProfOppoName = tsStringData.sHingeTrim tsDoubleData.dRadiusPrf = tsRadiusProf[2] tsDoubleData.dPlanePrf = tsPlaneProf[2] bHingeOnRef = false -- se il profilo lock non è da lavorare o è già stato lavorato if not tsBoolData.bLockMach or DGD.MLS then bCalcProf = true end -- se il profilo hinge non è da lavorare o è già stato lavorato if not tsBoolData.bHingeMach or DGD.MHS then bCalcProfOppo = true end end bTopOnRef = ( bTopOnRight and DISPMODE < 0) or ( not bTopOnRight and DISPMODE > 0) --[[ -- se il profilo in battuta non è da lavorare o è già stato lavorato if ( not tsBoolData.bHingeMach or DGD.MHS) and ( ( not bFlip and bTopOnRight and not tsBoolData.bAtRight) or ( not bFlip and not bTopOnRight and tsBoolData.bAtRight) or ( bFlip and bTopOnRight and tsBoolData.bAtRight) or ( bFlip and not bTopOnRight and not tsBoolData.bAtRight)) then sProfName = tsStringData.sHingeTrim sProfOppoName = tsStringData.sLockTrim bHingeOnRef = true bCalcProf = true elseif ( not tsBoolData.bLockMach or DGD.MLS) and ( ( not bFlip and bTopOnRight and tsBoolData.bAtRight) or ( not bFlip and not bTopOnRight and not tsBoolData.bAtRight) or ( bFlip and bTopOnRight and not tsBoolData.bAtRight) or ( bFlip and not bTopOnRight and tsBoolData.bAtRight)) then sProfName = tsStringData.sLockTrim sProfOppoName = tsStringData.sHingeTrim bHingeOnRef = false bCalcProf = true end ]]-- end -- se devo calcolare eventuale spostamento dato dal profilo in battuta if bCalcProf then if sProfName == 'SQ' or sProfName == 'EB' then nSideType = 0 -- se disposizione bevel down ( il nome è riferito alla prima disposizione) uso il riferimento in alto elseif sProfName == 'BU' or sProfName == 'BUEB' then nSideType = 1 if tsDoubleData.dThickDoor > tMainTabPar.AR then dExtraY = ( tsDoubleData.dThickDoor - tMainTabPar.AR) * TAN3 end -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo errore del probe tastando dallo spessore - il parametro z extra probe dDeltaProf = tMainTabPar.EZPB * TAN3 else -- calcolo errore del probe tastando a metà spessore - il parametro z extra probe dDeltaProf = ((( tsDoubleData.dThickDoor / 2) - tMainTabPar.EZPB) * TAN3) end dDeltaProbe = dDeltaProf - dExtraY -- dato che viene compensato il dDeltaProbe nella tastatura. il dDeltaProf risulta essere uguale a dExtraY dDeltaProf = dExtraY -- se disposizione bevel up ( il nome è riferito alla prima disposizione) uso il riferimento in basso elseif sProfName == 'BD' or sProfName == 'BDEB' then nSideType = 2 dExtraY = ( tMainTabPar.AR - tMainTabPar.TR) * TAN3 -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo errore del probe tastando dallo spessore - il parametro z extra probe dDeltaProf = (( tsDoubleData.dThickDoor - tMainTabPar.EZPB) * TAN3) else -- calcolo errore del probe tastando a metà spessore + il parametro z extra probe dDeltaProf = ((( tsDoubleData.dThickDoor / 2) + tMainTabPar.EZPB) * TAN3) end dDeltaProbe = dDeltaProf - dExtraY -- dato che viene compensato il dDeltaProbe nella tastatura. il dDeltaProf risulta essere uguale a dExtraY dDeltaProf = dExtraY -- se profilo bull nose verifico in base al raggio elseif sProfName == '1B' or sProfName == '2B' or sProfName == '3B' or sProfName == '4B' or sProfName == '5B' or sProfName == '6B' or sProfName == '7B' or sProfName == '8B' then nSideType = 3 -- calcolo punto massimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 local dAltcalc = 0 -- se punto max è sotto il minimo riferimento if dAltProf < ( tMainTabPar.AR - tMainTabPar.TR) then dAltcalc = tMainTabPar.AR - tMainTabPar.TR - dAltProf -- se punto max è sopra il massimo riferimento elseif dAltProf > tMainTabPar.AR then dAltcalc = dAltProf - tMainTabPar.AR end -- se punto massimo profilo non è compreso nel riferimento calcolo il delta Y if dAltcalc > 0 then dExtraY = tsDoubleData.dRadiusPrf - sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltcalc*dAltcalc)) end -- calcolo errore del probe tastando a metà spessore dDeltaProbe = -dExtraY -- dato che viene compensato il dDeltaProbe nella tastatura. il dDeltaProf risulta essere uguale a dExtraY dDeltaProf = dExtraY -- se profilo convex verifico in base al raggio elseif sProfName == 'CV' then nSideType = 4 -- calcolo punto minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 local dAltcalc = (tMainTabPar.TR/2) -- calcolo il delta Y massimo del minimo ingombro profilo local dMaxInsPrf = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-((dAltProf-tsDoubleData.dPlanePrf)*(dAltProf-tsDoubleData.dPlanePrf))) -- se riferimento è sul max ingombro porta if ( tsDoubleData.dThickDoor < tMainTabPar.AR) and ( tsDoubleData.dThickDoor > ( tMainTabPar.AR - tMainTabPar.TR)) then dAltcalc = 0 -- se punto minimo ingombro profilo è sotto all'altezza media del riferimento elseif dAltProf < ( tMainTabPar.AR - (tMainTabPar.TR/2)) then dAltcalc = tMainTabPar.AR - dAltProf -- se punto minimo ingombro profilo è sopra all'altezza media del riferimento elseif dAltProf > ( tMainTabPar.AR - (tMainTabPar.TR/2)) then dAltcalc = dAltProf - tMainTabPar.AR + tMainTabPar.TR end -- calcolo il delta Y if dAltcalc > 0 then dExtraY = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltcalc*dAltcalc)) - dMaxInsPrf end -- calcolo errore del probe tastando a metà spessore -- dDeltaProbe = dRadiusPrf - dExtraY -- dDeltaProf = dRadiusPrf - dMaxInsPrf dDeltaProbe = tsDoubleData.dRadiusPrf - (dExtraY + dMaxInsPrf) -- dato che viene compensato il dDeltaProbe nella tastatura. il dDeltaProf risulta essere uguale a dExtraY dDeltaProf = dExtraY end end if bCalcProfOppo then if sProfOppoName == 'SQ' or sProfOppoName == 'EB' then nSideOppoType = 0 -- se disposizione bevel down ( il nome è riferito alla prima disposizione) uso il riferimento in alto elseif sProfOppoName == 'BU' or sProfOppoName == 'BUEB' then nSideOppoType = 1 -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo errore del probe tastando dallo spessore - il parametro z extra probe dDeltaProfOppo = tMainTabPar.EZPB * TAN3 else -- calcolo errore del probe tastando a metà spessore - il parametro z extra p dDeltaProfOppo = ((( tsDoubleData.dThickDoor / 2) - tMainTabPar.EZPB) * TAN3) end -- se disposizione bevel up ( il nome è riferito alla prima disposizione) uso il riferimento in basso elseif sProfOppoName == 'BD' or sProfOppoName == 'BDEB' then nSideOppoType = 2 -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo errore del probe tastando dallo spessore - il parametro z extra probe dDeltaProfOppo = (( tsDoubleData.dThickDoor - tMainTabPar.EZPB) * TAN3) else -- calcolo errore del probe tastando a metà spessore + il parametro z extra probe dDeltaProfOppo = ((( tsDoubleData.dThickDoor / 2) + tMainTabPar.EZPB) * TAN3) end elseif sProfOppoName == '1B' or sProfOppoName == '2B' or sProfOppoName == '3B' or sProfOppoName == '4B' or sProfOppoName == '5B' or sProfOppoName == '6B' or sProfOppoName == '7B' or sProfOppoName == '8B' then nSideOppoType = 3 -- se profilo convex verifico in base al raggio elseif sProfOppoName == 'CV' then nSideOppoType = 4 local dAltProfOppo local dAltProfOppoTh local dExtraYOppoTh -- se abilitato il side probe if nProbeMode == 0 and nPostProbeSet >= 3 then -- calcolo punto minimo ingombro profilo dAltProfOppoTh = tsDoubleData.dThickDoor/2 - tsDoubleData.dPlanePrf -- calcolo errore del probe tastando a spessore completo - extra z dAltProfOppo = (tsDoubleData.dThickDoor/2) - tMainTabPar.EZPB - tsDoubleData.dPlanePrf -- calcolo il delta Y massimo del minimo ingombro profilo dExtraYOppo = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltProfOppo*dAltProfOppo)) dExtraYOppoTh = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltProfOppoTh*dAltProfOppoTh)) -- calcolo errore del probe tastando dallo spessore - quota extra z dDeltaProfOppo = dExtraYOppo - dExtraYOppoTh else -- calcolo punto minimo ingombro profilo dAltProfOppo = tsDoubleData.dThickDoor/2 - tsDoubleData.dPlanePrf -- calcolo il delta Y dExtraYOppo = sqrt((tsDoubleData.dRadiusPrf*tsDoubleData.dRadiusPrf)-(dAltProfOppo*dAltProfOppo)) -- calcolo errore del probe tastando a metà spessore dDeltaProfOppo = tsDoubleData.dRadiusPrf - dExtraYOppo end end end vExtraYDelta = Vector3d(0,-dExtraY,0) -- scrivo le note -- se sono ancora nella prima fase e non sono state fatte lavorazioni allora setto le note -- ancora per la prima disposizione if nNumPhase and nNumPhase == 1 and nNumMach == 0 then EgtSetInfo( Pz, 'ExtraCalcMoveY', dExtraY) EgtSetInfo( Pz, 'DoorProbeErrorY', dDeltaProbe) EgtSetInfo( Pz, 'DoorProbeExtraPosZ', tMainTabPar.EZPB) EgtSetInfo( Pz, 'DoorProbeThick', tMainTabPar.PTK) EgtSetInfo( Pz, 'DoorProfErrorY', dDeltaProf) EgtSetInfo( Pz, 'DoorProfOppoErrorY', dDeltaProfOppo) EgtSetInfo( Pz, 'SideDisposition', DISPMODE) EgtSetInfo( Pz, 'UseViseWithFrame', bUseVise) -- scrivo nota lavorazione lato hinge EgtSetInfo( Pz, 'SideHingeMach', nHingeMach) -- per compatibilità scrivo nota tipo profilo su lato in battuta (inizialmente il lato hinge era sempre in battuta) EgtSetInfo( Pz, 'SideHingeProf', nSideType) -- scrivo profilo lato in battuta EgtSetInfo( Pz, 'SideProfOnRef', nSideType) -- scrivo profilo lato opposto EgtSetInfo( Pz, 'SideProfOnOppo', nSideOppoType) -- scrivo nota lavorazione lato lock EgtSetInfo( Pz, 'SideLockMach', nLockMach) -- scrivo nota con numero geometrie di ProbeZ o probeXY (in base ai settaggi di nProbeMode e nPostProbeSet) EgtSetInfo( Pz, 'NumProbeZ', nNumProbeZ) -- scrivo nota flag modalita remove scrap EgtSetInfo( Pz, 'RemoveScrapMode', tMainTabPar.RSM) -- scrivo nota altezza riferimento e spessore riferimento EgtSetInfo( Pz, 'ReferenceHeight', tMainTabPar.AR) EgtSetInfo( Pz, 'ReferenceTall', tMainTabPar.TR) -- scrivo posizioni riferimenti EgtSetInfo( Pz, 'ReferencePos1', tMainTabPar.REF1) EgtSetInfo( Pz, 'ReferencePos2', tMainTabPar.REF2) EgtSetInfo( Pz, 'ReferencePos3', tMainTabPar.REF3) EgtSetInfo( Pz, 'ReferencePos4', tMainTabPar.REF4) else EgtSetInfo( Pz, 'ExtraCalcMoveY_2', dExtraY) EgtSetInfo( Pz, 'DoorProbeErrorY_2', dDeltaProbe) EgtSetInfo( Pz, 'DoorProbeExtraPosZ_2', tMainTabPar.EZPB) EgtSetInfo( Pz, 'DoorProbeThick', tMainTabPar.PTK) EgtSetInfo( Pz, 'DoorProfErrorY_2', dDeltaProf) EgtSetInfo( Pz, 'DoorProfOppoErrorY_2', dDeltaProfOppo) EgtSetInfo( Pz, 'SideDisposition_2', DISPMODE) EgtSetInfo( Pz, 'UseViseWithFrame_2', bUseVise) -- scrivo nota lavorazione lato hinge EgtSetInfo( Pz, 'SideHingeMach_2', nHingeMach) -- per compatibilità scrivo nota tipo profilo su lato in battuta (inizialmente il lato hinge era sempre in battuta) EgtSetInfo( Pz, 'SideHingeProf_2', nSideType) -- scrivo profilo lato in battuta EgtSetInfo( Pz, 'SideProfOnRef_2', nSideType) -- scrivo profilo lato opposto EgtSetInfo( Pz, 'SideProfOnOppo_2', nSideOppoType) -- scrivo nota lavorazione lato lock EgtSetInfo( Pz, 'SideLockMach_2', nLockMach) -- scrivo nota con numero geometrie di ProbeZ o probeXY (in base ai settaggi di nProbeMode e nPostProbeSet) EgtSetInfo( Pz, 'NumProbeZ_2', nNumProbeZ) -- scrivo nota altezza riferimento e spessore riferimento EgtSetInfo( Pz, 'ReferenceHeight_2', tMainTabPar.AR) EgtSetInfo( Pz, 'ReferenceTall_2', tMainTabPar.TR) -- scrivo posizioni riferimenti EgtSetInfo( Pz, 'ReferencePos1_2', tMainTabPar.REF1) EgtSetInfo( Pz, 'ReferencePos2_2', tMainTabPar.REF2) EgtSetInfo( Pz, 'ReferencePos3_2', tMainTabPar.REF3) EgtSetInfo( Pz, 'ReferencePos4_2', tMainTabPar.REF4) end local vExtraXY local dExtraX = 0 dExtraY = 0 local nCorner = MCH_CR.BL if sAssemb == 'framesx' then dExtraX , dExtraY, nCorner = CalcDispositionRef( true, bTopOnRight, tsDoubleData.dLeftOffs, tsDoubleData.dRightOffs, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs, bFlip, tMainTabPar.FTDD) vExtraXY = Vector3d( dExtraX, dExtraY, 0) -- Muovo frame nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta + vExtraXY), nCorner) elseif sAssemb == 'framedx' then dExtraX , dExtraY, nCorner = CalcDispositionRef( false, bTopOnRight, tsDoubleData.dLeftOffs, tsDoubleData.dRightOffs, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs, bFlip, tMainTabPar.FTDD) vExtraXY = Vector3d( dExtraX, dExtraY, 0) -- Muovo frame nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta + vExtraXY), nCorner) elseif sAssemb == 'frametop' then dExtraX , dExtraY, nCorner = CalcDispositionRef( true, bTopOnRight, tsDoubleData.dLeftOffs, tsDoubleData.dRightOffs, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs, bFlip, tMainTabPar.FTDD) vExtraXY = Vector3d( dExtraX, dExtraY, 0) -- Muovo frame nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta + vExtraXY), nCorner) elseif sAssemb == 'framebot' then dExtraX , dExtraY, nCorner = CalcDispositionRef( false, bTopOnRight, tsDoubleData.dLeftOffs, tsDoubleData.dRightOffs, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs, bFlip, tMainTabPar.FTDD) vExtraXY = Vector3d( dExtraX, dExtraY, 0) -- Muovo frame nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta + vExtraXY), nCorner) else -- Muovo porta con l'angolo in basso a ( destra o sinistra) nella posizione di origine bMoveRaw = EgtMoveToCornerRawPart( nRaw, ( Ori + vExtraYDelta), EgtIf( DISPMODE > 0, MCH_CR.BL, MCH_CR.BR)) end end --debug -- EgtSaveFile() -- EgtMove(DGD.PZ, Point3d(0,0,nil) - ORIG()) --nTime = EgtStopCounter() --if not DGD or not DGD.NCGEN then -- EgtOutBox( string.format( 'tempo calcolato sec: %s', (nTime/1000)), 'Timex', 'Timex') --end -- inizializzo il contatore --EgtStartCounter() if not bMoveRaw then bOk = false DGD.EMC = ' ' .. EgtDoorsMsg[676]..EgtDoorsMsg[474] -- Error positioning raw part on table break end if bFirstStep then if bShiftMchng then sNotePhase = 'SHIFT' else sNotePhase = 'NORMAL' end else if bShiftMchng then sNotePhase = 'FLIPSHIFT' else sNotePhase = 'FLIP' end end -- salvo una nota con le info della disposizione traslata EgtSetInfo( Pz, 'MachineNameFromCurrCamInfo', tMainTabPar.MN) EgtSetInfo( Pz, 'DoorOnTable_' .. EgtNumToString( nNumPhase, 0) .. '_' .. tMainTabPar.MN, sDispMode) EgtSetInfo( Pz, 'KindPhase_' .. EgtNumToString( nNumPhase, 0) .. '_' .. tMainTabPar.MN, sNotePhase) -- salvo note per porta ribaltata rispetto al ddf e per disposizione lato top EgtSetInfo( Pz, 'DispPhase_' .. EgtNumToString( nNumPhase, 0) , EgtIf( bFlip, 'F', 'N')) EgtSetInfo( Pz, 'DispTopOn_' .. EgtNumToString( nNumPhase, 0) , EgtIf( bTopOnRight, 'R', 'L')) if bFlip then -- se porta capovolta if bTopOnRight then -- se top a destra -- il lato sinistro appoggia sui riferimenti OffsYSovr = tsDoubleData.dLeftOffs OffsXSovr = EgtIf( DISPMODE > 0, tsDoubleData.dBottomOffs, tsDoubleData.dTopOffs) else -- se top a sinistra -- il lato destro appoggia sui riferimenti OffsYSovr = tsDoubleData.dRightOffs OffsXSovr = EgtIf( DISPMODE > 0, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs) end else -- altrimenti non è capovolta if bTopOnRight then -- se top a destra -- il lato destro appoggia sui riferimenti OffsYSovr = tsDoubleData.dRightOffs OffsXSovr = EgtIf( DISPMODE > 0, tsDoubleData.dBottomOffs, tsDoubleData.dTopOffs) else -- se top a sinistra -- il lato sinistro appoggia sui riferimenti OffsYSovr = tsDoubleData.dLeftOffs OffsXSovr = EgtIf( DISPMODE > 0, tsDoubleData.dTopOffs, tsDoubleData.dBottomOffs) end end -- se frame riassegno il valore del sovramateriale perché viene tenuto a filo della ventosa if bFrame then if nCodeVacDisp == 1 then if bUseVise then OffsXSovr = EgtIf( DISPMODE > 0, abs( tMainTabPar.OR1fv:getX() - tMainTabPar.OR1:getX()), abs( tMainTabPar.OR2fv:getX() - tMainTabPar.OR2:getX())) else OffsXSovr = EgtIf( DISPMODE > 0, abs( tMainTabPar.OR1f:getX() - tMainTabPar.OR1:getX()), abs( tMainTabPar.OR2f:getX() - tMainTabPar.OR2:getX())) end elseif nCodeVacDisp == 2 then OffsXSovr = EgtIf( DISPMODE > 0, abs( tMainTabPar.OR3f:getX() - tMainTabPar.OR1:getX()), abs( tMainTabPar.OR4f:getX() - tMainTabPar.OR2:getX())) elseif nCodeVacDisp == 3 then OffsXSovr = EgtIf( DISPMODE > 0, abs( tMainTabPar.OR5f:getX() - tMainTabPar.OR1:getX()), abs( tMainTabPar.OR6f:getX() - tMainTabPar.OR2:getX())) end end -- Controllo dimensioni pezzo -- se è un frame if bFrame then -- controllo se le dimensioni porta sono compresi nei valori minimi e massimi bFailDim = CheckPieceDimension( bFrame, tsDoubleData.dLengthDoor, tsDoubleData.dWidthDoor, tsDoubleData.dThickDoor, 0, 0, 0, 0) else -- controllo se le dimensioni porta sono compresi nei valori minimi e massimi bFailDim = CheckPieceDimension( bFrame, tsDoubleData.dLengthDoor, tsDoubleData.dWidthDoor, tsDoubleData.dThickDoor, OffsXSovr, OffsYSovr, vShift:getX(), vShift:getY()) end if bFailDim then DGD.ERR = 19 -- cancello e ricreo il file txt EgtEraseFile( sFileDir..sFileName..'.txt') --ricreo il file txt con la disposizione WriteErrFile( sFileDir..sFileName..'.txt') -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) DoorOutLog( DGD.EMC, 0) EgtOutBox( ' Err=' .. EgtNumToString( DGD.ERR, 0) .. DGD.EMC, EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on Nc part program generation end return false end ----------------------------------------------------------------------------------------------------------------- -- abilito/disabilito geometrie probe in base alla lavorazione o meno del fianco e dal tipo di profilo di questo ----------------------------------------------------------------------------------------------------------------- -- se profilo hinge è da lavorare rinomino i percorsi di probe per non farli if tsBoolData.bHingeMach then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 1 then EgtSetName( ProbeList[j], 'NO_ProbeSidePoint' ) end end -- se non da lavorare e profilo bevel dn cambio lo spessore a: spessore probe + extra probe z elseif not tsBoolData.bHingeMach and ( tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BDEB') then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 1 then -- EgtModifyCurveThickness( ProbeList[j], 0) EgtModifyCurveThickness( ProbeList[j], -tMainTabPar.EZPB) EgtSetInfo( ProbeList[j], 'ProfSide', 'BD') end end -- se profilo non lavorato e di tipo bullnose cambio lo spessore a metà porta + extra probe z elseif not tsBoolData.bHingeMach and ( tsStringData.sHingeTrim == '1B' or tsStringData.sHingeTrim == '2B' or tsStringData.sHingeTrim == '3B' or tsStringData.sHingeTrim == '4B' or tsStringData.sHingeTrim == '5B' or tsStringData.sHingeTrim == '6B' or tsStringData.sHingeTrim == '7B' or tsStringData.sHingeTrim == '8B') then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 1 then EgtModifyCurveThickness( ProbeList[j], -( tsDoubleData.dThickDoor/2 + tMainTabPar.EZPB)) end end -- in tutti gli altri profili setto l'affondamento a extra probe z elseif not tsBoolData.bHingeMach then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 1 then EgtModifyCurveThickness( ProbeList[j], -tMainTabPar.EZPB) -- EgtModifyCurveThickness( ProbeList[j], 0) -- se profilo bevel up assegno nota if tsStringData.sHingeTrim == 'BU' or tsStringData.sHingeTrim == 'BUEB' then EgtSetInfo( ProbeList[j], 'ProfSide', 'BU') end end end end -- se profilo lock è da lavorare rinomino i percorsi di probe per non farli if tsBoolData.bLockMach then -- recupero entità probe di fianco su lato secure local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 3 then EgtSetName( ProbeList[j], 'NO_ProbeSidePoint' ) end end -- se non da lavorare e profilo bevel dn cambio lo spessore allo spessore probe + extra probe z elseif not tsBoolData.bLockMach and ( tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BDEB') then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 3 then -- EgtModifyCurveThickness( ProbeList[j], 0) EgtModifyCurveThickness( ProbeList[j], -tMainTabPar.EZPB) EgtSetInfo( ProbeList[j], 'ProfSide', 'BD') end end -- se profilo non lavorato e di tipo bullnose cambio lo spessore a metà porta + extra probe z elseif not tsBoolData.bLockMach and ( tsStringData.sLockTrim == '1B' or tsStringData.sLockTrim == '2B' or tsStringData.sLockTrim == '3B' or tsStringData.sLockTrim == '4B' or tsStringData.sLockTrim == '5B' or tsStringData.sLockTrim == '6B' or tsStringData.sLockTrim == '7B' or tsStringData.sLockTrim == '8B') then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 3 then EgtModifyCurveThickness( ProbeList[j], -( tsDoubleData.dThickDoor/2 + tMainTabPar.EZPB)) end end -- in tutti gli altri profili setto l'affondamento a extra probe z elseif not tsBoolData.bLockMach then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 3 then EgtModifyCurveThickness( ProbeList[j], -tMainTabPar.EZPB) -- EgtModifyCurveThickness( ProbeList[j], 0) -- se profilo bevel up assegno nota if tsStringData.sLockTrim == 'BU' or tsStringData.sLockTrim == 'BUEB' then EgtSetInfo( ProbeList[j], 'ProfSide', 'BU') end end end end -- se profilo top è da lavorare rinomino i percorsi di probe per non farli if tsBoolData.bTopMach then -- recupero entità probe di fianco su lato secure local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 2 then EgtSetName( ProbeList[j], 'NO_ProbeSidePoint' ) end end -- se non da lavorare e profilo bevel dn cambio lo spessore allo spessore probe + extra probe z elseif not tsBoolData.bTopMach and ( tsStringData.sTopTrim == 'BD' or tsStringData.sTopTrim == 'BDEB') then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 2 then -- EgtModifyCurveThickness( ProbeList[j], 0) EgtModifyCurveThickness( ProbeList[j], -tMainTabPar.EZPB) EgtSetInfo( ProbeList[j], 'ProfSide', 'BD') end end -- se profilo non lavorato e di tipo bullnose cambio lo spessore a metà porta elseif not tsBoolData.bTopMach and ( tsStringData.sTopTrim == '1B' or tsStringData.sTopTrim == '2B' or tsStringData.sTopTrim == '3B' or tsStringData.sTopTrim == '4B' or tsStringData.sTopTrim == '5B' or tsStringData.sTopTrim == '6B' or tsStringData.sTopTrim == '7B' or tsStringData.sTopTrim == '8B') then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 2 then EgtModifyCurveThickness( ProbeList[j], -( tsDoubleData.dThickDoor/2 + tMainTabPar.EZPB)) end end -- in tutti gli altri profili setto l'affondamento a extra probe z elseif not tsBoolData.bTopMach then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 2 then EgtModifyCurveThickness( ProbeList[j], -tMainTabPar.EZPB) -- EgtModifyCurveThickness( ProbeList[j], 0) -- se profilo bevel up assegno nota if tsStringData.sTopTrim == 'BU' or tsStringData.sTopTrim == 'BUEB' then EgtSetInfo( ProbeList[j], 'ProfSide', 'BU') end end end end -- se profilo bottom è da lavorare oppure non da lavorare ma con profilo bevel up rinomino i percorsi di probe per non farli if tsBoolData.bBottomMach then -- recupero entità probe di fianco su lato secure local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 4 then EgtSetName( ProbeList[j], 'NO_ProbeSidePoint' ) end end -- se non da lavorare e profilo bevel dn cambio lo spessore allo spessore probe + extra probe z elseif not tsBoolData.bBottomMach and ( tsStringData.sBottomTrim == 'BD' or tsStringData.sBottomTrim == 'BDEB') then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 4 then -- EgtModifyCurveThickness( ProbeList[j], 0) EgtModifyCurveThickness( ProbeList[j], -tMainTabPar.EZPB) EgtSetInfo( ProbeList[j], 'ProfSide', 'BD') end end -- se profilo non lavorato e di tipo bullnose cambio lo spessore a metà porta elseif not tsBoolData.bBottomMach and ( tsStringData.sBottomTrim == '1B' or tsStringData.sBottomTrim == '2B' or tsStringData.sBottomTrim == '3B' or tsStringData.sBottomTrim == '4B' or tsStringData.sBottomTrim == '5B' or tsStringData.sBottomTrim == '6B' or tsStringData.sBottomTrim == '7B' or tsStringData.sBottomTrim == '8B') then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 4 then EgtModifyCurveThickness( ProbeList[j], -( tsDoubleData.dThickDoor/2 + tMainTabPar.EZPB)) end end -- in tutti gli altri profili setto l'affondamento a extra probe z elseif not tsBoolData.bBottomMach then -- recupero entità probe di fianco local ProbeList = MB.FindEntitiesWithName( Pz, 'ProbeSidePoint') local eProSide -- ciclo su tutte le entità trovate for j = 1, #ProbeList do eProSide = EgtGetInfo( ProbeList[j], 'SideApplied', 'i') or 0 if eProSide == 4 then EgtModifyCurveThickness( ProbeList[j], -tMainTabPar.EZPB) -- EgtModifyCurveThickness( ProbeList[j], 0) -- se profilo bevel up assegno nota if tsStringData.sBottomTrim == 'BU' or tsStringData.sBottomTrim == 'BUEB' then EgtSetInfo( ProbeList[j], 'ProfSide', 'BU') end end end end ------------------------------------------- -- Inserimento riferimenti e ventose/morse ------------------------------------------- if v == 1 then -- Offset barra riferimenti mobile da riferimenti quando posizione 0 dMobOffs2 = 0 dMobOffs1 = dMobOffs2 / 2 -- è in posizione intermedia -- Lunghezza minima per alzare prima ventosa da bordo sinistro -- ( dall'angolo rettangolo al punto centrale ventose + 5.5 + distanza riferimento-rettangolo) -- dDistMinX = 296.8 + 5.5 + 46.7 -- dall'angolo appoggio porta (riferimento) al punto centrale ventose + mezza larghezza ventosa (in X) + quota sicurezza dDistMinX = tMainTabPar.DVL + 92.075 + DIST_MIN_VAC -- Lunghezza minima per alzare prima ventosa da bordo destro -- ( dall'angolo rettangolo al punto centrale ventose + 5.5 + distanza riferimento-rettangolo) -- dDistMaxX = 185.1 + 5.5 + 46.7 -- dall'angolo appoggio porta (riferimento) al punto centrale ventose + mezza larghezza ventosa (in X) + quota sicurezza dDistMaxX = tMainTabPar.DVR + 92.075 + DIST_MIN_VAC -- Posizione ventose in alto dVacOn = 1 -- Interasse ventose lungo la barra dInterAx = 193.68 -- setto modaità due barre disabilitato bUseOnly2Bars = false -- Ventose nTabId = EgtGetTableId( sTab) nMobId1 = EgtGetFirstNameInGroup( nTabId or GDB_ID.NULL, 'MOBILE1') nMobId2 = EgtGetFirstNameInGroup( nTabId or GDB_ID.NULL, 'MOBILE2') nFixId = EgtGetFirstNameInGroup( nTabId or GDB_ID.NULL, 'FIXED') -- Riferimenti: faccio una ricerca dedicata per via che non si conoscono ancora i nomi esatti -- dei riferimenti inseriti if tMainTabPar.CUC == 1 then tRefArea = FindRefInTable( nTabId, 'REF_') end nDispId = EgtGetPhaseDisposition( nNumPhase) -- se gruppi richiesti non trovati if not nMobId1 or not nMobId2 or not nFixId then bOk = false DGD.EMC = ' ' .. EgtDoorsMsg[676]..EgtDoorsMsg[530] -- Error on MOBILE or FIXED table bar' break end -- Posizionamento barra mobile -- fisso dFixval = EgtGetInfo( nFixId, 'Val', 'd') -- scrivo il valore della barra fissa EgtSetInfo( nDispId, 'FIX1', dFixval) -- mobile 2 dOldVal = EgtGetInfo( nMobId2, 'Val', 'd') if bFrame then -- se è un frame dNewVal_2 = tMainTabPar.FPB else if tsDoubleData.dTopRadius then -- se la porta è ad arco calcolo la disposizione sulla terza barra simmetrica alla prima if bFirstStep then dNewVal_2 = b3Solid:getDimX() - dFixval + (2*OffsYSovr) + vShiftVac:getY() - dMobOffs2 -- calcolo la posizione simmetrica -- dNewVal_2 = b3Solid:getDimX() - dFixval + (2*OffsYSovr) - vShift:getY() + vShiftVac:getY() - dMobOffs2 -- calcolo la posizione simmetrica end else -- calcolo la disposizione sulla terza barra simmetrica alla prima if bFirstStep then dNewVal_2 = b3Solid:getDimX() - dFixval + (2*OffsYSovr) + vShiftVac:getY() - dMobOffs2 -- calcolo la posizione simmetrica -- dNewVal_2 = b3Solid:getDimX() - dFixval + (2*OffsYSovr) - vShift:getY() + vShiftVac:getY() - dMobOffs2 -- calcolo la posizione simmetrica -- prediligo la conservazione delle ventose sulla terza barra -- dNewVal_2 = b3Solid:getDimX() - dFixval + OffsYSovr - vShift:getY() + vShiftVac:getY() - dMobOffs2 end end end -- controllo che non supera la posizione massima raggiungibile if dNewVal_2 > tMainTabPar.MPMB then dNewVal_2 = tMainTabPar.MPMB end -- Se posizione raggiungibile if ( dNewVal_2 - dFixval + (2*vShift:getY())) >= ( 2 * dMinDistGroup) then -- mobile 2 if bFirstStep then dNewVal_2 = dNewVal_2 + 2 * vShift:getY() EgtMove( nMobId2, Vector3d( 0, dNewVal_2 - dOldVal, 0), GDB_RT.GLOB) end EgtSetInfo( nMobId2, 'Val', dNewVal_2) EgtSetInfo( nDispId, 'MOB2', dNewVal_2) -- mobile 1 if bFirstStep then dOldVal = EgtGetInfo( nMobId1, 'Val', 'd') dNewVal_1 = ( dNewVal_2 + dFixval) / 2 EgtMove( nMobId1, Vector3d( 0, dNewVal_1 - dOldVal, 0), GDB_RT.GLOB) end EgtSetInfo( nMobId1, 'Val', dNewVal_1) EgtSetInfo( nDispId, 'MOB1', dNewVal_1) else -- controllo se con due barre è possibile if ( dNewVal_2 - dFixval + (2*vShift:getY())) >= dMinDistGroup then -- mobile 1 dOldVal = EgtGetInfo( nMobId1, 'Val', 'd') -- se proprietà narrow stile attiva, aggiungo al movimento lo shift e la distanza riferimento ventosa -- if bNarrowStile then dNewVal_1 = dNewVal_2 + 2 * vShift:getY() -- else -- dNewVal_1 = dNewVal_2 -- end EgtMove( nMobId1, Vector3d( 0, dNewVal_1 - dOldVal, 0), GDB_RT.GLOB) EgtSetInfo( nMobId1, 'Val', dNewVal_1) EgtSetInfo( nDispId, 'MOB1', dNewVal_1) -- mobile 2 dOldVal = EgtGetInfo( nMobId2, 'Val', 'd') dNewVal_2 = (dNewVal_1 * 2) - dFixval EgtMove( nMobId2, Vector3d( 0, dNewVal_2 - dOldVal, 0), GDB_RT.GLOB) EgtSetInfo( nMobId2, 'Val', dNewVal_2) EgtSetInfo( nDispId, 'MOB2', dNewVal_2) bUseOnly2Bars = true else -- mobile 2 EgtSetInfo( nDispId, 'MOB2', dOldVal) -- mobile 1 dOldVal = EgtGetInfo( nMobId1, 'Val', 'd') EgtSetInfo( nDispId, 'MOB1', dOldVal) end end end -- Elevazione ventose con: altezza porta ( uso getDimY perché presa prima della disposizione porta) + -- sovramateriale a contatto con il riferimento a sx - distanza ventosa dCalcLen = b3Solid:getDimY() + OffsXSovr - EgtIf( DISPMODE > 0, dDistMinX, dDistMaxX) -- calcolo positione top porta rispetto allo zero macchina local nTabRef = EgtGetFirstNameInGroup( nTabId or GDB_ID.NULL, 'R1') local pPiecePos = EgtSP( nTabRef, GDB_ID.ROOT) + Ori + vExtraYDelta -- se il top porta è opposto al lato dei riferimenti if (DISPMODE > 0 and bTopOnRight) or ( DISPMODE < 0 and not bTopOnRight) then pPiecePos = pPiecePos + Vector3d( (b3Solid:getDimY() + OffsXSovr - DIST_MIN_VAC)*DISPMODE,0,0) else -- se top porta è adiacente al lato dei riferimenti pPiecePos = pPiecePos + Vector3d( (OffsXSovr + DIST_MIN_VAC)*DISPMODE,0,0) end -- predispongo regioni per verifica interferenza con lavorazioni passanti o da sotto StartVacVerify( Ls, bFlip, nProbeMode, tsDoubleData.dThickDoor, bFlipFrame) -- ciclo sulle ventose local nInd = 1 local bFoundSpecialVac -- tabelle per gestione conteggi inserimento ventose, gli indici tabella sono le barre (1 fissa, 2 intermedia, 3 mobile) local tnCountFailed = {} -- tabella conteggio ventose non disposte tnCountFailed[1] = 0 tnCountFailed[2] = 0 tnCountFailed[3] = 0 local tnIniFailed = {} -- tabella conteggio ventose iniziali non disposte tnIniFailed[1] = 0 tnIniFailed[2] = 0 tnIniFailed[3] = 0 local tnMiddleFailed = {} -- tabella conteggio ventose intermedie non disposte tnMiddleFailed[1] = 0 tnMiddleFailed[2] = 0 tnMiddleFailed[3] = 0 local tnEndFailed = {} -- tabella conteggio ventose finali non disposte tnEndFailed[1] = 0 tnEndFailed[2] = 0 tnEndFailed[3] = 0 local tnMaxIniFailed = {} -- tabella contatore totale ventose iniziali non disposte tnMaxIniFailed[1] = 0 tnMaxIniFailed[2] = 0 tnMaxIniFailed[3] = 0 local tnMaxMiddleFailed = {}-- tabella contatore totale ventose intermedie non disposte tnMaxMiddleFailed[1] = 0 tnMaxMiddleFailed[2] = 0 tnMaxMiddleFailed[3] = 0 local tnMaxEndFailed = {} -- tabella contatore totale ventose finali non disposte tnMaxEndFailed[1] = 0 tnMaxEndFailed[2] = 0 tnMaxEndFailed[3] = 0 -- tabella gestione ventose, gli indici tabella rappresentano le barre (1 fissa, 2 intermedia, 3 mobile) local tsBaseDataVac1 = {} -- tabella nomi punti ventosa base tsBaseDataVac1[1] = { tMainTabPar.P1T, tMainTabPar.V1T1, tMainTabPar.V1T1E, tMainTabPar.DTG, tMainTabPar.DBG, tMainTabPar.DSG, tMainTabPar.DTGN, tMainTabPar.DBGN, tMainTabPar.DSGN} tsBaseDataVac1[2] = { tMainTabPar.P1T, tMainTabPar.V2T1, tMainTabPar.V2T1E, tMainTabPar.DTG, tMainTabPar.DBG, tMainTabPar.DSG, tMainTabPar.DTGN, tMainTabPar.DBGN, tMainTabPar.DSGN} tsBaseDataVac1[3] = { tMainTabPar.P1T, tMainTabPar.V3T1, tMainTabPar.V3T1E, tMainTabPar.DTG, tMainTabPar.DBG, tMainTabPar.DSG, tMainTabPar.DTGN, tMainTabPar.DBGN, tMainTabPar.DSGN} local tsBaseDataVac2 = {} -- tabella nomi punti ventosa secondo tipo tsBaseDataVac2[1] = { tMainTabPar.P2T, tMainTabPar.V1T2, tMainTabPar.V1T2E, tMainTabPar.DTG, tMainTabPar.DBG, tMainTabPar.DSG, tMainTabPar.DTGN, tMainTabPar.DBGN, tMainTabPar.DSGN} tsBaseDataVac2[2] = { tMainTabPar.P2T, tMainTabPar.V2T2, tMainTabPar.V2T2E, tMainTabPar.DTG, tMainTabPar.DBG, tMainTabPar.DSG, tMainTabPar.DTGN, tMainTabPar.DBGN, tMainTabPar.DSGN} tsBaseDataVac2[3] = { tMainTabPar.P2T, tMainTabPar.V3T2, tMainTabPar.V3T2E, tMainTabPar.DTG, tMainTabPar.DBG, tMainTabPar.DSG, tMainTabPar.DTGN, tMainTabPar.DBGN, tMainTabPar.DSGN} local tsBaseDataVac3 = {} -- tabella nomi punti ventosa terzo tipo tsBaseDataVac3[1] = { tMainTabPar.P3T, tMainTabPar.V1T3, tMainTabPar.V1T3E, tMainTabPar.DTG, tMainTabPar.DBG, tMainTabPar.DSG, tMainTabPar.DTGN, tMainTabPar.DBGN, tMainTabPar.DSGN} tsBaseDataVac3[2] = { tMainTabPar.P3T, tMainTabPar.V2T3, tMainTabPar.V2T3E, tMainTabPar.DTG, tMainTabPar.DBG, tMainTabPar.DSG, tMainTabPar.DTGN, tMainTabPar.DBGN, tMainTabPar.DSGN} tsBaseDataVac3[3] = { tMainTabPar.P3T, tMainTabPar.V3T3, tMainTabPar.V3T3E, tMainTabPar.DTG, tMainTabPar.DBG, tMainTabPar.DSG, tMainTabPar.DTGN, tMainTabPar.DBGN, tMainTabPar.DSGN} -- tabella gestione morse, gli indici tabella rappresentano le barre (1 fissa, 2 intermedia, 3 mobile) local tsBaseDataVise1 = {} -- tabella nomi punti ventosa base tsBaseDataVise1[1] = { tMainTabPar.P1T, tMainTabPar.VSF1, tMainTabPar.DTGV, tMainTabPar.DBGV, tMainTabPar.DSGV} local tIdViseDisp = {} --------------------------------------------------------------------------------------------- -- tabella delle tabelle dei tipi di ventose gestite, per ora si gestiscono 3 tipi -- aggiungere nella tabella gli eventuali tipi da aggiungere local ttBaseDataVac = {} -- tabella globale dei tipi di ventose di tutte le barre ttBaseDataVac = { tsBaseDataVac1, tsBaseDataVac2, tsBaseDataVac3} --------------------------------------------------------------------------------------------- -- tabella delle tabelle dei tipi di morse gestite, per ora si gestiscono 1 tipo -- aggiungere nella tabella gli eventuali tipi da aggiungere local ttBaseDataVise = {} -- tabella globale dei tipi di ventose di tutte le barre ttBaseDataVise = { tsBaseDataVise1} --------------------------------------------------------------------------------------------- -- tabella dei riferimenti, nel CurrCamInfo i dati sono ridondanti rispetto all'originale nel file mlde local tBaseDataRef = {} tBaseDataRef = { tMainTabPar.REF1, tMainTabPar.REF2, tMainTabPar.REF3, tMainTabPar.REF4} --------------------------------------------------------------------------------------------- local tsBaseNameVac = {} -- tabella nomi ventose tipo unificato normale tsBaseNameVac[1] = {'','',0} tsBaseNameVac[2] = {'','',0} tsBaseNameVac[3] = {'','',0} --------------------------------------- local tsNoteRow = {} -- tabella per note da assegnare alle geometrie delle barre tsNoteRow[1] = '' tsNoteRow[2] = '' tsNoteRow[3] = '' -- questa tabella deve essere settata in base ai sottopezzi presenti nella cartella della macchina -- e al disegno della macchina( deve avere nome dei punti, ecc.) local tnNumVacInsert = {} -- tabella per numero di tipi di ventosa presenti sulle barre tnNumVacInsert[1] = tMainTabPar.NTVB1 or 1 tnNumVacInsert[2] = tMainTabPar.NTVB2 or 1 tnNumVacInsert[3] = tMainTabPar.NTVB3 or 1 -- se ho un solo tipo di ventose sulla barra carico in questa tabella local tnTypeSingleVacOnBar = {} tnTypeSingleVacOnBar[1] = tMainTabPar.TSVB1 tnTypeSingleVacOnBar[2] = tMainTabPar.TSVB2 tnTypeSingleVacOnBar[3] = tMainTabPar.TSVB3 -- tabella che indica il tipo di ventosa corrente local tnNumKindVac = {} tnNumKindVac[1] = 1 -- solo valore di inizializzazione tnNumKindVac[2] = 1 -- solo valore di inizializzazione tnNumKindVac[3] = 1 -- solo valore di inizializzazione --------------------------------------- -- tabella posizionamento ventose local tPosRowSubPieceRow1 = {} local tPosRowSubPieceRow2 = {} local tPosRowSubPieceRow3 = {} local tdYCommpos = {} -- tabella valori Y con sottopezzi identici --------------------------------------- -- settaggio ventosa arco su porta ad arco: -- annullo nome ventosa se porta ad arco con centro arco non oltre i 2" -- annullo nome ventosa se c'é proprietà porta if not tsDoubleData.dTopxDeltapos or ( tsDoubleData.dTopxDeltapos and abs(tsDoubleData.dTopxDeltapos) > 50.8) then tMainTabPar.AVNM = '' end -- se porta narrowstile forzo ad utilizzare solo le ventose strette sulle barre esterne if bNarrowStile then tMainTabPar.FVR = true end while dCalcLen > 0 and nInd <= tMainTabPar.NTVR do local nIndVac = EgtIf( DISPMODE > 0, nInd, ( tMainTabPar.NTVR - nInd + 1)) local sInd = EgtNumToString( nIndVac, 0) if nCodeVacDisp <= 1 then tPosRowSubPieceRow1[nIndVac] = CalcDispositionSubPieces( 1, nFixId, tMainTabPar.FVR, tsBaseNameVac, EgtIf( bUseVise, ttBaseDataVise, ttBaseDataVac), sInd, tnNumVacInsert, tnNumKindVac, tdYCommpos, nInd, tnCountFailed, tnMaxIniFailed, tnIniFailed, tnMaxMiddleFailed, tnMiddleFailed, tnMaxEndFailed, tnEndFailed, tMainTabPar.NTVR, ( dCalcLen - dInterAx), bNarrowStile, tabOri, tnTypeSingleVacOnBar, bFrameOnNarrow, bUseVise, tsDoubleData.dWidthDoor) end if nCodeVacDisp == 0 or nCodeVacDisp == 2 then local nIdVac = 2 if bUseOnly2Bars then nIdVac = 3 end tPosRowSubPieceRow2[nIndVac] = CalcDispositionSubPieces( nIdVac, nMobId1, tMainTabPar.FVR, tsBaseNameVac, ttBaseDataVac, sInd, tnNumVacInsert, tnNumKindVac, tdYCommpos, nInd, tnCountFailed, tnMaxIniFailed, tnIniFailed, tnMaxMiddleFailed, tnMiddleFailed, tnMaxEndFailed, tnEndFailed, tMainTabPar.NTVR, ( dCalcLen - dInterAx), bNarrowStile, tabOri, tnTypeSingleVacOnBar, bFrameOnNarrow) end if ( nCodeVacDisp == 0 or nCodeVacDisp == 3) and not bUseOnly2Bars then tPosRowSubPieceRow3[nIndVac] = CalcDispositionSubPieces( 3, nMobId2, tMainTabPar.FVR, tsBaseNameVac, ttBaseDataVac, sInd, tnNumVacInsert, tnNumKindVac, tdYCommpos, nInd, tnCountFailed, tnMaxIniFailed, tnIniFailed, tnMaxMiddleFailed, tnMiddleFailed, tnMaxEndFailed, tnEndFailed, tMainTabPar.NTVR, ( dCalcLen - dInterAx), bNarrowStile, tabOri, tnTypeSingleVacOnBar, bFrameOnNarrow) end -- aggiorno la lunghezza di calcolo e l'indice dCalcLen = dCalcLen - dInterAx nInd = nInd + 1 end -- end while -- verifico la tabella di disposizione della barra centrale e le opportune verifiche per inserire la ventosa ad arco: -- se non si utilizzano solo due barre e ho la ventosa ad arco if not bUseOnly2Bars and tMainTabPar.AVNM and #tMainTabPar.AVNM > 0 then tPosRowSubPieceRow2, bFoundSpecialVac = InsertSpecialSubPiece( tPosRowSubPieceRow2, tMainTabPar.NTVR, bTopOnRight, tMainTabPar.AVNM, tabOri, tMainTabPar.ADTG, tMainTabPar.ADBG, tMainTabPar.ADSG, pPiecePos, 2, tnMaxIniFailed, tnMaxMiddleFailed, tnMaxEndFailed, DISPMODE) end -- elimino geometrie per verifica EndVacVerify() for l = 1, tMainTabPar.NTVR do local nIndVac = EgtIf( DISPMODE > 0, l, ( tMainTabPar.NTVR - l + 1)) if nCodeVacDisp <= 1 then -- porta o frame su prima linea vicino a riferimenti local nIdVise = DispositionSubPieces( 1, nIndVac, tPosRowSubPieceRow1, tMainTabPar.FVR, tsBaseNameVac, tdYCommpos, EgtIf( bUseVise, ttBaseDataVise, ttBaseDataVac), nIndVac, tabOri, tsNoteRow, nDispId, nil, nil, nil, nil, bUseVise, tsDoubleData.dWidthDoor) if bUseVise and nIdVise then table.insert( tIdViseDisp, { nIdVise, nIndVac}) end end if nCodeVacDisp == 0 or nCodeVacDisp == 2 then -- porta o frame su linea intermedia local nIdVac = 2 if bUseOnly2Bars then nIdVac = 3 end DispositionSubPieces( nIdVac, nIndVac, tPosRowSubPieceRow2, tMainTabPar.FVR, tsBaseNameVac, tdYCommpos, ttBaseDataVac, ( nIndVac + 1), tabOri, tsNoteRow, nDispId, tMainTabPar.AVNM, pPiecePos, Pz, bFoundSpecialVac) end if nCodeVacDisp == 0 or nCodeVacDisp == 3 then -- porta o frame su ultima linea lontana dai riferimenti local nIdVac = 3 if bUseOnly2Bars then nIdVac = 2 end DispositionSubPieces( nIdVac, nIndVac, tPosRowSubPieceRow3, tMainTabPar.FVR, tsBaseNameVac, tdYCommpos, ttBaseDataVac, nIndVac, tabOri, tsNoteRow, nDispId) end end -- dispongo i riferimenti (utilizzati nella disposizione comportano di far correttamente risalire in Z un aggregato -- se questo viene trovato in collisione mentre sta eseguendo un movimento in rapido da una lavorazione ad un altra) if DISPMODE < 0 and tMainTabPar.CUC == 1 then local nMaxDist = max( tBaseDataRef[1][4], tBaseDataRef[2][4], tBaseDataRef[3][4], tBaseDataRef[4][4]) EgtSetTableAreaOffset( nMaxDist, nMaxDist, nMaxDist, nMaxDist) -- area maggiorata DispositionReferences( tBaseDataRef[1][1], tBaseDataRef[1][2], tBaseDataRef[1][3]) -- riferimento in testa dx DispositionReferences( tBaseDataRef[2][1], tBaseDataRef[2][2], tBaseDataRef[2][3]) -- riferimento in basso dx DispositionReferences( tBaseDataRef[3][1], tBaseDataRef[3][2], tBaseDataRef[3][3]) -- riferimento in basso sx elseif tMainTabPar.CUC == 1 then local nMaxDist = max( tBaseDataRef[1][4], tBaseDataRef[2][4], tBaseDataRef[3][4], tBaseDataRef[4][4]) EgtSetTableAreaOffset( nMaxDist, nMaxDist, nMaxDist, nMaxDist) -- area maggiorata DispositionReferences( tBaseDataRef[2][1], tBaseDataRef[2][2], tBaseDataRef[2][3]) -- riferimento in basso dx DispositionReferences( tBaseDataRef[3][1], tBaseDataRef[3][2], tBaseDataRef[3][3]) -- riferimento in basso sx DispositionReferences( tBaseDataRef[4][1], tBaseDataRef[4][2], tBaseDataRef[4][3]) -- riferimento in testa a sx end --nTime = EgtStopCounter() --if not DGD or not DGD.NCGEN then -- EgtOutBox( string.format( 'tempo calcolato sec: %s', (nTime/1000)), 'Timey', 'Timey') --end -- inizializzo il contatore --EgtStartCounter() -- scrivo nota linea di ventose if #tsNoteRow[1] > 0 then EgtSetInfo( Pz, 'FixVacRow_Phase_'..EgtNumToString( nNumPhase, 0), tsNoteRow[1]) end if bUseOnly2Bars then if #tsNoteRow[2] > 0 then EgtSetInfo( Pz, 'Mob2VacRow_Phase_'..EgtNumToString( nNumPhase, 0), tsNoteRow[2]) end if #tsNoteRow[3] > 0 then EgtSetInfo( Pz, 'Mob1VacRow_Phase_'..EgtNumToString( nNumPhase, 0), tsNoteRow[3]) end else if #tsNoteRow[2] > 0 then EgtSetInfo( Pz, 'Mob1VacRow_Phase_'..EgtNumToString( nNumPhase, 0), tsNoteRow[2]) end if #tsNoteRow[3] > 0 then EgtSetInfo( Pz, 'Mob2VacRow_Phase_'..EgtNumToString( nNumPhase, 0), tsNoteRow[3]) end end -- scrivo note con i valori di partenza della prima ventosa in basso a destra EgtSetInfo( Pz, 'FixValX', tMainTabPar.DVR) EgtSetInfo( Pz, 'FixValY', dFixval) EgtSetInfo( Pz, 'UseOnly2Bars', bUseOnly2Bars) -- scrivo la nota relativa all'attivazione o meno del controllo collisioni EgtSetInfo( Pz, 'EnableCollisionDetect', tMainTabPar.ECD) -- verifico se numero di ventose sufficienti e do errore nel caso contrario bOk, DGD.EMC = CheckEnoughVacuums( ( nInd - 1), nCodeVacDisp, tnMaxIniFailed, tnMaxMiddleFailed, tnMaxEndFailed, bUseOnly2Bars, tsDoubleData.dTopRadius, bTopOnRight, bUseVise, tIdViseDisp) if DGD.EMC and #DGD.EMC > 0 then -- se ho messaggio di errore lo mando una riga sotto per stamparlo correttamente DGD.EMC = '\n' .. DGD.EMC end if not bOk then break end ---------------------- ---------------------- -- *** Lavorazioni *** ---------------------- ---------------------- local bMakeGhost = EgtIf( bFirstStep, true, false) -- ricavo minimo e massimo del solido del pezzo b3SolidOnTab = EgtGetBBoxGlob( Ls, GDB_BB.EXACT) pMin = b3SolidOnTab:getMin() pMax = b3SolidOnTab:getMax() if v == 1 then -- solo il primo pezzo -- print Machining table for i = nIndexStartMach, #tLocMach do DoorOutLog( 'L'..EgtNumToString( i, 0) .. ' EN='.. (tLocMach[i].On or ' ') ..' N='.. tLocMach[i].Name .. ' O='.. (tLocMach[i].Oper or ' ') .. ' M='.. (tLocMach[i].Mach or ' ') .. ' MAC='.. (tLocMach[i].MachName or ' '), -1) end end -- solo il primo giro aggiusto i profili bevel per essere coerente con la sequenza di tabella. -- si è inserito il controllo che non sia anche una porta shiftata per non lavorarla in prima fase -- e poi ri-disporla in una eventuale seconda fase -- inserisco una modifica al controllo shift ma solo se non dipende dalle property -- if bFirstStep and ( not bShiftMchng or bSmallShiftedDoor) and nProbeMode ~= 1 then if bFirstStep and ( ( not bShiftMchng ) or ( bShiftMchng and bNarrowStile) or bSmallShiftedDoor) and nProbeMode ~= 1 then for i = 1, #tLocMach do if tLocMach[i].On ~= 0 then sLocMachId = tLocMach[i].MachId if not sLocMachId then sLocMachId = 1 end if sLocMachId == nNumMachFromTable then -- Recupero le entità local EntList = MB.FindEntitiesWithName( Pz, tLocMach[i].Name) -- Applico le lavorazioni for j = 1, #EntList do -- OPERAZIONI if tLocMach[i].Oper and tLocMach[i].Oper == 'AdjustBevel' then MB.AdjustBevel( EntList[j], tLocMach[i].Name, bFirstStep, bNoVertProf) end end end end end end -- conteggio lavorazioni saltate nNumMachSkipResult = 0 if v == 1 then -- solo il primo pezzo -- variabile per conteggio lavorazioni nNumMach = 0 nNumSkip = 0 end -- se porta ribatata inverto anche le variabili contatori lavorazioni sopra e sotto if bFlip then local nValAppo = nNumGeomBottom nNumGeomBottom = nNumGeomTop nNumGeomTop = nValAppo end -- local bEnBreak = false bEnBreak = false -- Machining adding, only for selected machine -- faccio tutto in un unico giro per non dover avere due contatori di break, uno per le operazioni e uno per le lavorazioni for i = nIndexStartMach, #tLocMach do -- se devo uscire dal ciclo if bEnBreak then break end if tLocMach[i].On ~= 0 then sLocMachId = tLocMach[i].MachId if not sLocMachId then sLocMachId = 1 end if sLocMachId == nNumMachFromTable then -- Recupero le entità local sHide = EgtIf( bFirstStep, '', DGD.GHT) local EntList = MB.FindEntitiesWithName( Pz, tLocMach[i].Name..sHide) -- -- solo per il ProbeSidePoint non cerco il percorso _HIDE in seconda fase -- if tLocMach[i].Name == 'ProbeSidePoint' then -- EntList = MB.FindEntitiesWithName( Pz, tLocMach[i].Name) -- else -- EntList = MB.FindEntitiesWithName( Pz, tLocMach[i].Name..sHide) -- end -- Applico le lavorazioni for j = 1, #EntList do local nNewIdEnt local nLocMach -- OPERAZIONI if tLocMach[i].Oper then if tLocMach[i].Oper == 'AdjustBevel' and nProbeMode ~= 1 then bLocMach, _, nNewIdEnt = MB.AdjustBevel( EntList[j], tLocMach[i].Name, bFirstStep, bNoVertProf, bMakeGhost) if bLocMach then local bInsLav = false -- faccio il test per vedere se la lavorazione è applicabile local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 nLocMach = nMach if nMach == 1 then bInsLav = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt) if not bInsLav then nNumMachSkipResult = nNumMachSkip + 1 EgtSetInfo( nNewIdEnt, 'Mach', 12) end elseif nMach == 2 then bInsLav = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt) if not bInsLav then nNumMachSkipResult = nNumMachSkip + 1 EgtSetInfo( nNewIdEnt, 'Mach', 11) end elseif nMach == 3 then bInsLav = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt) if not bInsLav then nNumMachSkipResult = nNumMachSkip + 1 EgtSetInfo( nNewIdEnt, 'Mach', 13) end end -- se la lavorazione è applicabile e non scatena lo shift -- if bInsLav and ( bShiftMchng or not tLocMach[i].Shift or tLocMach[i].Shift == 0) then -- se la lavorazione è applicabile if bInsLav then -- ottengo il nome del lato lavorato local sEdge = EgtGetName( EgtGetParent( EntList[j])) if sEdge then if #tsMachProf[v] > 0 then tsMachProf[v] = tsMachProf[v] .. ',' .. sEdge else tsMachProf[v] = sEdge end end -- in base a quale lato è verifico se il sovramateriale supera il valore massimo e genero sgrossatura if string.lower( sEdge) == 'left' then local dOffsLoc = 0 if tsBoolData.bAtRight then if tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BU' or tsStringData.sHingeTrim == 'BDEB' or tsStringData.sHingeTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sHingeTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[1] local dMaxInsPrf = sqrt((tsRadiusProf[1]*tsRadiusProf[1])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[1] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end elseif not tsBoolData.bAtRight then if tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BU' or tsStringData.sLockTrim == 'BDEB' or tsStringData.sLockTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sLockTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[2] local dMaxInsPrf = sqrt((tsRadiusProf[2]*tsRadiusProf[2])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[2] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end end MB.MakeRoughPaths( tsDoubleData.dLeftOffs, tMainTabPar.MOM, tMainTabPar.SOM, nNewIdEnt, false, bFlip, nil, dOffsLoc, tMainTabPar.RSM) elseif string.lower( sEdge) == 'right' then local dOffsLoc = 0 if tsBoolData.bAtRight then if tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BU' or tsStringData.sLockTrim == 'BDEB' or tsStringData.sLockTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sLockTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[2] local dMaxInsPrf = sqrt((tsRadiusProf[2]*tsRadiusProf[2])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[2] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end elseif not tsBoolData.bAtRight then if tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BU' or tsStringData.sHingeTrim == 'BDEB' or tsStringData.sHingeTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sHingeTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[1] local dMaxInsPrf = sqrt((tsRadiusProf[1]*tsRadiusProf[1])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[1] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end end MB.MakeRoughPaths( tsDoubleData.dRightOffs, tMainTabPar.MOM, tMainTabPar.SOM, nNewIdEnt, false, bFlip, nil, dOffsLoc, tMainTabPar.RSM) elseif string.lower( sEdge) == 'top' then local dOffsLoc = 0 if tsStringData.sTopTrim == 'BD' or tsStringData.sTopTrim == 'BU' or tsStringData.sTopTrim == 'BDEB' or tsStringData.sTopTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sTopTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[3] local dMaxInsPrf = sqrt((tsRadiusProf[3]*tsRadiusProf[3])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[3] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end MB.MakeRoughPaths( tsDoubleData.dTopOffs, tMainTabPar.MOM, tMainTabPar.SOM, nNewIdEnt, true, bFlip, nil, dOffsLoc, tMainTabPar.RSM) elseif string.lower( sEdge) == 'bottom' then local dOffsLoc = 0 if tsStringData.sBottomTrim == 'BD' or tsStringData.sBottomTrim == 'BU' or tsStringData.sBottomTrim == 'BDEB' or tsStringData.sBottomTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 end MB.MakeRoughPaths( tsDoubleData.dBottomOffs, tMainTabPar.MOM, tMainTabPar.SOM, nNewIdEnt, true, bFlip, nil, dOffsLoc, tMainTabPar.RSM) end elseif not bInsLav or (nNumMachSkipResult > nNumMachSkip) then -- se lavorazione skippata la inserisco nella tabella if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) else bOk = false end nNumMachSkip = nNumMachSkipResult end else bOk = false end elseif tLocMach[i].Oper == 'AdjustVertCurve' and nProbeMode ~= 1 then bOk, nNewIdEnt = MB.AdjustVertCurve( EntList[j], bMakeGhost) elseif tLocMach[i].Oper == 'AdjustRoughCurve' and nProbeMode ~= 1 then bOk, nNewIdEnt = MB.AdjustThrouCurve( EntList[j], bMakeGhost, true) elseif tLocMach[i].Oper == 'AdjResizeCurve' and nProbeMode ~= 1 then if bSteelDoor or bAlumDoor then bLocMach, nNewIdEnt = MB.AdjPrfThrouCurveNew( EntList[j], bMakeGhost, true, bNoVertProf) else bLocMach, nNewIdEnt = MB.AdjPrfThrouCurveNew( EntList[j], bMakeGhost, false, bNoVertProf) end if bLocMach then local bInsLav = false -- faccio un test per vedere che la lavorazione è applicabile local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 nLocMach = nMach if nMach == 1 then bInsLav = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt) elseif nMach == 2 then bInsLav = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt) elseif nMach == 3 then -- il metodo non dovrebbe assegnare il valore 3 bInsLav = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt) nNumMachSkipResult = nNumMachSkip + 1 end -- se la lavorazione è applicabile if bInsLav then -- ottengo il nome del lato lavorato local sEdge = EgtGetName( EgtGetParent( EntList[j])) if sEdge then if #tsMachProf[v] > 0 then tsMachProf[v] = tsMachProf[v] .. ',' .. sEdge else tsMachProf[v] = sEdge end end -- in base a quale lato è verifico se non è contro il riferimento e se devo compensare l'offset del bevel if string.lower( sEdge) == 'left' then local dOffsLoc = 0 -- se lato sinistro è contro i riferimenti disabilito la lavorazione if ( tsBoolData.bAtRight and bHingeOnRef) or ( not tsBoolData.bAtRight and not bHingeOnRef) then EgtSetInfo( nNewIdEnt, 'Mach', 42) else if tsBoolData.bAtRight and ( tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BDEB') then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif not tsBoolData.bAtRight and ( tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BDEB') then dOffsLoc = tsDoubleData.dThickDoor * TAN3 end EgtSetInfo( nNewIdEnt, 'OL', dOffsLoc) end elseif string.lower( sEdge) == 'right' then local dOffsLoc = 0 -- se lato destro è contro i riferimenti disabilito la lavorazione if ( tsBoolData.bAtRight and not bHingeOnRef) or ( not tsBoolData.bAtRight and bHingeOnRef) then EgtSetInfo( nNewIdEnt, 'Mach', 42) else if tsBoolData.bAtRight and ( tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BDEB') then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif not tsBoolData.bAtRight and ( tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BDEB') then dOffsLoc = tsDoubleData.dThickDoor * TAN3 end EgtSetInfo( nNewIdEnt, 'OL', dOffsLoc) end elseif string.lower( sEdge) == 'top' then local dOffsLoc = 0 -- se lato top è contro i riferimenti disabilito la lavorazione if bTopOnRef then EgtSetInfo( nNewIdEnt, 'Mach', 42) else if tsStringData.sTopTrim == 'BD' or tsStringData.sTopTrim == 'BU' or tsStringData.sTopTrim == 'BDEB' or tsStringData.sTopTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 end EgtSetInfo( nNewIdEnt, 'OL', dOffsLoc) end elseif string.lower( sEdge) == 'bottom' then local dOffsLoc = 0 -- se lato bottom è contro i riferimenti disabilito la lavorazione if not bTopOnRef then EgtSetInfo( nNewIdEnt, 'Mach', 42) else if tsStringData.sBottomTrim == 'BD' or tsStringData.sBottomTrim == 'BU' or tsStringData.sBottomTrim == 'BDEB' or tsStringData.sBottomTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 end EgtSetInfo( nNewIdEnt, 'OL', dOffsLoc) end end end if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) end nNumMachSkip = nNumMachSkipResult end else bOk = false end elseif tLocMach[i].Oper == 'AdjustThrouCurve' or tLocMach[i].Oper == 'AdjPrfThrouCurve' and nProbeMode ~= 1 then if tLocMach[i].Oper == 'AdjustThrouCurve' then bLocMach, nNewIdEnt = MB.AdjustThrouCurve( EntList[j], bMakeGhost) else -- altrimenti if bSkinned or bSteelDoor or bAlumDoor then bLocMach, nNewIdEnt = MB.AdjPrfThrouCurveNew( EntList[j], bMakeGhost, true, bNoVertProf) else bLocMach, nNewIdEnt = MB.AdjPrfThrouCurveNew( EntList[j], bMakeGhost, false, bNoVertProf) end end if bLocMach then local bInsLav = false -- faccio un test per vedere che la lavorazione è applicabile local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 nLocMach = nMach if nMach == 1 then bInsLav = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt) elseif nMach == 2 then bInsLav = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt) elseif nMach == 3 then -- il metodo non dovrebbe assegnare il valore 3 bInsLav = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt) nNumMachSkipResult = nNumMachSkip + 1 end -- se la lavorazione è applicabile e non scatena lo shift -- if bInsLav and ( bShiftMchng or not tLocMach[i].Shift or tLocMach[i].Shift == 0) then -- se la lavorazione è applicabile if bInsLav then -- ottengo il nome del lato lavorato local sEdge = EgtGetName( EgtGetParent( EntList[j])) if sEdge then if #tsMachProf[v] > 0 then tsMachProf[v] = tsMachProf[v] .. ',' .. sEdge else tsMachProf[v] = sEdge end end -- in base a quale lato è verifico se il sovramateriale supera il valore massimo e genero sgrossatura if string.lower( sEdge) == 'left' then local dOffsLoc = 0 if tsBoolData.bAtRight then if tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BU' or tsStringData.sHingeTrim == 'BDEB' or tsStringData.sHingeTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sHingeTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[1] local dMaxInsPrf = sqrt((tsRadiusProf[1]*tsRadiusProf[1])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[1] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end elseif not tsBoolData.bAtRight then if tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BU' or tsStringData.sLockTrim == 'BDEB' or tsStringData.sLockTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sLockTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[2] local dMaxInsPrf = sqrt((tsRadiusProf[2]*tsRadiusProf[2])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[2] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end end MB.MakeRoughPaths( tsDoubleData.dLeftOffs, tMainTabPar.MOM, tMainTabPar.SOM, nNewIdEnt, false, bFlip, nil, dOffsLoc, tMainTabPar.RSM) elseif string.lower( sEdge) == 'right' then local dOffsLoc = 0 if tsBoolData.bAtRight then if tsStringData.sLockTrim == 'BD' or tsStringData.sLockTrim == 'BU' or tsStringData.sLockTrim == 'BDEB' or tsStringData.sLockTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sLockTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[2] local dMaxInsPrf = sqrt((tsRadiusProf[2]*tsRadiusProf[2])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[2] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end elseif not tsBoolData.bAtRight then if tsStringData.sHingeTrim == 'BD' or tsStringData.sHingeTrim == 'BU' or tsStringData.sHingeTrim == 'BDEB' or tsStringData.sHingeTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sHingeTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[1] local dMaxInsPrf = sqrt((tsRadiusProf[1]*tsRadiusProf[1])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[1] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end end MB.MakeRoughPaths( tsDoubleData.dRightOffs, tMainTabPar.MOM, tMainTabPar.SOM, nNewIdEnt, false, bFlip, nil, dOffsLoc, tMainTabPar.RSM) elseif string.lower( sEdge) == 'top' then local dOffsLoc = 0 if tsStringData.sTopTrim == 'BD' or tsStringData.sTopTrim == 'BU' or tsStringData.sTopTrim == 'BDEB' or tsStringData.sTopTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 elseif tsStringData.sTopTrim == 'CV' then -- calcolo minimo ingombro profilo local dAltProf = tsDoubleData.dThickDoor/2 - tsPlaneProf[3] local dMaxInsPrf = sqrt((tsRadiusProf[3]*tsRadiusProf[3])-(dAltProf*dAltProf)) dOffsLoc = tsRadiusProf[3] - dMaxInsPrf -- assegno al nuovo percorso il delta tra il fondo profilo e il bordo porta EgtSetInfo( nNewIdEnt, 'OFFSTOPATH', dOffsLoc) end MB.MakeRoughPaths( tsDoubleData.dTopOffs, tMainTabPar.MOM, tMainTabPar.SOM, nNewIdEnt, true, bFlip, nil, dOffsLoc, tMainTabPar.RSM) elseif string.lower( sEdge) == 'bottom' then local dOffsLoc = 0 if tsStringData.sBottomTrim == 'BD' or tsStringData.sBottomTrim == 'BU' or tsStringData.sBottomTrim == 'BDEB' or tsStringData.sBottomTrim == 'BUEB' then dOffsLoc = tsDoubleData.dThickDoor * TAN3 end MB.MakeRoughPaths( tsDoubleData.dBottomOffs, tMainTabPar.MOM, tMainTabPar.SOM, nNewIdEnt, true, bFlip, nil, dOffsLoc, tMainTabPar.RSM) end end if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) end nNumMachSkip = nNumMachSkipResult end else bOk = false end elseif tLocMach[i].Oper == 'AdjustThrouIsle' and nProbeMode ~= 1 then bLocMach, nNumMachSkipResult, nNewIdEnt = MB.AdjustThrouIsle( EntList[j], b3Solid:getDimZ(), pMin, pMax, nNumMachSkip, bFirstStep, bWorkUnder, bMakeGhost, tMainTabPar.ETM) if not bLocMach then -- se operazione fallita bOk = false end if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 if nMach == 11 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 1 ,tLocMach[i].Mach}) elseif nMach == 12 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) elseif nMach == 13 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 3 ,tLocMach[i].MachDw}) end end nNumMachSkip = nNumMachSkipResult else -- se non skippata provo a verificare se la lavorazione è applicabile if bOk then local bInsLav = true local bMachBox -- faccio un test per vedere che la lavorazione è applicabile local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 nLocMach = nMach if nMach == 1 then bInsLav, _, bMachBox = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt, bUseVise) elseif nMach == 2 then bInsLav, _, bMachBox = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt, true) elseif nMach == 3 then -- il metodo AdjustThrouIsle non dovrebbe restituire il 3 bInsLav, _, bMachBox = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt, bUseVise) end -- se la lavorazione è applicabile ma è da sotto, verifico l'ingombro della lavorazione if bInsLav and nMach == 2 and bMachBox and not bMachBox:isEmpty() and tMainTabPar.CUC == 1 then bInsLav = VerifyRowCollision( tRefArea, bMachBox) end -- se utilizza lavorazione da sotto con le morse disabilito la lavorazione if nMach == 2 and bUseVise then bInsLav = false end -- verifico le collisioni con le morse if bInsLav and bUseVise and bMachBox and not bMachBox:isEmpty() then tsNoteRow[1] = VerifyViseCollision( tIdViseDisp, bMachBox, Pz, nNumPhase, DISPMODE, tMainTabPar.NTVR, tsNoteRow[1], 2) end -- se la lavorazione non è applicabile if not bInsLav then if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) if nMach == 1 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 1 ,tLocMach[i].Mach}) elseif nMach == 3 then EgtSetInfo( nNewIdEnt, 'JoinMach', { nMach ,tLocMach[i].MachDw}) end end -- aumento di 1 il numero di lavorazioni skippate nNumMachSkip = nNumMachSkip + 1 -- ricambio la nota come non lavorabile in questa fase if nMach == 1 then EgtSetInfo( nNewIdEnt, 'Mach', 12) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'Mach', 11) else EgtSetInfo( nNewIdEnt, 'Mach', nMach + 10) end -- incremento il numero di lavorazioni da sotto nNumGeomBottom = nNumGeomBottom + 1 end else EgtSetInfo( nNewIdEnt, 'Mach', 31) end end elseif tLocMach[i].Oper == 'AdjustProbeMill' and nProbeMode == 0 and nPostProbeSet > 2 then local sMachRetured bLocMach, nNumMachSkipResult, nNewIdEnt = MB.AdjustProbeMill( EntList[j], b3Solid:getDimZ(), pMin, pMax, nNumMachSkip, bFirstStep, NO_WORK_UNDERSQUARE, bMakeGhost, NO_WORK_UPSQUARE, tMainTabPar.PTK, tMainTabPar.EZPB) if not bLocMach then -- se operazione fallita bOk = false end if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 if nMach == 11 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 1 ,tLocMach[i].Mach}) elseif nMach == 12 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) elseif nMach == 13 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 3 ,tLocMach[i].MachDw}) end end nNumMachSkip = nNumMachSkipResult else -- se non skippata provo a verificare se la lavorazione è applicabile if bOk then local bInsLav = false -- faccio un test per vedere che la lavorazione è applicabile local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 nLocMach = nMach if nMach == 1 then bInsLav, sMachRetured = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt) elseif nMach == 2 then bInsLav, sMachRetured = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt, true) elseif nMach == 3 then bInsLav, sMachRetured = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt) end if not bInsLav then if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) if nMach == 1 then EgtSetInfo( nNewIdEnt, 'JoinMach', { nMach ,tLocMach[i].Mach}) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 3 ,tLocMach[i].MachDw}) elseif nMach == 3 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) end end -- se c'è nome lavorazione aumento di 1 il numero di lavorazioni skippate if sMachRetured then nNumMachSkip = nNumMachSkip + 1 end -- ricambio la nota come non lavorabile in questa fase if nMach == 1 then EgtSetInfo( nNewIdEnt, 'Mach', 11) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'Mach', 13) elseif nMach == 3 then EgtSetInfo( nNewIdEnt, 'Mach', 12) end -- se lavorazione presente incremento il numero di lavorazioni da sotto if sMachRetured then nNumGeomBottom = nNumGeomBottom + 1 end else -- se è andata a buon punto setto nota alla porta EgtSetInfo( Pz, 'ExistsProbeXY', true) -- presenza del probe in XY end else EgtSetInfo( nNewIdEnt, 'Mach', 31) end end elseif tLocMach[i].Oper == 'AdjustHorizDrillX' and nProbeMode ~= 1 then bLocMach, nNewIdEnt = MB.AdjustHorizDrillX( EntList[j], bMakeGhost, true, nProbeMode) if not bLocMach then bOk = false end elseif tLocMach[i].Oper == 'AdjustHorizDrillY' and nProbeMode ~= 1 then bLocMach, nNewIdEnt = MB.AdjustHorizDrillY( EntList[j], bMakeGhost, true, nProbeMode) if not bLocMach then bOk = false end elseif tLocMach[i].Oper == 'AdjustHorizAS' and nProbeMode ~= 1 then bLocMach, nNewIdEnt = MB.AdjustHorizAS( EntList[j], bMakeGhost) if not bLocMach then bOk = false end elseif tLocMach[i].Oper == 'AdjustHorNegativeAS' and nProbeMode ~= 1 then bLocMach, nNewIdEnt = MB.AdjustHorNegativeAS( EntList[j], bMakeGhost) if not bLocMach then bOk = false end elseif tLocMach[i].Oper == 'AdjustMortise' and nProbeMode ~= 1 then bLocMach, nNumMachSkipResult, nNewIdEnt = MB.AdjustMortise( EntList[j], nNumMachSkip, NO_WORK_UNDERSQUARE, bMakeGhost, NO_WORK_UPSQUARE, bForceHorizontalDir) if not bLocMach then -- se operazione fallita bOk = false end if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 if nMach == 11 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 1 ,tLocMach[i].Mach}) elseif nMach == 12 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) elseif nMach == 13 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 3 ,tLocMach[i].MachDw}) end end nNumMachSkip = nNumMachSkipResult else -- se non skippata provo a verificare se la lavorazione è applicabile if bOk then local bInsLav = false -- faccio un test per vedere che la lavorazione è applicabile local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 nLocMach = nMach if nMach == 1 then bInsLav, sMachRetured = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt) elseif nMach == 2 then bInsLav, sMachRetured = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt) elseif nMach == 3 then bInsLav, sMachRetured = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt) end if not bInsLav then if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) if nMach == 1 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 1 ,tLocMach[i].Mach}) elseif nMach == 3 then EgtSetInfo( nNewIdEnt, 'JoinMach', { nMach ,tLocMach[i].MachDw}) end end -- se c'è nome lavorazione aumento di 1 il numero di lavorazioni skippate if sMachRetured then nNumMachSkip = nNumMachSkip + 1 end -- ricambio la nota come non lavorabile in questa fase if nMach == 1 then EgtSetInfo( nNewIdEnt, 'Mach', 12) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'Mach', 11) else EgtSetInfo( nNewIdEnt, 'Mach', nMach + 10) end -- se lavorazione presente incremento il numero di lavorazioni da sotto if sMachRetured then nNumGeomBottom = nNumGeomBottom + 1 end end else EgtSetInfo( nNewIdEnt, 'Mach', 31) end end elseif tLocMach[i].Oper == 'AdjustVertHole' and nProbeMode ~= 1 then local nTypeGeom bLocMach, nNumMachSkipResult, nNewIdEnt, nTypeGeom = MB.AdjustVertHole( EntList[j], b3Solid:getDimZ(), pMin, pMax, nNumMachSkip, bFirstStep, bWorkUnder, bMakeGhost, tMainTabPar.ETM) if not bLocMach then bOk = false end if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 if nMach == 11 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 1 ,tLocMach[i].Mach}) elseif nMach == 12 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) elseif nMach == 13 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 3 ,tLocMach[i].MachDw}) end end nNumMachSkip = nNumMachSkipResult else -- se non skippata provo a verificare se la lavorazione è applicabile local bInsLav = true local bInsLavSec = true local bMachBox -- faccio un test per vedere che la lavorazione è applicabile local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 nLocMach = nMach if nMach == 1 then bInsLav, _, bMachBox = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt, bUseVise) -- se lavorazione non è applicabile ma di tipo passante e con la possibilità di lavorazione da sotto -- provo subito la seconda opzione if not bInsLav and ( nTypeGeom == 1 or nTypeGeom == 2) and bWorkUnder then bInsLavSec, _, bMachBox = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt, true) if bInsLavSec and bMachBox and not bMachBox:isEmpty() and tMainTabPar.CUC == 1 then bInsLavSec = VerifyRowCollision( tRefArea, bMachBox) end if bInsLavSec then nMach = 2 nLocMach = nMach EgtSetInfo( nNewIdEnt, 'Mach', 2) end end elseif nMach == 2 then bInsLav, _, bMachBox = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt, true) elseif nMach == 3 then -- il metodo AdjustVertHole non dovrebbe restituire il 3 bInsLav, _, bMachBox = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt, bUseVise) end -- se la lavorazione è applicabile ma è da sotto, verifico l'ingombro della lavorazione if bInsLav and nMach == 2 and bMachBox and not bMachBox:isEmpty() and tMainTabPar.CUC == 1 then bInsLav = VerifyRowCollision( tRefArea, bMachBox) end -- se utilizza lavorazione da sotto con le morse disabilito la lavorazione if nMach == 2 and bUseVise then bInsLav = false end -- verifico le collisioni con le morse if bInsLav and bUseVise and bMachBox and not bMachBox:isEmpty() then tsNoteRow[1] = VerifyViseCollision( tIdViseDisp, bMachBox, Pz, nNumPhase, DISPMODE, tMainTabPar.NTVR, tsNoteRow[1], 2) end -- se la lavorazione non è applicabile da entrambe i lati if not bInsLav and not bInsLavSec then -- setto la nota per non lavorare la geometria da nessuna parte EgtSetInfo( nNewIdEnt, 'Mach', 21) EgtSetInfo( nNewIdEnt, 'Mach2nd', 1) nLocMach = 21 -- se la lavorazione non è applicabile da un lato elseif not bInsLav then if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) if nMach == 1 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 1 ,tLocMach[i].Mach}) elseif nMach == 3 then EgtSetInfo( nNewIdEnt, 'JoinMach', { nMach ,tLocMach[i].MachDw}) end end -- aumento di 1 il numero di lavorazioni skippate nNumMachSkip = nNumMachSkip + 1 -- ricambio la nota come non lavorabile in questa fase if nMach == 1 then EgtSetInfo( nNewIdEnt, 'Mach', 12) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'Mach', 11) else EgtSetInfo( nNewIdEnt, 'Mach', nMach + 10) end -- incremento il numero di lavorazioni da sotto nNumGeomBottom = nNumGeomBottom + 1 end end elseif tLocMach[i].Oper == 'AdjustHole' and nProbeMode ~= 1 then bLocMach, nNewIdEnt = MB.AdjustHole( EntList[j], bMakeGhost, bForceHorizontalDir) if not bLocMach then bOk = false end elseif tLocMach[i].Oper == 'AdjPreHoleAndPocket' and nProbeMode ~= 1 then bLocMach, nNewIdEnt = MB.AdjPreHoleAndPocket( EntList[j], bMakeGhost, nil, nil, (bExtruded or bSkinned)) if not bLocMach then bOk = false end elseif tLocMach[i].Oper == 'AdjustProbeHole' and nProbeMode == 1 then local sMachRetured bLocMach, nNumMachSkipResult, nNewIdEnt = MB.AdjustProbeHole( EntList[j], b3Solid:getDimZ(), pMin, pMax, nNumMachSkip, bFirstStep, false, bMakeGhost) if not bLocMach then bOk = false end if nNumMachSkipResult > nNumMachSkip then -- se lavorazione skippata la inserisco nella tabella if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 if nMach == 11 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 1 ,tLocMach[i].Mach}) elseif nMach == 12 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) elseif nMach == 13 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 3 ,tLocMach[i].MachDw}) end end nNumMachSkip = nNumMachSkipResult else -- se non skippata provo a verificare se la lavorazione è applicabile local bInsLav = true -- faccio un test per vedere che la lavorazione è applicabile local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 nLocMach = nMach if nMach == 1 then bInsLav, sMachRetured = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt) elseif nMach == 2 then bInsLav, sMachRetured = MB.TestMachining( tLocMach[i].MachUp, nNewIdEnt) elseif nMach == 3 then -- il metodo AdjustProbeHole non dovrebbe restituire il 3 bInsLav, sMachRetured = MB.TestMachining( tLocMach[i].MachDw, nNewIdEnt) end -- se la lavorazione è applicabile setto la nota sul pezzo if bInsLav then EgtSetInfo( Pz, 'ExistsProbeZ', true) -- presenza del probe in Z else -- altrimenti la lavorazione non è applicabile if bFirstStep then -- inserisco in tabella solo se non già presente tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) if nMach == 1 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 2 ,tLocMach[i].MachUp}) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'JoinMach', { 1 ,tLocMach[i].Mach}) elseif nMach == 3 then EgtSetInfo( nNewIdEnt, 'JoinMach', { nMach ,tLocMach[i].MachDw}) end end -- se c'è nome lavorazione aumento di 1 il numero di lavorazioni skippate if sMachRetured then nNumMachSkip = nNumMachSkip + 1 end -- ricambio la nota come non lavorabile in questa fase if nMach == 1 then EgtSetInfo( nNewIdEnt, 'Mach', 12) elseif nMach == 2 then EgtSetInfo( nNewIdEnt, 'Mach', 11) else EgtSetInfo( nNewIdEnt, 'Mach', nMach + 10) end -- se lavorazione presente incremento il numero di lavorazioni da sotto if sMachRetured then nNumGeomBottom = nNumGeomBottom + 1 end end end elseif tLocMach[i].Oper == 'AdjustBladeVertCurve' and nProbeMode ~= 1 then bOk, nNewIdEnt = MB.AdjustBladeVertCurve( EntList[j], bMakeGhost) elseif tLocMach[i].Oper == 'AdjustSplitDoor' and nProbeMode ~= 1 then if not bGetSplitCuts then tSplitDoorEnt = EntList table.insert( tSplitDataInf, { tLocMach[i].Name, nNumGroup, tLocMach[i].Mach, tLocMach[i].MachUp, tLocMach[i].MachDw, nNumMach, bMakeGhost}) bGetSplitCuts = true end elseif tLocMach[i].Oper == 'AdjustConeCleanPaths' and nProbeMode ~= 1 then bOk, nNewIdEnt = MB.AdjustConeCleanPaths( EntList[j], bMakeGhost) elseif tLocMach[i].Oper == 'AdjustVertAsOnHeads' and nProbeMode ~= 1 then bLocMach, nNewIdEnt = MB.AdjustVertAsOnHeads( EntList[j], bMakeGhost) if not bLocMach then bOk = false end end else -- se nessuna operazione if nProbeMode ~= 1 then nNewIdEnt = MB.MakeGhostCopy( EntList[j]) if bUseVise then local bInsLav, _, bMachBox = MB.TestMachining( tLocMach[i].Mach, nNewIdEnt, bUseVise) -- verifico le collisioni con le morse if bInsLav and bMachBox and not bMachBox:isEmpty() then tsNoteRow[1] = VerifyViseCollision( tIdViseDisp, bMachBox, Pz, nNumPhase, DISPMODE, tMainTabPar.NTVR, tsNoteRow[1], 2) end -- se la lavorazione non è applicabile -- if not bInsLav then -- if bFirstStep then -- -- inserisco in tabella solo se non già presente -- tSecMachTab = AddMachIntable( tLocMach[i], tSecMachTab, i) -- end -- -- aumento di 1 il numero di lavorazioni skippate -- nNumMachSkip = nNumMachSkip + 1 -- -- ricambio la nota come non lavorabile in questa fase -- if nMach == 1 then -- EgtSetInfo( nNewIdEnt, 'Mach', 12) -- elseif nMach == 2 then -- EgtSetInfo( nNewIdEnt, 'Mach', 11) -- else -- EgtSetInfo( nNewIdEnt, 'Mach', nMach + 10) -- end -- -- incremento il numero di lavorazioni da sotto -- nNumGeomBottom = nNumGeomBottom + 1 -- end end end end -- LAVORAZIONI local nMach if nNewIdEnt then nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 else nMach = 0 end local bScroll = true if nMach > 30 and nMach < 40 then nMach = nMach - 30 end -- se prima lavorazione, valida, con chiave Shift abilitata, esco dal giro --[[ if ( nMach > 0 and nMach < 10) and not bShiftMchng and tLocMach[i].Shift == 1 then bShiftMchng = true -- flag per traslazione Y nIndexStartMach = i -- ripartenza da questa posizione bScroll = false -- salto l'applicazione delle lavorazioni in seguito bEnBreak = true -- blocco il for della scansione tabella -- se fase di ripresa rimetto la nota mach disabilitata if not bFirstStep then nMach = nMach + 10 EgtSetInfo( EntList[j], 'Mach', nMach) nNumMachSkip = nNumMachSkip + 1 end end --]] if not bScroll then break -- esco dal ciclo for j else if nMach > 0 and nMach < 4 then -- se è fuori range non ci entro nemmeno -- carico id entità in una tabella local tListSameMach = {} table.insert( tListSameMach, nNewIdEnt) local bCalMach = true -- se non primo passo e nota JoinMach differisce dal mach e dalla lavorazione if not bFirstStep then local sJoinMach = EgtGetInfo( nNewIdEnt, 'JoinMach') if sJoinMach and #sJoinMach > 1 then local tJoinMach = EgtSplitString( sJoinMach) if tJoinMach and #tJoinMach == 2 then local nNumMachRef = tonumber( tJoinMach[1]) local sMachRefJoin = tJoinMach[2] if nNumMachRef ~= nMach then bCalMach = false elseif nNumMachRef == 1 and sMachRefJoin and tLocMach[i].Mach and tLocMach[i].Mach ~= sMachRefJoin then bCalMach = false elseif nNumMachRef == 2 and sMachRefJoin and tLocMach[i].MachUp and tLocMach[i].MachUp ~= sMachRefJoin then bCalMach = false elseif nNumMachRef == 3 and sMachRefJoin and tLocMach[i].MachDw and tLocMach[i].MachDw ~= sMachRefJoin then bCalMach = false end end end end bOk, nNumMach = InsertMachiningByMachNum( tListSameMach, nMach, tLocMach[i].Name, nNumGroup, tLocMach[i].Mach, tLocMach[i].MachUp, tLocMach[i].MachDw, bOk, nNumMach, false, NOT_GEN_MACH, nil, tMainTabPar.BPLI, tMainTabPar.PRF, bCalMach) elseif nNewIdEnt then local sLocMachName if not nLocMach or nLocMach == 1 then sLocMachName = tLocMach[i].Mach elseif nLocMach == 2 then sLocMachName = tLocMach[i].MachUp elseif nLocMach == 3 then sLocMachName = tLocMach[i].MachDw elseif nLocMach == 21 then -- caso particolare quando falliscono sia la lavorazione top che bottom if tLocMach[i].Mach then -- se non è nil sLocMachName = tLocMach[i].Mach else sLocMachName = 'no machining' end if tLocMach[i].MachUp then -- se non è nil sLocMachName = sLocMachName .. ' + ' .. tLocMach[i].MachUp else sLocMachName = sLocMachName .. ' + ' .. 'no machining' end end DoorOutLog( EgtDoorsMsg[497]..EgtNumToString( nNewIdEnt, 0)..' '.. EgtDoorsMsg[638] ..tLocMach[i].Name.. EgtDoorsMsg[595].. EgtIf( sLocMachName, sLocMachName, '') .. EgtDoorsMsg[596]..EgtNumToString( nNumPhase, 0), 0) nNumSkip = nNumSkip + 1 end end end end end end -- se utilizzo morse faccio l'ultimo controllo ed eventuale scrematura del numero delle morse if bUseVise and #tIdViseDisp > 3 then ReduceViseNumber( tIdViseDisp, 3, Pz, nNumPhase, DISPMODE, tMainTabPar.NTVR, tsNoteRow[1], 2) elseif bUseVise and #tIdViseDisp < 3 then local sMess = ' ' .. EgtDoorsMsg[683] if DGD.EMC and #DGD.EMC > 0 then -- se ho messaggio di errore lo mando una riga sotto per stamparlo correttamente DGD.EMC = '\n' .. sMess else DGD.EMC = sMess end bOk = false break end end -- end for per ogni pezzo local i = 1 while i <= #tLocMachOrd and not bEnBreak do -- carico tutto il gruppo in una tabella local tGroup = {} local nNumGrp = tLocMachOrd[i].Group local sProperty = tLocMachOrd[i].Property tGroup, i = MB.GetGroup( tLocMachOrd, i, nNumGrp, sProperty) if sProperty and nNumGrp > 0 then -- se esiste proprietà del gruppo e gruppo non 0 if sProperty == 'MinDist' or sProperty == 'MinDistByPiece' then -- ottimizzare alla minima distanza -- prendo l'ultima lavorazione inserita ( lavorazione o disposizione) local LastMch = EgtGetLastOperation() local EndLastMach -- se l'ultima lavorazione non sia nulla o non sia disposizione mi faccio dare il punto finale if EgtGetOperationType(LastMch) ~= MCH_OY.DISP and EgtGetOperationType(LastMch) ~= MCH_OY.NONE then EgtSetCurrMachining( LastMch) EndLastMach = EgtGetMachiningEndPoint() end local nPz local nTotPz if sProperty == 'MinDistByPiece' then nTotPz = #tPz else nTotPz = 1 end for v = 1, nTotPz do local nPz if sProperty == 'MinDistByPiece' then nPz = tPz[v] else nPz = tPz end local tMachining = {} -- creo lavorazioni del gruppo for k = 1, #tGroup do -- Recupero le entità local EntList = MB.FindEntitiesWithName( nPz, tGroup[k].Name..DGD.GHT) local bAdjustHead = false -- Applico le lavorazioni for j = 1, #EntList do -- LAVORAZIONI local nMach = EgtGetInfo( EntList[j], 'Mach', 'i') or 1 nMach = nMach - 30 -- se lavorazione corretta ottengo 1 local nMach2nd = EgtGetInfo( EntList[j], 'Mach2nd', 'i') or 0 local sMachining = EgtGetInfo( EntList[j], 'Machining') -- con questa tabella non ci sono seconde o terze lavorazioni, solo la prima if nMach > 0 and nMach < 4 then nMach = 1 end -- se è fuori range o non corrispondono le lavorazioni if sMachining and nMach == 1 and nMach2nd == 0 and sMachining == tGroup[k].Mach then -- cerco di unire più entità nella stessa lavorazione ( non da sotto e non oltre una certa distanza) local tListSameMach = MB.FindEntitiesCompMach( EntList[j], EntList, sMachining, tGroup[k].Join, tMainTabPar.MDC) -- se più di 1 entità le ordino if #tListSameMach > 1 then tListSameMach = MB.OrderEnt( tListSameMach, EndLastMach) EndLastMach = EgtSP( tListSameMach[#tListSameMach], GDB_ID.ROOT ) end bOk, nNumMach, tMachining = InsertMachiningByMachNum( tListSameMach, nMach, tGroup[k].Name, nNumGrp, tGroup[k].Mach, tGroup[k].MachUp, tGroup[k].MachDw, bOk, nNumMach, bAdjustHead, GEN_MACH, tMachining, tMainTabPar.BPLI, tMainTabPar.PRF) -- se ho assegnato lavorazione a più entità, marco quelle che ho già fatto SetInfoTable( tListSameMach, 'Mach2nd', 1) local nNewMach = EgtGetInfo( tListSameMach[1], 'Mach', 'i') or 1 if nNewMach > 30 and nNewMach < 40 then SetInfoTable( tListSameMach, 'Mach', nNewMach-20) -- assegno nota per non lavorarla di nuovo elseif nNewMach > 40 and nNewMach < 50 then SetInfoTable( tListSameMach, 'Mach', nNewMach-30) -- assegno nota per non lavorarla di nuovo end end end -- 11/01/2019 commento la cancellazione della nota per evitare di lavorare una seconda volta una geometria già lavorata -- tolgo di mezzo le note secondarie -- for j = 1, #EntList do -- EgtRemoveInfo( EntList[j], 'Mach2nd') -- end end -- ordino le lavorazioni if #tMachining > 1 then -- Tavole per fresature da ordinare local TabMill = {} local TabMStEnP = {} local TabZMach = {} for k = 1, #tMachining do -- Se appartiene alla fase corrente e fresatura non vuota if EgtGetOperationPhase( tMachining[k][1]) == nNumPhase then EgtSetCurrMachining( tMachining[k][1]) local ptStart = EgtGetMachiningStartPoint() local ptEnd = EgtGetMachiningEndPoint() if ptStart and ptEnd then table.insert( TabMill, tMachining[k][1]) table.insert( TabMStEnP, { ptStart, ptEnd}) MB.InsZedByTool( TabZMach, tMachining, k) end end end -- calcolo ordinamento EgtSpInit() for k = 1, #TabMill do EgtSpAddPoint( TabMStEnP[k][1]:getX(), TabMStEnP[k][1]:getY(), TabZMach[k], 0, 0, TabMStEnP[k][2]:getX(), TabMStEnP[k][2]:getY(), TabZMach[k], 0, 0) end if EndLastMach then EgtSpSetOpenBound(true,SHP_OB.NEAR_PNT,EndLastMach:getX(),EndLastMach:getY(),0,90,90) else EgtSpSetOpenBound(true,SHP_OB.NEAR_PNT,-2000,0,0,90,90) end local vMillOrd = EgtSpCalculate(SHP_TY.OPEN) EgtSpTerminate() -- applico ordinamento calcolato -- parto da LastMch precedente if vMillOrd then for k = 1, #vMillOrd do EgtRelocateGlob(TabMill[vMillOrd[k]],LastMch,GDB_IN.AFTER) LastMch = TabMill[vMillOrd[k]] end end end end -- end for elseif sProperty == 'Layer' then -- lavorazione layer for v = 1, #tPz do local nPz = tPz[v] -- ottengo tutte le entità del gruppo local EntListGrp = MB.LoadEntitiesFromGroup( tGroup, nPz, DGD.GHT) -- Applico le lavorazioni for j = 1, #EntListGrp do local nParendId = EgtGetParent(EntListGrp[j]) -- Recupero la prima entità del layer padre local EntList = MB.FindEntities( nParendId, true) -- LAVORAZIONI local nMach = 1 -- riciclo per prendere tutte le entità di un gruppo che devono essere lavorate assieme bOk, nNumMach = MakeGroupMachining( EntList, nParendId, tGroup, nMach, nNumGrp, nNumMach, bOk, DGD.GHT, tMainTabPar.MDC, EndLastMach, tMainTabPar.BPLI, tMainTabPar.PRF) end end -- end for elseif sProperty == '' then -- proprietà nulla -- creo lavorazioni del gruppo for k = 1, #tGroup do -- Recupero le entità local EntList = MB.FindEntitiesWithName( tPz, tGroup[k].Name..DGD.GHT) local bAdjustHead = false -- Applico le lavorazioni for j = 1, #EntList do -- LAVORAZIONI local nMach = EgtGetInfo( EntList[j], 'Mach', 'i') or 1 nMach = nMach - 30 -- se lavorazione corretta ottengo 1 local nMach2nd = EgtGetInfo( EntList[j], 'Mach2nd', 'i') or 0 local sMachining = EgtGetInfo( EntList[j], 'Machining') -- con questa tabella non ci sono seconde o terze lavorazioni, solo la prima if nMach > 0 and nMach < 4 then nMach = 1 end if sMachining and nMach == 1 and nMach2nd == 0 and sMachining == tGroup[k].Mach then -- cerco di unire più entità nella stessa lavorazione ( non da sotto e non oltre una certa distanza) local tListSameMach = MB.FindEntitiesCompMach( EntList[j], EntList, sMachining, tGroup[k].Join, tMainTabPar.MDC) -- se più di 1 entità le ordino if #tListSameMach > 1 then tListSameMach = MB.OrderEnt( tListSameMach, EndLastMach) EndLastMach = EgtSP( tListSameMach[#tListSameMach], GDB_ID.ROOT ) end bOk, nNumMach = InsertMachiningByMachNum( tListSameMach, nMach, tGroup[k].Name, nNumGrp, tGroup[k].Mach, tGroup[k].MachUp, tGroup[k].MachDw, bOk, nNumMach, bAdjustHead, GEN_MACH, nil, tMainTabPar.BPLI, tMainTabPar.PRF) -- se ho assegnato lavorazione a più entità, marco quelle che ho già fatto SetInfoTable( tListSameMach, 'Mach2nd', 1) local nNewMach = EgtGetInfo( tListSameMach[1], 'Mach', 'i') or 1 if nNewMach > 30 and nNewMach < 40 then SetInfoTable( tListSameMach, 'Mach', nNewMach-20) -- assegno nota per non lavorarla di nuovo elseif nNewMach > 40 and nNewMach < 50 then SetInfoTable( tListSameMach, 'Mach', nNewMach-30) -- assegno nota per non lavorarla di nuovo end end end -- 11/01/2019 commento la cancellazione della nota per evitare di lavorare una seconda volta una geometria già lavorata -- tolgo di mezzo le note secondarie -- for j = 1, #EntList do -- EgtRemoveInfo( EntList[j], 'Mach2nd') -- end end end elseif nNumGrp == 0 then -- se lavorazioni in gruppo 0 do errore DGD.ERR = -15 if DGD.EMC and #DGD.EMC > 0 then DGD.EMC = DGD.EMC .. ' ' .. string.format(EgtDoorsMsg[639], tGroup[1].Name) -- con gruppo 0 c'è solo un'istanza else DGD.EMC = '\n' .. ' ' .. string.format(EgtDoorsMsg[639], tGroup[1].Name) -- con gruppo 0 c'è solo un'istanza end if DGD.ERM and #DGD.ERM > 0 then DGD.ERM = DGD.ERM .. ' ' .. string.format(EgtDoorsMsg[639], tGroup[1].Name) -- con gruppo 0 c'è solo un'istanza else DGD.ERM = ' ' .. string.format(EgtDoorsMsg[639], tGroup[1].Name) -- con gruppo 0 c'è solo un'istanza end end i = i + 1 end -- se ci sono state lavorazioni accodo la disposizione delle fase if nNumMach > 0 then sTotDispMode = sTotDispMode .. ' ' .. sDispMode .. '\n' else -- altrimenti nessuna lavorazione if not bFirstStep then -- se non è il primo giro elimino la fase vuota -- se ho più di una fase elimino l'ultima fase if nNumPhase > 1 then EgtRemoveLastPhase() end -- setto corrente fase precedente if nPrevPhase then EgtSetCurrPhase(nPrevPhase) nNumPhase = nPrevPhase end end end -- se sono al primissimo giro if not bGenFirstStep then -- la lavorazione di traslazione ha priorità sul ribaltamento -- se trovata traslazione setto il flag per il prossimo giro if bShiftMchng then bGenFirstStep = true if not bFirstStep then -- se sono già in ripresa porta resetto il contatore di lavorazioni saltate nNumMachSkip = 0 -- resetto per il prossimo giro end else -- se nessuna geometria skippata esco if nNumMachSkip and nNumMachSkip == 0 then bWork = false end -- se lavorazioni skippate abilito il ribaltamento porta in altra fase if nNumMachSkip and nNumMachSkip > 0 then -- se già con pezzo non in prima fase ( non shiftato) o pezzo frame, esco if not bFirstStep or bFrame then bWork = false else bFirstStep = false end nNumMachSkip = 0 -- resetto per il prossimo giro end end else -- altrimenti ho già fatto un giro e ho trovato la traslazione -- se nessuna geometria skippata esco if nNumMachSkip == 0 then bWork = false end -- se lavorazioni skippate abilito il ribaltamento porta in altra fase if nNumMachSkip and nNumMachSkip > 0 then nNumMachSkip = 0 -- resetto per il prossimo giro if bFirstStep then -- se ho terminato il giro con eventuale traslazione disabilito la traslazione -- disativo la traslazione sul giro successvo bShiftMchng = false -- disattivo il flag che indica di disporre la porta subito traslata bSmallShiftedDoor = false end bFirstStep = false end end -- controllo di sicurezza if nNumCycle > 4 then bWork = false end nNumCycle = nNumCycle + 1 -- se deve uscire dal ciclo, prima di farlo, eseguo l'eventuale split della porta if not bWork then -- gestione taglio longitudinale split door -- per ogni pezzo passato for v = 1, #tPz do Pz = tPz[v] sAssemb = tsAssemb[v] -- assegnamento variabili bFrame = sAssemb and string.find( sAssemb, 'frame') == 1 -- se è una porta if not bFrame then local EntList = tSplitDoorEnt if #EntList == 1 then -- acquisisco nota direzione taglio e la confronto con il parametro del currcaminfo local sDirCut = EgtGetInfo( EntList[1], 'DirectionCut', 's') if sDirCut and ( ( sDirCut == 'H' and string.find( tMainTabPar.CDA, 'H')) or ( sDirCut == 'W' and string.find( tMainTabPar.CDA, 'W'))) then bLocMach, nNewIdEnt = MB.AdjustThrouCurve( EntList[1], tSplitDataInf[1][7]) if bLocMach then local bInsLav = false local nMach = EgtGetInfo( nNewIdEnt, 'Mach', 'i') or 1 nLocMach = nMach if nMach == 1 then -- carico id entità in una tabella local tListSameMach = {} table.insert( tListSameMach, nNewIdEnt) bOk, nNumMach = InsertMachiningByMachNum( tListSameMach, nMach, tSplitDataInf[1][1], tSplitDataInf[1][2], tSplitDataInf[1][3], tSplitDataInf[1][4], tSplitDataInf[1][5], bOk, tSplitDataInf[1][6], false, NGEN_MACH, nil, tMainTabPar.BPLI, tMainTabPar.PRF) end else bOk = false end end -- se ho più di un taglio do errore elseif #EntList > 1 then -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then if DGD.EMC and #DGD.EMC > 0 then EgtOutBox( DGD.EMC .. '\n' .. EgtDoorsMsg[695], EgtDoorsMsg[476], EgtDoorsMsg[477]) else EgtOutBox( EgtDoorsMsg[695], EgtDoorsMsg[476], EgtDoorsMsg[477]) end else -- scrivo messaggio nei file log DoorOutLog( EgtDoorsMsg[695], 0) end -- Salvo progetto EgtSaveFile() return false, nNumGroup end end end end end -- end while --nTime = EgtStopCounter() --if not DGD or not DGD.NCGEN then -- EgtOutBox( string.format( 'tempo calcolato sec: %s', (nTime/1000)), 'Time2', 'Time2') --end -- inizializzo il contatore --EgtStartCounter() -------------------------- -------------------------- -- *** Tools Setup *** -------------------------- -------------------------- -- provo a importare l'attrezzaggio di default, se fallisce passo gli altri bSetUp = EgtImportSetup() sListTool = '' if bSetUp then -- se importato quello di default sSetup = EgtGetDefaultSetupName() -- verifico se l'attrezzaggio è idoneo bSetUp, tListError = EgtVerifyCurrSetup() -- se attrezzaggio andato a buon fine setto il nome dell'attrezzaggio di default if bSetUp then -- assegno nota con il nome del file setup assegnato EgtSetInfo( EgtGetCurrSetup(), 'Name', sSetup) else -- preparo la lista degli utensili mancanti sListTool = string.format( EgtDoorsMsg[552], sSetup) .. ' (Default)' sListTool = sListTool .. '\n ' .. EgtDoorsMsg[553] for k = 1, #tListError do sListTool = sListTool .. '\n ' .. tListError[k] end end else sListTool = sListTool .. '\n ' .. string.format( EgtDoorsMsg[554], ' ') .. ' (from Default)' end -- se fallito quello di default o utensili mancanti provo quelli indicati nel CurrCamInfo if not bSetUp then local sDefSetUp = sSetup -- mi tengo via il nome dell'attrezzaggio di default local nContImport = 0 -- ciclo tra quelli disponibili for k = 1, 30 do if not bSetUp then if k == 1 then sSetup = mCamData[nNumMachFromCam].Setup1 elseif k == 2 then sSetup = mCamData[nNumMachFromCam].Setup2 elseif k == 3 then sSetup = mCamData[nNumMachFromCam].Setup3 elseif k == 4 then sSetup = mCamData[nNumMachFromCam].Setup4 elseif k == 5 then sSetup = mCamData[nNumMachFromCam].Setup5 elseif k == 6 then sSetup = mCamData[nNumMachFromCam].Setup6 elseif k == 7 then sSetup = mCamData[nNumMachFromCam].Setup7 elseif k == 8 then sSetup = mCamData[nNumMachFromCam].Setup8 elseif k == 9 then sSetup = mCamData[nNumMachFromCam].Setup9 elseif k == 10 then sSetup = mCamData[nNumMachFromCam].Setup10 elseif k == 11 then sSetup = mCamData[nNumMachFromCam].Setup11 elseif k == 12 then sSetup = mCamData[nNumMachFromCam].Setup12 elseif k == 13 then sSetup = mCamData[nNumMachFromCam].Setup13 elseif k == 14 then sSetup = mCamData[nNumMachFromCam].Setup14 elseif k == 15 then sSetup = mCamData[nNumMachFromCam].Setup15 elseif k == 16 then sSetup = mCamData[nNumMachFromCam].Setup16 elseif k == 17 then sSetup = mCamData[nNumMachFromCam].Setup17 elseif k == 18 then sSetup = mCamData[nNumMachFromCam].Setup18 elseif k == 19 then sSetup = mCamData[nNumMachFromCam].Setup19 elseif k == 20 then sSetup = mCamData[nNumMachFromCam].Setup20 elseif k == 21 then sSetup = mCamData[nNumMachFromCam].Setup21 elseif k == 22 then sSetup = mCamData[nNumMachFromCam].Setup22 elseif k == 23 then sSetup = mCamData[nNumMachFromCam].Setup23 elseif k == 24 then sSetup = mCamData[nNumMachFromCam].Setup24 elseif k == 25 then sSetup = mCamData[nNumMachFromCam].Setup25 elseif k == 26 then sSetup = mCamData[nNumMachFromCam].Setup26 elseif k == 27 then sSetup = mCamData[nNumMachFromCam].Setup27 elseif k == 28 then sSetup = mCamData[nNumMachFromCam].Setup28 elseif k == 29 then sSetup = mCamData[nNumMachFromCam].Setup29 elseif k == 30 then sSetup = mCamData[nNumMachFromCam].Setup30 end -- se nome attrezzaggio non è vuoto if sSetup and #sSetup > 0 then bSetUp = EgtImportSetup(sSetup) end if bSetUp then -- se importato il fle da CurrCamInfo nContImport = nContImport + 1 -- verifico se l'attrezzaggio è idoneo bSetUp, tListError = EgtVerifyCurrSetup() if bSetUp then -- se è andato bene -- assegno nota con il nome del file setup assegnato EgtSetInfo( EgtGetCurrSetup(), 'Name', sSetup) break else -- se utensili mancanti prendo la lista e passo al successivo sListTool = sListTool .. '\n ' .. string.format( EgtDoorsMsg[552], sSetup) .. string.format(' (from CurrCamInfo Setup%s)', k) sListTool = sListTool .. '\n ' .. EgtDoorsMsg[553] for k = 1, #tListError do sListTool = sListTool .. '\n ' .. tListError[k] end end else -- se non importato carico il messaggio di errore e passo al successivo sListTool = sListTool .. '\n ' .. string.format( EgtDoorsMsg[554], sSetup) .. string.format(' (from CurrCamInfo Setup%s)', k) end end end -- se nessuno è andato bene verifico se il primo era stato importato if not bSetUp then -- se ho importato almeno un attrezzaggio do errore if ( sDefSetUp and #sDefSetUp > 0) or nContImport > 0 then if DGD.EMC and #DGD.EMC > 0 then DGD.EMC = DGD.EMC .. '\n' .. ' ' .. EgtDoorsMsg[551] else DGD.EMC = ' ' .. EgtDoorsMsg[551] end bOk = false if #sListTool > 0 then DGD.EMC = DGD.EMC .. sListTool end else -- setup default non definito -- assegno ugualmente un attrezzaggio vuoto EgtSetInfo( EgtGetCurrSetup(), 'Name', EgtDoorsMsg[555]) end end end if nNumGroup > 1 then sNumGroup = '_'..EgtNumToString(nNumGroup, 0) end -- Eventuale messaggio di errore if not bOk then DoorOutLog( string.format(EgtDoorsMsg[494], tMainTabPar.MN), 0) -- inizio lavorazione su macchina DGD.ERR = 20 DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 1) -- stampo gli errori del machiningBase if DGD.EMC and #DGD.EMC > 0 then DoorOutLog( DGD.EMC, 0) end DoorOutLog( string.format( EgtDoorsMsg[475], tMainTabPar.MN), 0) -- Error on machining calculation -- cancello il file cn e il txt EgtEraseFile( sFileDir..sFileName..sNumGroup..'.cnc') EgtEraseFile( sFileDir..sFileName..sNumGroup..'.txt') -- cancello eventuali file immagini EgtEraseFile( sFileDir..sFileName..sNumGroup..'_TableView'..'.html') EgtEraseFile( sFileDir..sFileName..sNumGroup..'_TableView'..'.png') --ricreo il file txt con l'errore WriteErrFile( sFileDir..sFileName..sNumGroup..'.txt', string.format( EgtDoorsMsg[475], tMainTabPar.MN)) if not DGD.NCGEN then -- modificato not DGD con not DGD.NCGEN perche ho incluso EgtDoorsData dove esiste DGD if DGD.EMC and #DGD.EMC > 0 then EgtOutBox( DGD.EMC .. '\n' .. string.format( EgtDoorsMsg[475], tMainTabPar.MN), EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on machining calculation else EgtOutBox( string.format( EgtDoorsMsg[475], tMainTabPar.MN), EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on machining calculation end end -- Salvo progetto EgtSaveFile() return false, nNumGroup end -- Applica tutte le lavorazioni ( che comprende anche l'aggiornamento, EgtUpdateAllMachinings con il calcolo assi macchina e movimenti tra lavorazioni e finale) EgtApplyAllMachinings( false, false) local nNumMachErr, sErrMach = EgtGetLastMachMgrError() local bMachOk = true -- Salvo progetto EgtSaveFile() -- controllo collisioni local bSimOk if nNumMachErr == 0 then -- Simulation for collision check if tMainTabPar.ECD == 1 then DoorOutLog( ' +++ Simulating with collision check >>>', 0) EgtOutText( 'Start hidden simulation to find collision, It keep some time') local nErr, sErr bSimOk, nErr, sErr = EgtSimulate() if not bSimOk then if nErr == MCH_SHE.INIT then DGD.ERR = 33 DGD.EMC = DGD.EMC .. string.format(EgtDoorsMsg[686], sErr) EgtOutBox( string.format(EgtDoorsMsg[686], sErr), 'Simulation', 'Simulation') elseif nErr == MCH_SHE.COLLISION then DGD.ERR = 33 DGD.EMC = DGD.EMC .. string.format(EgtDoorsMsg[687], sErr) EgtOutBox( string.format(EgtDoorsMsg[687], sErr), 'Collision', 'Collision') elseif nErr == MCH_SHE.OUTSTROKE then DGD.ERR = 33 DGD.EMC = DGD.EMC .. string.format(EgtDoorsMsg[688], sErr) EgtOutBox( string.format(EgtDoorsMsg[688], sErr), 'Outstroke', 'Outstroke') else DGD.ERR = 33 DGD.EMC = DGD.EMC .. string.format(EgtDoorsMsg[689], sErr) EgtOutBox( string.format(EgtDoorsMsg[689], sErr), 'Simulation', 'Simulation') end end EgtOutText( 'hidden simulation finished') else bSimOk = true end else bMachOk = false DGD.ERR = 36 DGD.EMC = DGD.EMC .. string.format(EgtDoorsMsg[713], sErrMach) EgtOutBox( string.format(EgtDoorsMsg[713], sErrMach), 'Machining error', 'Machining error') end if bMachOk and bSimOk then -- Estimation bOk = EgtEstimate( sFileDir..sFileName..sNumGroup..'.html', 'EgtCam5 - '..sFilePath) -- NC code generation bOk = EgtGenerate( sFileDir..sFileName..sNumGroup..EgtIf( nProbeMode ~= 1,'.cnc','.prb'), 'EgtCam5 - '..sFilePath) else bOk = false end if bOk then if not DGD.ERR then DGD.ERR = 0 end DoorOutLog( string.format( '\n'..EgtDoorsMsg[494], tMainTabPar.MN), 0) -- inizio lavorazione su macchina DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 1) if not DGD.NCGEN then if DGD.ERM and #DGD.ERM > 0 then DoorOutLog( DGD.ERM, 0) -- stampo la disposizione nel log end end DoorOutLog( sTotDispMode, 0) -- stampo la disposizione nel log -- esportazione vista tavola local bExport -- se esportazione vista pezzo in png o esportazione vista tavola tipo html (vista 3d) if tMainTabPar.ETV >= 1 and tMainTabPar.ETV <= 3 then local sIniFilePath local nPieceToZoom local dWidthImg, dHeightImg -- se esportazione vista tavola tipo png (vista 2d) if tMainTabPar.ETV == 1 or tMainTabPar.ETV == 3 then -- ottengo la risoluzione di esportazione sIniFilePath = EgtGetIniFile() -- percorso del file ini dell'EgtCam5 dWidthImg = EgtGetStringFromIni( 'Export', 'ImgWidth', '1920', sIniFilePath) dHeightImg = EgtGetStringFromIni( 'Export', 'ImgHeight', '1080', sIniFilePath) end for v = 1, #tMchId do -- acquisisco il numero di fase local nCurrPhase = EgtGetCurrPhase() -- esco dal machining EgtResetCurrMachGroup() -- acquisisco il numero complessivo di tavole e su quale tavola è disposto il pezzo local nTableUsed = EgtGetInfo( tMchId[v][3], 'TableUsed', 'i') -- cerco nel GDB_ID.ROOT la macchina e il gruppo di lavoro local nMachAux = EgtGetNameInGroup( GDB_ID.ROOT, 'MachAux') if nMachAux and #nMachAux == 1 then local nIdMachine = EgtGetFirstInGroup( nMachAux[1]) local sNameInMachAux while nIdMachine do sNameInMachAux = EgtGetName(nIdMachine) or '' -- se trovata macchina if #sNameInMachAux > 0 and sNameInMachAux == tMchId[v][1] then break else nIdMachine = EgtGetNext( nIdMachine) end end -- se trovato nome macchina if nIdMachine then -- rendo visiblie il gruppo EgtSetStatus( nIdMachine, GDB_ST.ON) -- lascio abilitata solo la tavole local nGenGroup = EgtGetNameInGroup( nIdMachine, 'Base') if nGenGroup and #nGenGroup == 1 then local nSubGenGroup = EgtGetFirstInGroup( nGenGroup[1]) while nSubGenGroup do -- acquisisco il nome del grippo local sNameSubGenGroup = EgtGetName(nSubGenGroup) if sNameSubGenGroup then local sTabName = 'tab' -- se ho più tavole verifico di abilitare quella utilizzata if nTableUsed == 1 then sTabName = 'tab1' elseif nTableUsed == 2 then sTabName = 'tab2' end -- Se nel nome non è presente la parte tavola la nascondo if not string.find( string.lower(sNameSubGenGroup), 'tab') then EgtSetStatus( nSubGenGroup, GDB_ST.OFF) -- ho una componente tavola else -- se ho più tavola if NUMTABLE > 1 then -- nascondo la tavola non utilizzata if not string.find( string.lower(sNameSubGenGroup), sTabName) then EgtSetStatus( nSubGenGroup, GDB_ST.OFF) else -- altrimenti tango traccia della tavola utilizzata per fare lo zoom nPieceToZoom = nSubGenGroup end -- altrimenti una tavola sola else -- se ho trovato la tavola if string.find( string.lower(sNameSubGenGroup), sTabName) then nPieceToZoom = nSubGenGroup -- altrimenti se ho trovato la tavola provo con la standard elseif string.find( string.lower(sNameSubGenGroup), 'tab') then nPieceToZoom = nSubGenGroup -- altrimenti nascondo l'oggetto else EgtSetStatus( nSubGenGroup, GDB_ST.OFF) end end end -- se non ha un nome lo nascondo in ogni caso else EgtSetStatus( nSubGenGroup, GDB_ST.OFF) end nSubGenGroup = EgtGetNext( nSubGenGroup) end end end end local nMachBase = EgtGetNameInGroup( GDB_ID.ROOT, 'MachBase') if nMachBase and #nMachBase == 1 then local nIdMachGroup = EgtGetFirstInGroup( nMachBase[1]) local sNameInMachBase -- ottengo il nome del gruppo local sMachIdName = EgtGetName(tMchId[v][2]) while nIdMachGroup do sNameInMachBase = EgtGetName(nIdMachGroup) or '' -- se trovato gruppo lavoro if #sNameInMachBase > 0 and sNameInMachBase == sMachIdName then break else nIdMachGroup = EgtGetNext( nIdMachGroup) end end -- se trovato nome gruppo lavoro if nIdMachGroup then -- rendo visiblie il gruppo EgtSetStatus( nIdMachGroup, GDB_ST.ON) end end local nVMill = EgtGetNameInGroup( GDB_ID.ROOT, 'VMill') -- nascondo i pezzi local nPieceId = EgtGetFirstInGroup( GDB_ID.ROOT) -- se sono presenti i due gruppi if nMachBase and #nMachBase == 1 and nMachAux and #nMachAux == 1 then -- ottengo il nome del pezzo local sPieceNameToDis = EgtGetName(tMchId[v][3]) while nPieceId do -- se pezzo esiste ed è diverso dagli altri if nPieceId ~= nMachBase[1] and nPieceId ~= nMachAux[1] then -- rendo non visiblie il gruppo EgtSetStatus( nPieceId, GDB_ST.OFF) end nPieceId = EgtGetNext( nPieceId) end end -- se esportazione html if tMainTabPar.ETV == 2 or tMainTabPar.ETV == 3 then -- esporto html local sExport = sFileDir..sFileName..sNumGroup.. '_TableView' ..'.html' bExport = EgtExportThreeJS( GDB_ID.ROOT, sExport, 393) end -- se esportazione vista tavola tipo png (vista 2d) if tMainTabPar.ETV == 1 or tMainTabPar.ETV == 3 then if nPieceToZoom then EgtZoomObject( nPieceToZoom) else EgtZoom( SCE_ZM.OUT) end local sExport = sFileDir..sFileName..sNumGroup.. '_TableView' ..'.png' local cColor3d1, cColor3d2 = EgtGetBackground() if cColor3d1 and cColor3d2 then bExport = EgtGetImage( SCE_SM.SH, cColor3d1, cColor3d2, dWidthImg, dHeightImg, sExport) end end -- riporto tutto come prima, per prima la macchina nel MachAux if nMachAux and #nMachAux == 1 then local nIdMachine = EgtGetFirstInGroup( nMachAux[1]) -- nascono tutte le macchine while nIdMachine do EgtSetStatus( nIdMachine, GDB_ST.OFF) nIdMachine = EgtGetNext( nIdMachine) end end -- nascono i gruppi nel MachBase if nMachBase and #nMachBase == 1 then local nIdMachGroup = EgtGetFirstInGroup( nMachBase[1]) -- nascono tutti i gruppi di lavoro while nIdMachGroup do EgtSetStatus( nIdMachGroup, GDB_ST.OFF) nIdMachGroup = EgtGetNext( nIdMachGroup) end end -- rendo visibile i pezzi local nPieceId = EgtGetFirstInGroup( GDB_ID.ROOT) -- se sono presenti i due/tre gruppi if nMachBase and #nMachBase == 1 and nMachAux and #nMachAux == 1 then while nPieceId do -- se pezzo esiste ed è diverso dagli altri if nPieceId ~= nMachBase[1] and nPieceId ~= nMachAux[1] then if nVMill then if nPieceId ~= nVMill[1] then -- rendo visiblie il gruppo EgtSetStatus( nPieceId, GDB_ST.ON) end else -- rendo visiblie il gruppo EgtSetStatus( nPieceId, GDB_ST.ON) end end nPieceId = EgtGetNext( nPieceId) end end -- rientro nel machining EgtSetCurrMachGroup( tMchId[v][2]) EgtSetCurrPhase(nCurrPhase) end EgtSaveFile() end -- cancello e ricreo il file txt EgtEraseFile( sFileDir..sFileName..sNumGroup..'.txt') --ricreo il file txt con la disposizione WriteErrFile( sFileDir..sFileName..sNumGroup..'.txt', sTotDispMode) else -- altrimenti errore cn -- se le lavorazioni e la simulazione sono corrette ma errore nella generazione if bMachOk and bSimOk then DGD.ERR = 20 DGD.EMC = DGD.EMC .. string.format(EgtDoorsMsg[478], tMainTabPar.MN, sSetup) end -- cancello eventuali file immagini EgtEraseFile( sFileDir..sFileName..sNumGroup..'_TableView'..'.html') EgtEraseFile( sFileDir..sFileName..sNumGroup..'_TableView'..'.png') -- cancello e ricreo il file txt EgtEraseFile( sFileDir..sFileName..sNumGroup..'.txt') --ricreo il file txt con la disposizione WriteErrFile( sFileDir..sFileName..sNumGroup..'.txt') -- se le lavorazioni sono corrette ma errore nella simulazione o generazione if bMachOk then -- se la simulazione è stata corretta ma errore nella generazione if bSimOk then -- scrivo messaggio nei file log DoorOutLog( string.format(EgtDoorsMsg[478], tMainTabPar.MN, sSetup), 0) -- Error on Nc part program generation -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) EgtOutBox( string.format(EgtDoorsMsg[478], tMainTabPar.MN, sSetup), EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on Nc part program generation end -- altrimenti errore in simulazione else -- scrivo messaggio nei file log DoorOutLog( EgtDoorsMsg[690], 0) -- Error on simulation -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) EgtOutBox( EgtDoorsMsg[690], EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on simulation end end -- altrimenti errore nelle lavorazioni else -- scrivo messaggio nei file log DoorOutLog( EgtDoorsMsg[714], 0) -- Error on machining generation -- se lanciato da DMach stampo anche un messaggio a video if not DGD or not DGD.NCGEN then DoorOutLog( ' Err=' .. EgtNumToString( DGD.ERR, 0), 0) EgtOutBox( EgtDoorsMsg[714], EgtDoorsMsg[476], EgtDoorsMsg[477]) -- Error on machining generation end end return false, nNumGroup end --nTime = EgtStopCounter() --if not DGD or not DGD.NCGEN then -- EgtOutBox( string.format( 'tempo calcolato sec: %s', (nTime/1000)), 'Time3', 'Time3') --end -- reset librerie locali package.loaded[MachiningsTable] = nil package.loaded[MachiningsTableOrd] = nil return true, nNumGroup end return MachiningLoc