Dario Sassi
3368 lines
130 KiB
Lua
3368 lines
130 KiB
Lua
--
|
|
-- 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
|
|
--
|
|
-- MachiningBase.lua by EgalWare s.r.l. 2016.07.10
|
|
-- Machining Base library
|
|
|
|
-- 2017.06.30 V1.013 FM Add function for optimization paths with same machining
|
|
-- 2017.11.17 V1.014 FM Add manage parameter dExtraThruDepth from CurrCamInfo into functions AdjustThrouIsle and AdjustVertHole
|
|
-- 2018.08.22 V1.015 FM Add parameter dBevelOffs on MakeRoughPaths function
|
|
-- 2018.08.22 V1.016 FM add parameter nForceUseShuttle on AdjustHead function to set only the forced shuttle
|
|
-- 2019.01.11 V1.017 FM Manage note Mach2nd into function FindEntitiesCompMach
|
|
-- 2019.01.14 V1.018 FM Manage note Mach2nd into functions AdjustThrouIsle and AdjustVertHole
|
|
-- 2019.01.21 V1.019 FM Add output of variable nTypeGeom on function AdjustVertHole
|
|
-- 2019.01.24 V1.01a FM Fix error into FindEntitiesCompMach on compare with sKeepProbe
|
|
-- 2019.01.24 V1.01b FM Extend cases on AdjustHeadChisel function
|
|
-- 2019.04.08 V1.01c FM Add common functions ModifyLiLo (used into AddAndDelMachining) and AdjustBladeVertCurve
|
|
-- to manage blade lead-in and lead-out
|
|
-- 2019.04.30 V1.01d FM Add functions AdjustASplintWithBlade to manage anti-splint paths when groove by blade
|
|
-- 2019.04.08 V1.01d FM Add functions AdjustHeadOnASplint to manage anti-splint path on hinge side when groove by blade
|
|
-- 2019.04.08 V1.01d FM Add common functions DefineASplint (used into AdjustHeadOnASplint and AdjustASplintWithBlade)
|
|
-- 2019.07.17 V1.01e FM Manage better the delta angle when probemode is active on function AdjustHorizDrillX and AdjustHorizDrillY
|
|
-- 2019.08.27 V1.01f FM Release Notes info on exit of AddAndDelMachining function
|
|
-- 2019.08.27 V1.01f FM Add FindGeomWithNote function
|
|
-- 2019.10.01 V1.020 FM Delete function FindProperties (already present into EgtDoorBase as FindProperty)
|
|
-- 2019.10.01 V1.021 FM Add AdjPrfThrouCurveNew function
|
|
-- 2019.10.17 V1.023 FM Manage note for blade into AdjustThrouIsle
|
|
-- 2019.10.18 V2.000 FM Manage use Materials
|
|
-- 2019.10.21 V2.001 FM Add function ModifyLiLoToExt to modify lead-in and lead-out for strike steel machining
|
|
-- 2019.11.11 V2.002 FM Into function MakeRoughPaths manage also Top chamfer shape
|
|
-- 2019.12.02 V2.003 FM Modify function ModifyLiLoToExt to disable also oscillation parameters
|
|
-- 2020.12.22 V2.004 FM Manage Open Paths into TestThrouIsle and AdjustThrouIsle functions
|
|
-- 2021.04.02 V2.005 FM Manage Closed paths with no area into TestThrouIsle and AdjustThrouIsle functions
|
|
-- 2021.05.25 V2.006 FM Manage Closed paths with no area into TestVertHole and AdjustVertHole functions
|
|
-- 2021.11.24 V2.007 FM Add functions AdjustProbeMill to manage probe paths
|
|
-- 2022.02.21 V2.008 FM Manage machining note CUT_LENGTH=xxx to machine only distance defined by value (in mm)
|
|
-- 2023.05.24 V2.009 FM Add function AdjustVertAsOnHeads to modify anti split paths (of door heads) to be vertical on bevelled sides
|
|
-- 2023.07.26 V2.00a FM Fix error on calculate area on closed curved into AdjustThrouIsle function
|
|
-- 2023.09.16 V2.00b FM Manage to invert path also with Zpositive direction path into AdjustThrouCurve function
|
|
-- 2023.10.25 V2.00c FM Manage add extra leadout length into AddAndDelMachining
|
|
-- 2023.10.25 V2.00d FM Manage new input interface parameter nModeOrder into OrderEnt function
|
|
-- to have head machining ordered from X pos to X neg
|
|
-- 2023.10.25 V2.00d FM Manage new input interface parameter bNoModifyPath into AdjustBevel function
|
|
-- to manage 5 axis head and 3 axis head ( that machine bevel profile) on same machine
|
|
-- 2023.11.13 V2.00e FM into AddAndDelMachining function let to Outpuut the machining note also when 'not generation machining' flag is enable
|
|
-- 2024.01.19 V2.010 FM Fix error into InsZedByTool when use max function with a paarameter at nil value
|
|
-- 2024.05.31 V2.011 FM Add to function interface (and manage) the bNarrowDoor parameter into AddAndDelMachining function let to manage narrow doors
|
|
-- Add to function interface (and manage) the bSkipOnSecCol parameter into AdjustBevel function
|
|
-- Add to function interface (and manage) the bSkipOnSecCol parameter into AdjustThrouCurve function
|
|
-- 2024.06.21 V2.012 FM Manage to set clockwise direction on closed path into Adjusthead (by new parameter: bCheckDirection)
|
|
-- 2024.10.30 V2.013 FM into GetToolDataFromAttrib function, if force read thicknnes is enabled get the mill max thickness as blade thickness
|
|
-- in case mill is used instead blade
|
|
-- 2024.11.14 V2.014 FM Manage the flipping geometry into AdjustConeCleanPaths from solid layer than geometry
|
|
-- 2025.01.13 V2.015 FM Initialize DGD.GHT to be compatible with old Machining_xxx
|
|
-- 2025.01.17 V2.016 FM Set infos (Parent and LinkCode) to ghost paths (into MakeGhostCopy function)
|
|
-- and disable the machining that has info LinkCode with negative value ( into AddAndDelMachining function)
|
|
-- 2025.01.20 V2.017 FM Manage new info type 'InvDir' from groove compo into funtion ModifyLiLo
|
|
|
|
require( 'EgtBase')
|
|
require( 'EgtConst')
|
|
local EgtDoorsMsg = require( 'EgtDoorsMsg')
|
|
|
|
-- Tavola per definizione modulo
|
|
local MachiningBase = {}
|
|
|
|
print( 'MachiningBase started')
|
|
DoorOutLog( ' MachiningBase started', 1)
|
|
|
|
-- set the DGD with old value to be compatible with old Machining_x files
|
|
if not DGD.GHT then
|
|
DGD.GHT = '_HIDE'
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Disposition Functions ***
|
|
-----------------------------------------------------------------
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustXFixture( dX)
|
|
-- per non trovarsi tra i due tavoli
|
|
if dX > 2360 and dX < 2570 then
|
|
dX = 2570
|
|
end
|
|
return dX
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustXReference( dX, HintList)
|
|
local DX_ENG = 200
|
|
dX = MachiningBase.AdjustXFixture( dX)
|
|
--for i = 1, #HintList, 2 do
|
|
-- if dX > HintList[i] - DX_ENG and dX < HintList[i+1] + DX_ENG then
|
|
-- dX = HintList[i] - DX_ENG
|
|
-- end
|
|
--end
|
|
return dX
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Make Ghost copy of entity ***
|
|
-----------------------------------------------------------------
|
|
function MachiningBase.MakeGhostCopy( EntId, bCheckDirection)
|
|
|
|
local sParnt = EgtGetParent( EntId)
|
|
local EntName = EgtGetName( EntId)
|
|
local nNewEntId = EgtCopyGlob( EntId, sParnt)
|
|
EgtSetName( nNewEntId, EntName..DGD.GHT)
|
|
EgtSetStatus( nNewEntId, GDB_ST.OFF)
|
|
|
|
-- Se ottimizzazione lavorazioni macchine in linea
|
|
if DGD.OML then
|
|
EgtSetInfo( nNewEntId, 'Parent', EntId)
|
|
end
|
|
-- assegno nota con valore il campo Link della Mtable
|
|
if DGD.LVL and abs(DGD.LVL) > 0 then
|
|
EgtSetInfo( nNewEntId, 'LinkCode', DGD.LVL)
|
|
end
|
|
|
|
-- se check per verifica direzione percorso
|
|
if bCheckDirection then
|
|
|
|
-- verifico se ho la nota per non fare il controllo di direzione percorso ( per esempio le svuotature in centro utensile)
|
|
local nNotCheck = EgtGetInfo( nNewEntId, 'NotCheckDir', 'i') or 0
|
|
|
|
-- se la nota vale 0 o non ho la nota faccio la verifica
|
|
if nNotCheck == 0 then
|
|
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( nNewEntId, GDB_ID.ROOT)
|
|
local vtMPlane, dDist, dArea
|
|
|
|
-- verifico se il percorso è chiuso
|
|
if EgtCurveIsClosed( nNewEntId) then
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
vtMPlane, dDist, dArea = EgtCurveArea( nNewEntId)
|
|
if abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return nNewEntId
|
|
end
|
|
-- altrimenti non è chiuso
|
|
else
|
|
-- faccio una copia del percorso
|
|
local nNewEntId2 = EgtCopyGlob( nNewEntId, sParnt)
|
|
-- chiudo il percorso
|
|
if EgtCloseCurveCompo( nNewEntId2) then
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
vtMPlane, dDist, dArea = EgtCurveArea( nNewEntId2)
|
|
EgtErase(nNewEntId2)
|
|
if dArea and abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return nNewEntId
|
|
end
|
|
else
|
|
EgtErase(nNewEntId2)
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
vtMPlane, dDist, dArea = EgtCurveArea( nNewEntId)
|
|
if not dArea or abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return nNewEntId
|
|
end
|
|
end
|
|
end
|
|
|
|
local frEnt = EgtGetGlobFrame( nNewEntId)
|
|
if vtMPlane then
|
|
vtMPlane:toGlob(frEnt)
|
|
if dArea and dArea * ( vtMPlane * vtExtr) > 0 then
|
|
EgtInvertCurve( nNewEntId)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return nNewEntId
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Seeking Functions ***
|
|
-----------------------------------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.FindEntitiesCompMach( nEntId, tEntList, sMachining, nJoinGeomInMach, nMaxDist, bSameLayer, bSameSecMach)
|
|
local List = {}
|
|
-- inserisco per prima l'entità passata
|
|
table.insert( List, nEntId)
|
|
-- acquisisco il padre dell'entità passata
|
|
local nParendId = EgtGetParent(nEntId)
|
|
-- punto iniziale entità passata
|
|
local pIni1 = EgtSP( nEntId, GDB_ID.ROOT)
|
|
-- nota correzione in Z per probe
|
|
local sKeepProbe = EgtGetInfo( nEntId, 'KeepBackSet') or '0'
|
|
local sNoteProbes = EgtGetInfo( nEntId, 'ProbeSide') or '0'
|
|
-- se direzione fresa da sotto esco subito
|
|
local vtExtr = EgtCurveExtrusion( nEntId, GDB_ID.ROOT) -- recupero versore estrusione
|
|
-- parametro link
|
|
local nCheckLink = EgtGetInfo( nEntId, 'LinkCode', 'i') or 0
|
|
local bEnablekinkCheck = DGD.OML
|
|
|
|
-- --------------------------------------------------------------------------------------
|
|
-- provvisoriamente lascio attiva la gestione del Join anche se ho il parametro LinkCode
|
|
-- nel caso si voglia disabilitare il join commentare la linea bEnablekinkCheck = false
|
|
-- --------------------------------------------------------------------------------------
|
|
bEnablekinkCheck = false
|
|
|
|
-- se non ha codice link, non abilitato, con distanza valida e non diretto verso il basso
|
|
if ( nCheckLink == 0 or not bEnablekinkCheck) and nJoinGeomInMach and nJoinGeomInMach > 0 and nMaxDist and nMaxDist > 0 and vtExtr:getZ() > - 0.1 then
|
|
for i = 1, #tEntList do
|
|
if tEntList[i] and tEntList[i] ~= nEntId then
|
|
-- se sono nello stesso layer
|
|
if not bSameLayer or EgtGetParent( tEntList[i]) == nParendId then
|
|
-- se non ha parametro link
|
|
nCheckLink = EgtGetInfo( tEntList[i], 'LinkCode', 'i') or 0
|
|
if ( nCheckLink == 0 or not bEnablekinkCheck) then
|
|
local sMachNote = EgtGetInfo( tEntList[i], 'Machining')
|
|
-- se hanno la stessa lavorazione
|
|
if sMachNote and sMachNote == sMachining then
|
|
-- se non è già stata lavorata
|
|
local nSecMach = EgtGetInfo( tEntList[i], 'Mach2nd', 'i') or 0
|
|
if bSameSecMach or nSecMach == 0 then
|
|
local vtExtr1 = EgtCurveExtrusion( tEntList[i], GDB_ID.ROOT) -- recupero versore estrusione
|
|
if AreSameVectorApprox( vtExtr1, vtExtr) then -- se direzioni uguali
|
|
local pIni2 = EgtSP( tEntList[i], GDB_ID.ROOT)
|
|
local sKeepProbe2 = EgtGetInfo( tEntList[i], 'KeepBackSet') or '0'
|
|
local sNoteProbes2 = EgtGetInfo( tEntList[i], 'ProbeSide') or '0'
|
|
-- se la distanza tra loro è inferiore della massima
|
|
if dist( pIni1, pIni2) <= nMaxDist then
|
|
-- se hanno note uguali
|
|
if sKeepProbe == sKeepProbe2 or sNoteProbes == sNoteProbes2 then
|
|
table.insert( List, tEntList[i])
|
|
-- pIni1 = pIni2 -- diventa il nuovo punto
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return List
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.FindEntitiesWithNameFromTab( ListPrev, sName)
|
|
local List = {}
|
|
if ListPrev then
|
|
for i = 1, #ListPrev do
|
|
local sEntName = EgtGetName( ListPrev[i])
|
|
if sEntName and sEntName == sName then
|
|
table.insert( List, ListPrev[i])
|
|
end
|
|
end
|
|
end
|
|
return List
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.FindEntitiesWithName( Pz, sName, ListPrev)
|
|
local List = {}
|
|
local PzIsTab = type(Pz) == 'table'
|
|
if ListPrev then
|
|
for i = 1, #ListPrev do
|
|
table.insert( List, ListPrev[i])
|
|
end
|
|
end
|
|
local nMaxPz = 1
|
|
if PzIsTab then nMaxPz = #Pz end
|
|
for i = 1, nMaxPz do
|
|
local nIdPz
|
|
if PzIsTab then nIdPz = Pz[i] else nIdPz = Pz end
|
|
local Ly = EgtGetFirstGroupInGroup( nIdPz)
|
|
while Ly do
|
|
local Ent = EgtGetFirstNameInGroup( Ly, sName)
|
|
while Ent do
|
|
table.insert( List, Ent)
|
|
Ent = EgtGetNextName( Ent, sName)
|
|
end
|
|
Ly = EgtGetNextGroup( Ly)
|
|
end
|
|
end
|
|
return List
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.FindGroupWithPartName( Pz, sNameFind, ListPrev)
|
|
local List = {}
|
|
local PzIsTab = type(Pz) == 'table'
|
|
if ListPrev then
|
|
for i = 1, #ListPrev do
|
|
table.insert( List, ListPrev[i])
|
|
end
|
|
end
|
|
local nMaxPz = 1
|
|
if PzIsTab then nMaxPz = #Pz end
|
|
for i = 1, nMaxPz do
|
|
local nIdPz
|
|
if PzIsTab then nIdPz = Pz[i] else nIdPz = Pz end
|
|
local Ent = EgtGetFirstInGroup( nIdPz)
|
|
while Ent do
|
|
local sNameEnt = EgtGetName(Ent)
|
|
if sNameEnt and string.find( sNameEnt, sNameFind) then
|
|
table.insert( List, Ent)
|
|
end
|
|
Ent = EgtGetNext( Ent)
|
|
end
|
|
end
|
|
return List
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.FindEntitiesWithPartName( Pz, sNameFind, ListPrev, sInfoName, nInfoValue)
|
|
local List = {}
|
|
local ListTwo = {}
|
|
local PzIsTab = type(Pz) == 'table'
|
|
if ListPrev then
|
|
for i = 1, #ListPrev do
|
|
table.insert( List, ListPrev[i])
|
|
end
|
|
end
|
|
local nMaxPz = 1
|
|
if PzIsTab then nMaxPz = #Pz end
|
|
for i = 1, nMaxPz do
|
|
local nIdPz
|
|
if PzIsTab then nIdPz = Pz[i] else nIdPz = Pz end
|
|
local Ly = EgtGetFirstGroupInGroup( nIdPz)
|
|
while Ly do
|
|
local Ent = EgtGetFirstInGroup( Ly)
|
|
while Ent do
|
|
local sNameEnt = EgtGetName(Ent)
|
|
if sNameEnt and string.find( sNameEnt, sNameFind) then
|
|
-- se note da ricercare
|
|
if sInfoName and nInfoValue and #sInfoName > 0 and nInfoValue > 0 then
|
|
-- se nota corrisponde
|
|
if EgtGetInfo( Ent, sInfoName, 'i') == nInfoValue then
|
|
table.insert( ListTwo, Ent)
|
|
else
|
|
table.insert( List, Ent)
|
|
end
|
|
else
|
|
table.insert( List, Ent)
|
|
end
|
|
end
|
|
Ent = EgtGetNext( Ent)
|
|
end
|
|
Ly = EgtGetNextGroup( Ly)
|
|
end
|
|
end
|
|
return List, ListTwo
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.FindEntities( Pz, bSingle)
|
|
local List = {}
|
|
local Ly = EgtGetFirstInGroup( Pz)
|
|
while Ly do
|
|
if bSingle then
|
|
return Ly -- esco appena ha trovato il primo trovato
|
|
else
|
|
table.insert( List, Ly) -- inserisco a tabella
|
|
end
|
|
Ly = EgtGetNext( Ly)
|
|
end
|
|
|
|
if bSingle then
|
|
return nil
|
|
else
|
|
return List
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.FindGeomWithName( Pz, sName, bSingle, ListPrev)
|
|
local List = {}
|
|
if ListPrev and not bSingle then
|
|
for i = 1, #ListPrev do
|
|
table.insert( List, ListPrev[i])
|
|
end
|
|
end
|
|
local Ly = EgtGetFirstInGroup( Pz)
|
|
while Ly do
|
|
local Ent = EgtGetName( Ly)
|
|
if Ent == sName then
|
|
if bSingle then
|
|
return Ly -- esco appena ha trovato il primo elemento
|
|
else
|
|
table.insert( List, Ly) -- inserisco a tabella
|
|
end
|
|
end
|
|
Ly = EgtGetNext( Ly)
|
|
end
|
|
|
|
if bSingle then
|
|
return nil
|
|
else
|
|
return List
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.FindGeomWithNote( Pz, sNote, sTypeNote, NoteToFind, ListPrev)
|
|
local List = {}
|
|
if ListPrev then
|
|
for i = 1, #ListPrev do
|
|
table.insert( List, ListPrev[i])
|
|
end
|
|
end
|
|
local Ly = EgtGetFirstInGroup( Pz) -- ottengo il primo layer
|
|
while Ly do
|
|
-- ottengo la prima entità del layer
|
|
local Lx = EgtGetFirstInGroup( Ly)
|
|
while Lx do
|
|
local Ent = EgtGetInfo( Lx, sNote, sTypeNote)
|
|
if sTypeNote == 'b' then -- se nota booleana
|
|
if Ent then -- se trovata nota boolena
|
|
table.insert( List, Lx) -- inserisco a tabella
|
|
end
|
|
else
|
|
if Ent == NoteToFind then
|
|
table.insert( List, Lx) -- inserisco a tabella
|
|
end
|
|
end
|
|
Lx = EgtGetNext( Lx)
|
|
end
|
|
Ly = EgtGetNext( Ly)
|
|
end
|
|
|
|
return List
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.GetHingesBoxes( Pz, tabOriX)
|
|
local List = {}
|
|
local Ly = EgtGetFirstGroupInGroup( Pz)
|
|
while Ly do
|
|
local sName = EgtGetName( Ly)
|
|
if sName and string.find( sName, 'Hinge', 1, true) then
|
|
local b3Box = EgtGetBBoxGlob( Ly, GDB_BB.STANDARD)
|
|
if b3Box then
|
|
table.insert( List, b3Box:getMin():getX() - tabOriX)
|
|
table.insert( List, b3Box:getMax():getX() - tabOriX)
|
|
end
|
|
end
|
|
Ly = EgtGetNextGroup( Ly)
|
|
end
|
|
return List
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.ReorderGroup( EntId, tOrderGrp, nDirToIns)
|
|
|
|
local nParendId = EgtGetParent(EntId)
|
|
local b3Grp = EgtGetBBoxGlob( nParendId, GDB_BB.STANDARD)
|
|
local dRefGrp = EgtIf( nDirToIns > 0, b3Grp:getMin():getX(), b3Grp:getMax():getX())
|
|
|
|
-- controllo dalla nota se non è già stata lavorata prima
|
|
local nSetSide = EgtGetInfo( EntId, 'Mach', 'i') or 0
|
|
|
|
-- se già lavorata annullo valore disabilitante
|
|
if nSetSide >= 10 then
|
|
EgtSetInfo( EntId, 'Mach', 0)
|
|
end
|
|
|
|
-- se trovato minimo lo assegno in testa
|
|
if #tOrderGrp == 0 then
|
|
table.insert( tOrderGrp, { nParendId, dRefGrp})
|
|
else
|
|
|
|
local bInsert = false
|
|
local bfoundGroup = false
|
|
for i = 1, #tOrderGrp do
|
|
-- se trovato minimo lo inserisco in tabella e ne riloco il gruppo nell'albero
|
|
local nIdParTab = tOrderGrp[i]
|
|
if nDirToIns > 0 then
|
|
if dRefGrp < nIdParTab[2] then
|
|
table.insert( tOrderGrp, i,{ nParendId, dRefGrp})
|
|
EgtRelocateGlob( nParendId, nIdParTab[1], GDB_IN.BEFORE)
|
|
bInsert = true
|
|
break
|
|
elseif nParendId == nIdParTab[1] then -- se gruppo già presente esco
|
|
bfoundGroup = true
|
|
break
|
|
end
|
|
else
|
|
if dRefGrp > nIdParTab[2] then
|
|
table.insert( tOrderGrp, i,{ nParendId, dRefGrp})
|
|
EgtRelocateGlob( nParendId, nIdParTab[1], GDB_IN.BEFORE)
|
|
bInsert = true
|
|
break
|
|
elseif nParendId == nIdParTab[1] then -- se gruppo già presente esco
|
|
bfoundGroup = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se non inserito lo inserisco in coda senza rilocamento
|
|
if not bInsert and not bfoundGroup then
|
|
table.insert( tOrderGrp, { nParendId, dRefGrp})
|
|
end
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.GetGroup( tLocMachOrd, ind, nNumGroup, sProperty)
|
|
|
|
local tSubGroup = {}
|
|
local nIdt = ind
|
|
if sProperty and #sProperty > 0 then -- acquisisco tutto il gruppo
|
|
for j = ind, #tLocMachOrd do
|
|
if tLocMachOrd[j].Group == nNumGroup then
|
|
table.insert( tSubGroup, tLocMachOrd[j])
|
|
nIdt = j
|
|
else -- se non è più lo stesso gruppo esco
|
|
break
|
|
end
|
|
end
|
|
else
|
|
table.insert( tSubGroup, tLocMachOrd[nIdt]) -- restituisco solo una linea della tabella
|
|
end
|
|
return tSubGroup, nIdt
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.LoadEntitiesFromGroup( tGroup, Pz, sSuffix)
|
|
|
|
local EntList
|
|
|
|
for j = 1, #tGroup do
|
|
EntList = MachiningBase.FindEntitiesWithName( Pz, tGroup[j].Name..sSuffix, EntList)
|
|
end
|
|
|
|
return EntList
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.InsZedByTool( TabZMach, tMachining, nInd)
|
|
|
|
local bFind = false
|
|
local nMaxVal = 0
|
|
|
|
for i = 1, nInd-1 do
|
|
if tMachining[nInd][2] == tMachining[i][2] then -- se utensile uguale assegno identico valore
|
|
table.insert( TabZMach, TabZMach[i]) -- inserisco lo stesso valore
|
|
bFind = true
|
|
break -- esco dal ciclo
|
|
else
|
|
nMaxVal = max( nMaxVal, (TabZMach[i] or 0))
|
|
end
|
|
end
|
|
|
|
if not bFind then -- se non ho trovato aggiungo nuovo valore alla Z utensile
|
|
table.insert( TabZMach, ( nMaxVal+10000))
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.OrderEnt( tListEntSameMach, EndLastMach, nModeOrder)
|
|
|
|
-- Tavole per fresature da ordinare
|
|
local TabMill = {}
|
|
local TabMStEnP = {}
|
|
local TabResult = {}
|
|
local dStart = -2000
|
|
|
|
if nModeOrder and nModeOrder == 1 then
|
|
dStart = 10000
|
|
end
|
|
|
|
for m = 1, #tListEntSameMach do
|
|
local ptStart = EgtSP( tListEntSameMach[m], GDB_ID.ROOT )
|
|
if ptStart then
|
|
table.insert( TabMill, tListEntSameMach[m])
|
|
table.insert( TabMStEnP, ptStart)
|
|
end
|
|
end
|
|
-- calcolo ordinamento
|
|
EgtSpInit()
|
|
for m = 1, #TabMill do
|
|
EgtSpAddPoint( TabMStEnP[m]:getX(), TabMStEnP[m]:getY(), TabMStEnP[m]:getZ(), 0, 0,
|
|
TabMStEnP[m]:getX(), TabMStEnP[m]:getY(), TabMStEnP[m]:getZ(), 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,dStart,0,0,90,90)
|
|
end
|
|
local vMillOrd
|
|
if not nModeOrder or nModeOrder == 0 then
|
|
vMillOrd = EgtSpCalculate(SHP_TY.OPEN)
|
|
elseif nModeOrder == 1 then
|
|
vMillOrd = EgtSpCalculate(SHP_TY.ONEWAY_XP)
|
|
else
|
|
vMillOrd = EgtSpCalculate(SHP_TY.OPEN)
|
|
end
|
|
EgtSpTerminate()
|
|
-- applico ordinamento calcolato
|
|
if vMillOrd and #vMillOrd == #tListEntSameMach then
|
|
for m = 1, #vMillOrd do
|
|
table.insert( TabResult, TabMill[vMillOrd[m]])
|
|
end
|
|
tListEntSameMach = TabResult
|
|
end
|
|
|
|
return tListEntSameMach
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.DefineASplint( EntId, nDispType, bFlipDoor, nMaxNum)
|
|
|
|
-- recupero note percorso
|
|
local bCutByBlade = EgtGetInfo( EntId, 'UseBlade', 'b')
|
|
local bCutByTwiceBlade = EgtGetInfo( EntId, 'UseTwiceBl', 'b')
|
|
|
|
-- se utilizzata lama
|
|
if bCutByBlade then
|
|
-- se uso doppia lama assegno la seconda lavorazione
|
|
if bCutByTwiceBlade then
|
|
-- lavorazione 2nd
|
|
EgtSetInfo( EntId, 'Mach', nMaxNum)
|
|
return nMaxNum
|
|
else -- altrimenti leggo altre note
|
|
|
|
local sSideApp = EgtGetInfo( EntId, 'SideApp', 's')
|
|
local nTypePath = EgtGetInfo( EntId, 'TypePath', 'i')
|
|
|
|
if sSideApp and nTypePath then
|
|
if sSideApp == 'hinge' or sSideApp == 'lock' then
|
|
if bFlipDoor then -- se porta ribaltata
|
|
if nTypePath == 1 then -- se percorso antisplint 1
|
|
EgtSetInfo( EntId, 'Mach', nMaxNum) -- eventualmente lo disabilito
|
|
return nMaxNum
|
|
else -- percorso antisplint 2
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
return 0
|
|
end
|
|
else -- non ribaltata
|
|
if nTypePath == 1 then -- se percorso antisplint 1
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
return 0
|
|
else -- percorso antisplint 2
|
|
EgtSetInfo( EntId, 'Mach', nMaxNum) -- eventualmente lo disabilito
|
|
return nMaxNum
|
|
end
|
|
end
|
|
else
|
|
if ( sSideApp == 'top' and nDispType > 0) or ( sSideApp == 'bottom' and nDispType < 0 ) then
|
|
if nTypePath == 1 then -- se percorso lato hinge
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
return 0
|
|
else -- se percorso lato lock
|
|
EgtSetInfo( EntId, 'Mach', nMaxNum) -- eventualmente lo disabilito
|
|
return nMaxNum
|
|
end
|
|
else
|
|
if nTypePath == 1 then -- se percorso lato hinge
|
|
EgtSetInfo( EntId, 'Mach', nMaxNum) -- eventualmente lo disabilito
|
|
return nMaxNum
|
|
else -- se percorso lato lock
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
return 0
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
else
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
end
|
|
|
|
return 0
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Machining Functions ***
|
|
-----------------------------------------------------------------
|
|
-----------------------------------------------------------------
|
|
function MachiningBase.ModifyLiLoToExt()
|
|
|
|
-- leggo il parametro di lunghezza perpendicolare di ingresso
|
|
local dLenIniPerp = EgtGetMachiningParam( MCH_MP.LIPERP)
|
|
local sTuuid = EgtGetMachiningParam( MCH_MP.TUUID)
|
|
local sTool = EgtTdbGetToolFromUUID( sTuuid)
|
|
EgtTdbSetCurrTool( sTool)
|
|
local dDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
|
|
|
|
if dLenIniPerp then
|
|
if dLenIniPerp > 0 then
|
|
dLenIniPerp = -dLenIniPerp
|
|
else -- altrimenti è a 0
|
|
dLenIniPerp = -(dDiam*0.55)
|
|
end
|
|
else -- altrimenti lo calcolo dall'utensile
|
|
dLenIniPerp = -(dDiam*0.55)
|
|
end
|
|
|
|
-- cambio il lead-in a lineare
|
|
EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
|
|
|
|
-- setto a 0 l'allungamento iniziale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0.762)
|
|
|
|
-- setto a 0 la lunghezza tangente ingresso
|
|
EgtSetMachiningParam( MCH_MP.LITANG, 0)
|
|
|
|
-- setto il valore di distanza perpendicolare uscita come quella dell'ingresso
|
|
EgtSetMachiningParam( MCH_MP.LIPERP, dLenIniPerp)
|
|
|
|
-- setto a 0 l'elevazione iniziale
|
|
EgtSetMachiningParam( MCH_MP.LIELEV, 0)
|
|
|
|
-- setto a 0 l'inserimento correttore attacco
|
|
EgtSetMachiningParam( MCH_MP.LICOMPLEN , 0)
|
|
|
|
-- cambio il lead-out a lineare
|
|
EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR)
|
|
|
|
-- 2019/12/20 setto a -0.6 il valore di distanza perpendicolare
|
|
-- 2020/05/18 setto a 0 il valore di distanza perpendicolare
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
|
|
-- setto a 0 l'allungamento finale
|
|
-- EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
|
|
|
|
-- setto a 0 il valore tangente finale
|
|
EgtSetMachiningParam( MCH_MP.LOTANG, 0)
|
|
|
|
-- 2019/12/20 setto a 0 il valore di distanza perpendicolare
|
|
EgtSetMachiningParam( MCH_MP.LOPERP, 0)
|
|
-- setto il valore di distanza perpendicolare uscita come quella dell'ingresso
|
|
-- EgtSetMachiningParam( MCH_MP.LOPERP, dLenIniPerp)
|
|
|
|
-- setto a 0 l'elevazione
|
|
EgtSetMachiningParam( MCH_MP.LOELEV, 0)
|
|
|
|
-- setto a 0 l'inserimento correttore uscita
|
|
EgtSetMachiningParam( MCH_MP.LOCOMPLEN , 0)
|
|
|
|
-- disabilito eventuale oscillazione
|
|
EgtSetMachiningParam( MCH_MP.OSCENABLE, false)
|
|
|
|
-- setto a 0 la sovrapposizione 2019/12/20
|
|
EgtSetMachiningParam( MCH_MP.OVERL , 0)
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
function MachiningBase.ModifyLiLo( sLeadCode, bRevCode, sPathType, sToolUse, dCalcLead, dPercFeedVal, sDirType)
|
|
|
|
-- leggo il parametro di lunghezza perpendicolare di ingresso
|
|
local dLenIniPerp = EgtGetMachiningParam( MCH_MP.LIPERP)
|
|
-- leggo il parametro feed per moltiplicarlo con il fattore di riduzione per l'ingresso nel pieno
|
|
local dFeedVal = EgtGetMachiningParam( MCH_MP.FEED)
|
|
|
|
-- cambio il lead-in a lineare
|
|
EgtSetMachiningParam( MCH_MP.LEADINTYPE, MCH_MILL_LI.LINEAR)
|
|
|
|
if bRevCode and ( sLeadCode == '_NLI' or sLeadCode == '_NLO') then
|
|
if sPathType and sPathType == 'NR' and sToolUse then
|
|
-- setto a 0 l'allungamento iniziale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0)
|
|
-- cambio la feed di ingresso con la Feed ricalcolata con il parametro
|
|
EgtSetMachiningParam( MCH_MP.STARTFEED, (dFeedVal*dPercFeedVal))
|
|
else
|
|
if sDirType == 'INV' then
|
|
-- setto a 0 l'allungamento iniziale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0)
|
|
-- cambio la feed di ingresso con la Feed ricalcolata con il parametro
|
|
EgtSetMachiningParam( MCH_MP.STARTFEED, (dFeedVal*dPercFeedVal))
|
|
else
|
|
-- setto al valore l'allungamento iniziale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dCalcLead)
|
|
end
|
|
end
|
|
elseif ( not bRevCode and sLeadCode == '_NLO') then
|
|
if sPathType and sPathType == 'NR' and sToolUse then
|
|
-- setto a 0 l'allungamento iniziale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0)
|
|
-- cambio la feed di ingresso con la Feed ricalcolata con il parametro
|
|
EgtSetMachiningParam( MCH_MP.STARTFEED, (dFeedVal*dPercFeedVal))
|
|
else
|
|
-- setto al valore l'allungamento iniziale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dCalcLead)
|
|
end
|
|
elseif ( not bRevCode and sLeadCode == '_NLI') then
|
|
if sDirType == 'INV' then
|
|
-- setto al valore l'allungamento iniziale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dCalcLead)
|
|
else
|
|
-- setto a 0 l'allungamento iniziale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0)
|
|
-- cambio la feed di ingresso con la Feed ricalcolata con il parametro
|
|
EgtSetMachiningParam( MCH_MP.STARTFEED, (dFeedVal*dPercFeedVal))
|
|
end
|
|
else
|
|
-- setto a 0 l'allungamento iniziale
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, 0)
|
|
-- cambio la feed di ingresso con la Feed ricalcolata con il parametro
|
|
EgtSetMachiningParam( MCH_MP.STARTFEED, (dFeedVal*dPercFeedVal))
|
|
end
|
|
|
|
-- setto a 0 la lunghezza tangente ingresso
|
|
EgtSetMachiningParam( MCH_MP.LITANG, 0)
|
|
-- cambio il lead-out a lineare
|
|
EgtSetMachiningParam( MCH_MP.LEADOUTTYPE, MCH_MILL_LI.LINEAR)
|
|
|
|
if ( bRevCode and sLeadCode == '_NLO') then -- Se percorso REV con niente uscita
|
|
if sPathType and sPathType == 'NR' then -- se percorso di andata
|
|
-- setto al valore l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dCalcLead)
|
|
else
|
|
-- setto a 0 l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
|
|
end
|
|
elseif ( bRevCode and sLeadCode == '_NLI') then -- Se percorso REV con niente ingresso
|
|
if sPathType and sPathType == 'NR' then -- se percorso di andata
|
|
if sDirType == 'INV' then
|
|
-- setto al valore l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dCalcLead)
|
|
else
|
|
-- setto a 0 l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
|
|
end
|
|
else
|
|
-- setto al valore l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dCalcLead)
|
|
end
|
|
elseif ( not bRevCode and sLeadCode == '_NLI') then
|
|
if sPathType and sPathType == 'NR' and sToolUse then
|
|
-- setto a 0 l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
|
|
else
|
|
if sDirType == 'INV' then
|
|
-- setto a 0 l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
|
|
else
|
|
-- setto al valore l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dCalcLead)
|
|
end
|
|
end
|
|
elseif ( not bRevCode and sLeadCode == '_NLO') then
|
|
if sPathType and sPathType == 'NR' and sToolUse then
|
|
-- setto al valore l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dCalcLead)
|
|
else
|
|
-- setto a 0 l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
|
|
end
|
|
else
|
|
-- setto a 0 l'allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, 0)
|
|
end
|
|
|
|
-- setto a 0 il valore tangente finale
|
|
EgtSetMachiningParam( MCH_MP.LOTANG, 0)
|
|
-- setto il valore di distanza perpendicolare uscita come quella dell'ingresso
|
|
EgtSetMachiningParam( MCH_MP.LOPERP, dLenIniPerp)
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
function MachiningBase.AddAndDelMachining( sName, sMach, tEntId, dOverL, sOriName,
|
|
bNotGenMachining, sCodeKeepBackSet, dBladePerpLeadIn, dPercRedFeed, sCodeProbeSide,
|
|
sActiveStop, sSetMaxElev, dOverR, bSandFound, dAddLength,
|
|
dAddSandLength, bNarrowDoor)
|
|
local sEntId = ''
|
|
local tParentId = {}
|
|
local sNotesMach
|
|
local nCheckLink
|
|
for t = 1, #tEntId do
|
|
if tEntId[t] then
|
|
if not bNotGenMachining then
|
|
-- load the Link value if exists
|
|
if not nCheckLink or nCheckLink == 0 then
|
|
nCheckLink = EgtGetInfo( tEntId[t], 'LinkCode', 'i') or 0
|
|
end
|
|
-- acquisisco le note Parent delle entità
|
|
table.insert( tParentId, EgtGetInfo( tEntId[t], 'Parent', 'i'))
|
|
end
|
|
sEntId = sEntId .. tEntId[t] .. ','
|
|
end
|
|
end
|
|
if not sMach or ( sMach and #sMach == 0) then
|
|
DGD.ERM = DGD.ERM .. string.format( EgtDoorsMsg[483], sOriName, sEntId)
|
|
return 0 -- nome lavorazione vuoto
|
|
end
|
|
local nMach = EgtAddMachining( sName, sMach)
|
|
local sTool
|
|
if not nMach then
|
|
DGD.EMC = DGD.EMC .. '\n' .. string.format( EgtDoorsMsg[484], sMach, sOriName, sEntId)
|
|
return -1 -- lavorazione mancante o errata
|
|
end
|
|
if dOverL then -- se c'è un valore, assegno sovramateriale in lunghezza
|
|
EgtSetMachiningParam( MCH_MP.OFFSL, dOverL)
|
|
end
|
|
if dOverR and dOverR > 0 then -- se c'è un valore, assegno offset sul raggio
|
|
EgtSetMachiningParam( MCH_MP.OFFSR, dOverR)
|
|
end
|
|
if sCodeKeepBackSet then -- se c'è un valore, assegno codice correzione in Z
|
|
sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
if not sNotesMach or #sNotesMach == 0 then -- se la nota è vuota aggiungo il codice
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sCodeKeepBackSet..';')
|
|
else -- altrimenti se non è vuota verifico se c'è o no
|
|
-- verifico se c'é già parte iniziale del codice 'CORR_Z_PROBE' settato nel Machining_xvx nella funzione InsertMachiningByMachNum
|
|
local sFirst = string.sub( sCodeKeepBackSet, 1, 12)
|
|
local nPosFind, _ = sNotesMach:find( sFirst, 1, true)
|
|
if nPosFind then -- se ho già la prima parte
|
|
if not sNotesMach:find( sCodeKeepBackSet, 1, true) then -- se non ho la stessa nota la sostituisco
|
|
sNotesMach = string.gsub( sNotesMach, string.sub( sNotesMach, nPosFind, 14), sCodeKeepBackSet)
|
|
end
|
|
else -- se non ho la prima parte la aggiungo
|
|
sNotesMach = sNotesMach..sCodeKeepBackSet..';'
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesMach)
|
|
end
|
|
end
|
|
end
|
|
if sCodeProbeSide then
|
|
sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
if not sNotesMach or #sNotesMach == 0 then -- se la nota è vuota aggiungo il codice
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sCodeProbeSide..';')
|
|
else -- altrimenti se non è vuota verifico se c'è o no
|
|
-- verifico se c'é già parte iniziale del codice 'CPBP' settato nel Machining_xvx nella funzione InsertMachiningByMachNum
|
|
local sFirst = string.sub( sCodeProbeSide, 1, 4)
|
|
local nPosFind, _ = sNotesMach:find( sFirst, 1, true)
|
|
if nPosFind then -- se ho già la prima parte
|
|
if not sNotesMach:find( sCodeProbeSide, 1, true) then -- se non ho la stessa nota la sostituisco
|
|
sNotesMach = string.gsub( sNotesMach, string.sub( sNotesMach, nPosFind, 4), sCodeProbeSide)
|
|
end
|
|
else -- se non ho la prima parte la aggiungo
|
|
sNotesMach = sNotesMach..sCodeProbeSide..';'
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesMach)
|
|
end
|
|
end
|
|
end
|
|
if sActiveStop then
|
|
sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
if not sNotesMach or #sNotesMach == 0 then -- se la nota è vuota aggiungo il codice
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sActiveStop..';')
|
|
else -- altrimenti se non è vuota verifico se c'è o no
|
|
-- verifico se c'é già parte iniziale del codice 'ActiveStopMach' settato nel Machining_xvx nella funzione InsertMachiningByMachNum
|
|
local sFirst = string.sub( sActiveStop, 1, 14)
|
|
local nPosFind, _ = sNotesMach:find( sFirst, 1, true)
|
|
if nPosFind then -- se ho già la prima parte
|
|
if not sNotesMach:find( sActiveStop, 1, true) then -- se non ho la stessa nota la sostituisco
|
|
sNotesMach = string.gsub( sNotesMach, string.sub( sNotesMach, nPosFind, 16), sActiveStop)
|
|
end
|
|
else -- se non ho la prima parte la aggiungo
|
|
sNotesMach = sNotesMach..sActiveStop..';'
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesMach)
|
|
end
|
|
end
|
|
end
|
|
if sSetMaxElev then
|
|
sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
if not sNotesMach or #sNotesMach == 0 then -- se la nota è vuota aggiungo il codice
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sSetMaxElev..';')
|
|
else -- altrimenti se non è vuota verifico se c'è o no
|
|
-- verifico se c'é già parte iniziale del codice 'MaxElev' settato nel Machining_xvx nella funzione InsertMachiningByMachNum
|
|
local sFirst = string.sub( sSetMaxElev, 1, 7)
|
|
local nPosFind, _ = sNotesMach:find( sFirst, 1, true)
|
|
if nPosFind then -- se ho già la prima parte
|
|
if not sNotesMach:find( sSetMaxElev, 1, true) then -- se non ho la stessa nota la sostituisco
|
|
sNotesMach = string.gsub( sNotesMach, string.sub( sNotesMach, nPosFind, 11), sSetMaxElev)
|
|
end
|
|
else -- se non ho la prima parte la aggiungo
|
|
sNotesMach = sNotesMach..sSetMaxElev..';'
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesMach)
|
|
end
|
|
end
|
|
end
|
|
if bSandFound and dAddLength and dAddLength > 0 then
|
|
sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
if sNotesMach and #sNotesMach > 0 then -- se la nota non è vuota cerco la lavorazione di profilatura
|
|
local sProfFind_LK, _ = sNotesMach:find( 'TRIM_LK', 1, true)
|
|
local sProfFind, _ = sNotesMach:find( 'TRIM_', 1, true)
|
|
local sProfAdded, _ = sNotesMach:find( 'ADD_EXTENDED', 1, true)
|
|
-- se trovata lavorazione trim e non è stata ancora allungata (nella parte finale)
|
|
if sProfFind and not sProfAdded then
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesMach .. 'ADD_EXTENDED'..';')
|
|
-- applico l'allungamento se non è percorso lock e non è una porta stretta
|
|
if not (sProfFind_LK and bNarrowDoor) then
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, dAddLength)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
if bSandFound and dAddSandLength and dAddSandLength > 0 then
|
|
sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
if sNotesMach and #sNotesMach > 0 then -- se la nota non è vuota cerco la lavorazione di profilatura
|
|
local sSandFind, _ = sNotesMach:find( 'SAND_', 1, true)
|
|
local sProfAdded, _ = sNotesMach:find( 'ADD_EXTENDED', 1, true)
|
|
-- se trovata lavorazione sand e non è stata ancora allungata (nella parte iniziale)
|
|
if sSandFind and not sProfAdded then
|
|
EgtSetMachiningParam( MCH_MP.USERNOTES, sNotesMach .. 'ADD_EXTENDED'..';')
|
|
EgtSetMachiningParam( MCH_MP.STARTADDLEN, dAddSandLength)
|
|
end
|
|
end
|
|
end
|
|
|
|
local bSetMach = EgtSetMachiningGeometry( tEntId)
|
|
-- se creo effettivamente la lavorazione controllo se ho le note per la modifica degli attacchi
|
|
if not bNotGenMachining then
|
|
sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
for t = 1, #tEntId do
|
|
if tEntId[t] then
|
|
local sPathType = EgtGetInfo( tEntId[t], 'PathType', 's')
|
|
local sToolUse = EgtGetInfo( tEntId[t], 'ToolsUse', 's')
|
|
local sTypeLead = EgtGetInfo( tEntId[t], 'LeadType', 's')
|
|
local sInvDir = EgtGetInfo( tEntId[t], 'InvDir', 's')
|
|
local nDirType = EgtGetInfo( tEntId[t], 'RevMach', 'i')
|
|
local nStFromExt = EgtGetInfo( tEntId[t], 'StartFromExt', 'i')
|
|
|
|
if nDirType and sPathType and sPathType == 'NR' and not sToolUse then -- se percorso REV singolo
|
|
-- leggo il lato di lavoro
|
|
-- local nWorkSide = EgtGetMachiningParam( MCH_MP.WORKSIDE)
|
|
-- if nWorkSide and nWorkSide == MCH_MILL_WS.LEFT then -- se lato sinistro
|
|
-- EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
|
|
-- elseif nWorkSide and nWorkSide == MCH_MILL_WS.RIGHT then -- se lato destro
|
|
-- EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
|
|
-- end
|
|
--inverto il percorso di lavoro
|
|
EgtSetMachiningParam( MCH_MP.INVERT, true)
|
|
end
|
|
|
|
if sTypeLead then -- se ho una nota di lead-in/out
|
|
MachiningBase.ModifyLiLo( sTypeLead, nDirType, sPathType, sToolUse, dBladePerpLeadIn, dPercRedFeed, sInvDir)
|
|
end
|
|
if nStFromExt then -- se ho una nota di lead-in/out dall'esterno
|
|
MachiningBase.ModifyLiLoToExt()
|
|
end
|
|
-- fermo il ciclo
|
|
break
|
|
end
|
|
end
|
|
-- se lavorazione ha le note opportune,
|
|
-- rifaccio il ciclo sulle entità/lavorazione per applicare la riduzione della lunghezza lavorata
|
|
if string.find( sNotesMach, 'HALF_LENGTH') then
|
|
for t = 1, #tEntId do
|
|
if tEntId[t] then
|
|
local dPathLen = EgtCurveLength( tEntId[t]) or 0.0
|
|
if dPathLen > 0 then -- se nelle note trovata la nota di ridurre il percorso
|
|
-- setto il valore di riduzione allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, -(( dPathLen/2)-1))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
local nPosFound = string.find( sNotesMach, 'CUT_LENGTH')
|
|
if nPosFound then
|
|
local sParz = string.sub( sNotesMach, nPosFound)
|
|
nPosFound = string.find( sParz, ';')
|
|
local sTrimmed
|
|
if nPosFound then
|
|
sTrimmed = string.sub( sParz, 1, nPosFound-1)
|
|
else
|
|
sTrimmed = sParz
|
|
end
|
|
if sTrimmed and #sTrimmed > 0 then
|
|
local sValue = string.sub( sTrimmed, 12)
|
|
if sValue and #sTrimmed > 0 then
|
|
local dVal = tonumber( sValue)
|
|
if dVal and abs(dVal) > GEO.EPS_SMALL then
|
|
for t = 1, #tEntId do
|
|
if tEntId[t] then
|
|
local dPathLen = EgtCurveLength( tEntId[t]) or 0.0
|
|
if dPathLen > 0 then -- se nelle note trovata la nota di ridurre il percorso
|
|
-- setto il valore di riduzione allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, -( dPathLen - abs(dVal)))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- se non genero la lavorazione leggo comunque le note
|
|
else
|
|
sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
end
|
|
local bApplyMach = EgtApplyMachining()
|
|
if not bNotGenMachining and ( not bSetMach or not bApplyMach) then
|
|
if not bSetMach or not bApplyMach then
|
|
local nIdErr, sIdErr = EgtGetLastMachMgrError()
|
|
DGD.EMC = DGD.EMC .. '\n' .. string.format( EgtDoorsMsg[598], sMach, sOriName, sEntId, nIdErr, sIdErr)
|
|
else
|
|
DGD.EMC = DGD.EMC .. '\n' .. string.format( EgtDoorsMsg[485], sMach, sOriName, sEntId)
|
|
end
|
|
return -1
|
|
end
|
|
if bNotGenMachining then
|
|
EgtRemoveOperation( nMach)
|
|
-- ripristino ultima lavorazione rimasta
|
|
local nOper = EgtGetLastActiveOperation() or GDB_ID.NULL
|
|
local nType = EgtGetOperationType( nOper)
|
|
if nType ~= MCH_OY.NONE and nType ~= MCH_OY.DISP then
|
|
EgtSetCurrMachining( nOper)
|
|
EgtApplyMachining()
|
|
end
|
|
nMach = nil
|
|
else
|
|
sTool = EgtGetMachiningParam( MCH_MP.TOOL )
|
|
-- if link value different than 0 write info to machining
|
|
if abs(nCheckLink) > 0 then
|
|
EgtSetInfo( nMach, 'Link', nCheckLink)
|
|
if #tParentId > 0 and tParentId[1] then
|
|
EgtSetInfo( nMach, 'Parent', tParentId[1])
|
|
end
|
|
-- if link value is negative disable the machining
|
|
if nCheckLink < 0 then
|
|
EgtSetOperationMode( nMach, false)
|
|
end
|
|
end
|
|
-- sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
end
|
|
return 1, nMach, sTool, sNotesMach
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AddMachining( sName, sMach, tEntId, dOverL, sOriName)
|
|
local sEntId = ''
|
|
local sNotesMach
|
|
for t = 1, #tEntId do
|
|
sEntId = sEntId .. tEntId[t] .. ','
|
|
end
|
|
if not sMach or ( sMach and #sMach == 0) then
|
|
DGD.ERM = DGD.ERM .. string.format( EgtDoorsMsg[483], sOriName, sEntId)
|
|
return true
|
|
end
|
|
local nMach = EgtAddMachining( sName, sMach)
|
|
if not nMach then
|
|
DGD.EMC = DGD.EMC .. '\n' .. string.format( EgtDoorsMsg[484], sMach, sOriName, sEntId)
|
|
return false
|
|
end
|
|
if dOverL then
|
|
EgtSetMachiningParam( MCH_MP.OFFSL, dOverL)
|
|
end
|
|
if not EgtSetMachiningGeometry( tEntId) or not EgtApplyMachining() then
|
|
local nIdErr, sIdErr = EgtGetLastMachMgrError()
|
|
DGD.EMC = DGD.EMC .. '\n' .. string.format( EgtDoorsMsg[598], sMach, sOriName, sEntId, nIdErr, sIdErr)
|
|
return false
|
|
end
|
|
-- ottengo le note lavorazione
|
|
sNotesMach = EgtGetMachiningParam( MCH_MP.USERNOTES)
|
|
if string.find( sNotesMach, 'HALF_LENGTH') then
|
|
for t = 1, #tEntId do
|
|
if tEntId[t] then
|
|
local dPathLen = EgtCurveLength( tEntId[t]) or 0.0
|
|
if dPathLen > 0 then -- se nelle note trovata la nota di ridurre il percorso
|
|
-- setto il valore di riduzione allungamento finale
|
|
EgtSetMachiningParam( MCH_MP.ENDADDLEN, -(( dPathLen/2)-1))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.MakeRoughPaths ( dSideOverMat, dMaxOverMat, dStepOverMat, nIdEnt, bTopBottPart, bFlip, bAlreadyMachSide, dBevelOffs, nScrapMode)
|
|
|
|
local bMadeMach = bAlreadyMachSide
|
|
|
|
if not bAlreadyMachSide and dMaxOverMat and dSideOverMat > dMaxOverMat then
|
|
|
|
-- creo passate di sgrossatura
|
|
local nHorStep = ceil(dSideOverMat / dStepOverMat)
|
|
-- se modalità remove scrap abilitata setto una sola passata
|
|
if nScrapMode and nScrapMode == 1 then
|
|
nHorStep = 1
|
|
end
|
|
local dHorStep = dStepOverMat
|
|
local nPassHor = 1
|
|
local nSideOffs = EgtIf( bFlip, -1, 1)
|
|
local nNumEnt1, nNumEnt2 = EgtCurveDomain( nIdEnt)
|
|
local bSimpleLine = (nNumEnt2 - nNumEnt1) == 1
|
|
local pIni = EgtSP( nIdEnt)
|
|
local pMid = EgtMP( nIdEnt)
|
|
local pEnd = EgtEP( nIdEnt)
|
|
local nParId = EgtGetParent(nIdEnt)
|
|
local dOffsBevel = 0
|
|
if dBevelOffs and dBevelOffs > 0 then -- se profilo bevel
|
|
dOffsBevel = dBevelOffs * nSideOffs
|
|
end
|
|
|
|
while nPassHor <= nHorStep do
|
|
|
|
local nLine
|
|
if bSimpleLine then
|
|
nLine = EgtArc3P( nParId, pIni, pMid, pEnd, GDB_RT.LOC)
|
|
else -- faccio la copia del percorso
|
|
nLine = EgtCopy( nIdEnt, nParId, GDB_RT.LOC)
|
|
EgtModifyCurveExtrusion( nLine, Z_AX(), GDB_RT.LOC)
|
|
end
|
|
|
|
EgtOffsetCurve( nLine, ( dOffsBevel + ( dHorStep * ( nPassHor-1) * nSideOffs)))
|
|
EgtModifyCurveExtrusion( nLine, Z_AX(), GDB_RT.GLOB)
|
|
|
|
if nLine then
|
|
bMadeMach = true
|
|
|
|
if bTopBottPart then
|
|
EgtSetName( nLine, 'ROUGH_H_' .. EgtNumToString(nPassHor,0))
|
|
else
|
|
EgtSetName( nLine, 'ROUGH_' .. EgtNumToString(nPassHor,0))
|
|
end
|
|
end
|
|
|
|
nPassHor = nPassHor + 1
|
|
end -- end while
|
|
end
|
|
|
|
return bMadeMach
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Adjust Geometries Functions (Operations) ***
|
|
-----------------------------------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustBevel( EntId, EntName, bFirstStep, bNoVertCurve, bMakeGhostGeom, bNoModifyPath, bSkipOnSecCol)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- recupero flag di lavorazione
|
|
local nLocMach = EgtGetInfo( EntId, 'Mach', 'i') or 1
|
|
local sNewName = EntName
|
|
-- se diretto verso il basso
|
|
if vtExtr:getZ() < 0 then
|
|
-- sposto la curva, inverto l'estrusione
|
|
local dTh = EgtCurveThickness( EntId)
|
|
-- sposto la curva in basso lungo il versore
|
|
EgtMove( EntId, vtExtr * dTh, GDB_RT.GLOB)
|
|
if not bNoVertCurve then
|
|
if not bNoModifyPath then
|
|
-- rendo l'estrusione verticale e aggiusto lo spessore di conseguenza
|
|
EgtModifyCurveThickness( EntId, - dTh * vtExtr:getZ())
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
end
|
|
else
|
|
-- sistemo l'estrusione e aggiusto lo spessore di conseguenza
|
|
EgtModifyCurveThickness( EntId, dTh)
|
|
EgtModifyCurveExtrusion( EntId, -vtExtr, GDB_RT.GLOB)
|
|
end
|
|
-- inverto la curva
|
|
EgtInvertCurve( EntId)
|
|
|
|
-- cambio il nome
|
|
if EntName == 'BU' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BD'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BD')
|
|
end
|
|
sNewName = 'BD'
|
|
elseif EntName == 'BU_H' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BD_H'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BD_H')
|
|
end
|
|
sNewName = 'BD'
|
|
elseif EntName == 'BU_LK' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BD_LK'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BD_LK')
|
|
end
|
|
sNewName = 'BD'
|
|
elseif EntName == 'BD' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BU'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BU')
|
|
end
|
|
sNewName = 'BU'
|
|
elseif EntName == 'BD_H' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BU_H'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BU_H')
|
|
end
|
|
sNewName = 'BU'
|
|
elseif EntName == 'BD_LK' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BU_LK'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BU_LK')
|
|
end
|
|
sNewName = 'BU'
|
|
elseif EntName then
|
|
if string.find( EntName, 'BU_Mach') then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, string.gsub( EntName, 'BU_Mach', 'BD'..DGD.GHT..'_Mach'))
|
|
else
|
|
EgtSetName( EntId, string.gsub( EntName, 'BU_Mach', 'BD_Mach'))
|
|
end
|
|
sNewName = 'BD'
|
|
elseif string.find( EntName,'BUEB') then -- bevel con edge break lato serratura
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, string.gsub( EntName, 'BUEB', 'BDEB') .. DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, string.gsub( EntName, 'BUEB', 'BDEB'))
|
|
end
|
|
sNewName = 'BD'
|
|
elseif string.find( EntName, 'BD_Mach') then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, string.gsub( EntName, 'BD_Mach', 'BU'..DGD.GHT..'_Mach'))
|
|
else
|
|
EgtSetName( EntId, string.gsub( EntName, 'BD_Mach', 'BU_Mach'))
|
|
end
|
|
sNewName = 'BU'
|
|
elseif string.find( EntName,'BDEB') then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, string.gsub( EntName, 'BDEB', 'BUEB') .. DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, string.gsub( EntName, 'BDEB', 'BUEB'))
|
|
end
|
|
sNewName = 'BU'
|
|
end
|
|
end
|
|
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
if nLocMach >= 10 then
|
|
nLocMach = nLocMach - 10
|
|
elseif nLocMach > 0 then -- se è una che non avevo escluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
else
|
|
-- se devo utilizzare seconda colonna
|
|
if bSkipOnSecCol then
|
|
-- nota seconda colonna
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
end
|
|
end
|
|
else
|
|
|
|
if not bNoVertCurve and not bNoModifyPath then
|
|
-- rendo l'estrusione verticale e aggiusto lo spessore di conseguenza
|
|
local dTh = EgtCurveThickness( EntId)
|
|
EgtModifyCurveThickness( EntId, dTh * vtExtr:getZ())
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
end
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
if nLocMach >= 10 then
|
|
nLocMach = nLocMach - 10
|
|
elseif nLocMach > 0 then -- se è una che non avevo scluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
else
|
|
-- se devo utilizzare seconda colonna
|
|
if bSkipOnSecCol then
|
|
-- nota seconda colonna
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
end
|
|
end
|
|
end
|
|
return true, sNewName, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustConeCleanPaths( EntId, bMakeGhostGeom, bKeepDir, nSolidLayer)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- se diretto verso il basso
|
|
if vtExtr:getZ() < 0 then
|
|
-- prendo il punto medio in Z dall'id del solido passato o dalla geometria stessa
|
|
local b3Solid
|
|
if not nSolidLayer then
|
|
b3Solid = EgtGetBBoxGlob( EntId, GDB_BB.STANDARD)
|
|
else
|
|
b3Solid = EgtGetBBoxGlob( nSolidLayer, GDB_BB.STANDARD)
|
|
end
|
|
local ptMidZ = ( b3Solid:getMin():getZ() + b3Solid:getMax():getZ()) /2
|
|
EgtMirror( EntId, Point3d(0,0,ptMidZ), Z_AX(), GDB_ID.ROOT) -- faccio il mirror su asse Z
|
|
end
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustThrouCurve( EntId, bMakeGhostGeom, bKeepDir, bKeepDirZPos, bSkipOnSecCol)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- se diretto verso il basso
|
|
if vtExtr:getZ() < 0 then
|
|
local dTh = EgtCurveThickness( EntId)
|
|
EgtMove( EntId, vtExtr * dTh, GDB_RT.GLOB)
|
|
EgtModifyCurveThickness( EntId, - dTh * vtExtr:getZ())
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
if not bKeepDir then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
else
|
|
if bKeepDirZPos then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
end
|
|
|
|
-- se devo utilizzare seconda colonna
|
|
if bSkipOnSecCol then
|
|
-- nota seconda colonna
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
else
|
|
-- nessuna nota
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
end
|
|
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjPrfThrouCurveNew( EntId, bMakeGhostGeom, bFoundProperty, bNoVertCurve, bFirstStep, EntName)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
local sNewName = EntName
|
|
-- se diretto verso il basso
|
|
if vtExtr:getZ() < 0 then
|
|
-- sposto la curva, inverto l'estrusione
|
|
local dTh = EgtCurveThickness( EntId)
|
|
-- sposto la curva in basso lungo il versore
|
|
EgtMove( EntId, vtExtr * dTh, GDB_RT.GLOB)
|
|
if not bNoVertCurve then
|
|
-- rendo l'estrusione verticale e aggiusto lo spessore di conseguenza
|
|
EgtModifyCurveThickness( EntId, - dTh * vtExtr:getZ())
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
else
|
|
-- sistemo l'estrusione e aggiusto lo spessore di conseguenza
|
|
EgtModifyCurveThickness( EntId, dTh)
|
|
EgtModifyCurveExtrusion( EntId, -vtExtr, GDB_RT.GLOB)
|
|
end
|
|
-- inverto la curva
|
|
EgtInvertCurve( EntId)
|
|
|
|
-- cambio il nome
|
|
if EntName == 'BU' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BD'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BD')
|
|
end
|
|
sNewName = 'BD'
|
|
elseif EntName == 'BD' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BU'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BU')
|
|
end
|
|
sNewName = 'BU'
|
|
elseif EntName then
|
|
if string.find( EntName, 'BU_Mach') then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, string.gsub( EntName, 'BU_Mach', 'BD'..DGD.GHT..'_Mach'))
|
|
else
|
|
EgtSetName( EntId, string.gsub( EntName, 'BU_Mach', 'BD_Mach'))
|
|
end
|
|
sNewName = 'BD'
|
|
elseif string.find( EntName, 'BD_Mach') then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, string.gsub( EntName, 'BD_Mach', 'BU'..DGD.GHT..'_Mach'))
|
|
else
|
|
EgtSetName( EntId, string.gsub( EntName, 'BD_Mach', 'BU_Mach'))
|
|
end
|
|
sNewName = 'BU'
|
|
end
|
|
end
|
|
else -- se diretto verso l'alto
|
|
|
|
if not bNoVertCurve then
|
|
-- rendo l'estrusione verticale e aggiusto lo spessore di conseguenza
|
|
local dTh = EgtCurveThickness( EntId)
|
|
EgtModifyCurveThickness( EntId, dTh * vtExtr:getZ())
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
end
|
|
end
|
|
-- cerco se nella tabella c'è la chiave find, se c'è assegno la nota mach a 2
|
|
-- disabilito la ricerca perché ho già passato la variabile che indica se è stata trovata la proprietà
|
|
local bMatchProp = bFoundProperty
|
|
|
|
-- se ho trovato corrispondenza di proprietà
|
|
if bMatchProp then
|
|
-- nota seconda colonna
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
else
|
|
-- nessuna nota
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
end
|
|
|
|
return true, EntId, sNewName
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjPrfThrouCurve( EntId, bMakeGhostGeom, tsProperties, sFind, bNoVertCurve, bFirstStep, EntName)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
local sNewName = EntName
|
|
-- se diretto verso il basso
|
|
if vtExtr:getZ() < 0 then
|
|
-- sposto la curva, inverto l'estrusione
|
|
local dTh = EgtCurveThickness( EntId)
|
|
-- sposto la curva in basso lungo il versore
|
|
EgtMove( EntId, vtExtr * dTh, GDB_RT.GLOB)
|
|
if not bNoVertCurve then
|
|
-- rendo l'estrusione verticale e aggiusto lo spessore di conseguenza
|
|
EgtModifyCurveThickness( EntId, - dTh * vtExtr:getZ())
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
else
|
|
-- sistemo l'estrusione e aggiusto lo spessore di conseguenza
|
|
EgtModifyCurveThickness( EntId, dTh)
|
|
EgtModifyCurveExtrusion( EntId, -vtExtr, GDB_RT.GLOB)
|
|
end
|
|
-- inverto la curva
|
|
EgtInvertCurve( EntId)
|
|
|
|
-- cambio il nome
|
|
if EntName == 'BU' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BD'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BD')
|
|
end
|
|
sNewName = 'BD'
|
|
elseif EntName == 'BD' then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, 'BU'..DGD.GHT)
|
|
else
|
|
EgtSetName( EntId, 'BU')
|
|
end
|
|
sNewName = 'BU'
|
|
elseif EntName then
|
|
if string.find( EntName, 'BU_Mach') then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, string.gsub( EntName, 'BU_Mach', 'BD'..DGD.GHT..'_Mach'))
|
|
else
|
|
EgtSetName( EntId, string.gsub( EntName, 'BU_Mach', 'BD_Mach'))
|
|
end
|
|
sNewName = 'BD'
|
|
elseif string.find( EntName, 'BD_Mach') then
|
|
if bMakeGhostGeom or not bFirstStep then
|
|
EgtSetName( EntId, string.gsub( EntName, 'BD_Mach', 'BU'..DGD.GHT..'_Mach'))
|
|
else
|
|
EgtSetName( EntId, string.gsub( EntName, 'BD_Mach', 'BU_Mach'))
|
|
end
|
|
sNewName = 'BU'
|
|
end
|
|
end
|
|
else -- se diretto verso l'alto
|
|
|
|
if not bNoVertCurve then
|
|
-- rendo l'estrusione verticale e aggiusto lo spessore di conseguenza
|
|
local dTh = EgtCurveThickness( EntId)
|
|
EgtModifyCurveThickness( EntId, dTh * vtExtr:getZ())
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
end
|
|
end
|
|
-- cerco se nella tabella c'è la chiave find, se c'è assegno la nota mach a 2
|
|
local bMatchProp = FindProperty( tsProperties, sFind)
|
|
|
|
-- se ho trovato corrispondenza di proprietà
|
|
if bMatchProp then
|
|
-- nota seconda colonna
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
else
|
|
-- nessuna nota
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
end
|
|
|
|
return true, EntId, sNewName
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustVertCurve( EntId, bMakeGhostGeom)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- se diretto verso il basso
|
|
if vtExtr:getZ() < 0 then
|
|
local dTh = EgtCurveThickness( EntId)
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
-- lavorazione 2nd
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
else
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
end
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustBladeVertCurve( EntId, bMakeGhostGeom)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- se diretto verso il basso
|
|
if vtExtr:getZ() < 0 then
|
|
local dTh = EgtCurveThickness( EntId)
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
local sPathInfo = EgtGetInfo( EntId, 'PathType', 's')
|
|
local sToolsUse = EgtGetInfo( EntId, 'ToolsUse', 's')
|
|
if sPathInfo and sPathInfo == 'NR' and not sToolsUse then -- se percorso singolo genero prima colonna
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
else
|
|
-- lavorazione 2nd
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
end
|
|
-- setto una nota aggiuntiva del parametro mach
|
|
EgtSetInfo( EntId, 'RevMach', 1)
|
|
else
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
end
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustASplintWithBlade( EntId, bMakeGhostGeom, nDispType, bFlipDoor)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
MachiningBase.DefineASplint( EntId, nDispType, bFlipDoor, 2)
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustThrouIsle( EntId, DimZ, ptMin, ptMax, nNumMachSkip, bFirstStep, bWorkUnder, bMakeGhostGeom, dExtraThruDepth)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- contatore disabilitazione lavorazione
|
|
local nNumSkip = nNumMachSkip
|
|
-- recupero spessore e verifico se passante
|
|
local dTh = EgtCurveThickness( EntId)
|
|
local bTrhu = ( abs( dTh) > DimZ - GEO.EPS_SMALL)
|
|
-- se passante, aggiunto affondamento
|
|
if bTrhu then
|
|
-- acquisisco nota per vedere se viene fatta da lama
|
|
local bBladeNote = EgtGetInfo( EntId, 'ByBlade', 'b') or false
|
|
local dOl = -2 -- valore in mm
|
|
if dExtraThruDepth then
|
|
dOl = -abs(dExtraThruDepth)
|
|
end
|
|
if not bBladeNote then -- assegno nota se non ha taglio di lama
|
|
EgtSetInfo( EntId, 'OL', dOl)
|
|
end
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- recupero flag di lavorazione
|
|
local nLocMach = EgtGetInfo( EntId, 'Mach', 'i') or 1
|
|
-- se versore fresa diretto come Z-,
|
|
if vtExtr:getZ() < 0 then
|
|
-- se passante, lo cambio in Z+
|
|
if bTrhu then
|
|
vtExtr = - vtExtr
|
|
local pIni = EgtSP( EntId, GDB_ID.ROOT)
|
|
if abs( pIni:getZ() - ptMin:getZ()) < GEO.EPS_SMALL then -- se geometria è sulla faccia sotto
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
|
|
-- leggo la nota Mach2nd che indica se l'entità è già stata lavorata
|
|
local nMach2nd = EgtGetInfo( EntId, 'Mach2nd', 'i') or 0
|
|
|
|
if nMach2nd == 0 then
|
|
if nLocMach >= 10 then
|
|
nLocMach = nLocMach - 10
|
|
elseif nLocMach > 0 then -- se è una che non avevo escluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
end
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
EgtMove( EntId, vtExtr * abs(dTh), GDB_RT.GLOB)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
end
|
|
elseif abs( pIni:getZ() - ptMax:getZ()) < GEO.EPS_SMALL then -- se geometria è sulla faccia sopra
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
|
|
-- leggo la nota Mach2nd che indica se l'entità è già stata lavorata
|
|
local nMach2nd = EgtGetInfo( EntId, 'Mach2nd', 'i') or 0
|
|
|
|
if nMach2nd == 0 then
|
|
if nLocMach >= 10 then
|
|
nLocMach = nLocMach - 10
|
|
elseif nLocMach > 0 then -- se è una che non avevo scluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
end
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
EgtMove( EntId, -vtExtr * abs(dTh), GDB_RT.GLOB)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
end
|
|
else -- altrimenti lo salto perché è in una Z diversa da sopra o sotto
|
|
EgtSetInfo( EntId, 'Mach', 0)
|
|
end
|
|
-- altrimenti lo salto
|
|
else
|
|
-- se non posso lavorare da sotto
|
|
if not bWorkUnder then
|
|
-- se non era ancora stato escluso, lo escludo sommando 10 al valore
|
|
if nLocMach < 10 then
|
|
nLocMach = nLocMach + 10
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
nNumSkip = nNumSkip + 1
|
|
else
|
|
nLocMach = 2
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
end
|
|
else
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
-- leggo la nota Mach2nd che indica se l'entità è già stata lavorata
|
|
local nMach2nd = EgtGetInfo( EntId, 'Mach2nd', 'i') or 0
|
|
if nMach2nd == 0 then
|
|
if nLocMach >= 10 then
|
|
if nLocMach <= 21 then
|
|
nLocMach = nLocMach - 10
|
|
end
|
|
elseif nLocMach > 0 then -- se è una che non avevo escluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
end
|
|
end
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
local vtMPlane, dDist, dArea
|
|
-- verifico se il percorso è chiuso
|
|
if EgtCurveIsClosed( EntId) then
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
if abs( dArea) < 1 then
|
|
-- verifico se il percroso ha la nota che identifica una doubleline cioè un percorso composto da due linee sovrapposte
|
|
if not ( EgtGetInfo( EntId, 'DoubleLine', 'i') == 1) then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
end
|
|
end
|
|
-- altrimenti è aperto
|
|
else
|
|
-- faccio una copia del percorso
|
|
local sParnt = EgtGetParent( EntId)
|
|
local nNewEntId = EgtCopyGlob( EntId, sParnt)
|
|
-- chiudo il percorso
|
|
if EgtCloseCurveCompo( nNewEntId) then
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
vtMPlane, dDist, dArea = EgtCurveArea( nNewEntId)
|
|
EgtErase(nNewEntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
-- verifico se il percorso originario è una curvecompo
|
|
if EgtGetType( EntId) == GDB_TY.CRV_COMPO then
|
|
local _, nLast = EgtCurveDomain( EntId)
|
|
-- se è composto da una sola entità
|
|
if nLast == 1 then
|
|
-- rifaccio la copia
|
|
nNewEntId = EgtCopyGlob( EntId, sParnt)
|
|
-- esplodo e verifico che sia una linea
|
|
local nLocalGeom, nLast = EgtExplodeCurveCompo( nNewEntId)
|
|
if nLocalGeom and ( nLast > 1 or EgtGetType( nLocalGeom) ~= GDB_TY.CRV_LINE) then
|
|
if nLast > 1 then
|
|
for i = 1, nLast do
|
|
EgtErase( nLocalGeom + i - 1)
|
|
end
|
|
else
|
|
EgtErase( nLocalGeom)
|
|
end
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
else
|
|
EgtErase( nLocalGeom)
|
|
return true, nNumSkip, EntId
|
|
end
|
|
else
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
end
|
|
elseif EgtGetType( EntId) == GDB_TY.CRV_LINE then
|
|
return true, nNumSkip, EntId
|
|
else
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
end
|
|
end
|
|
else
|
|
EgtErase(nNewEntId)
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
end
|
|
end
|
|
end
|
|
local frEnt = EgtGetGlobFrame( EntId)
|
|
if vtMPlane then
|
|
vtMPlane:toGlob(frEnt)
|
|
if nLocMach ~= 2 then
|
|
if dArea and dArea * ( vtMPlane * vtExtr) > 0 then
|
|
EgtInvertCurve( EntId)
|
|
-- cerco se ho la nota OPEN che definisce quale entità è quella aperta per le svuotature
|
|
local sNumOpen = EgtGetInfo( EntId, 'OPEN', 'i')
|
|
if sNumOpen then
|
|
if sNumOpen > 0 then
|
|
EgtSetInfo( EntId, 'OPEN', 0)
|
|
else
|
|
local nNumEnt1, nNumEnt2 = EgtCurveDomain( EntId)
|
|
if nNumEnt2 > 1 then
|
|
EgtSetInfo( nHint, 'OPEN', nNumEnt2-1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
else
|
|
if dArea and dArea * ( vtMPlane * vtExtr) < 0 then
|
|
EgtInvertCurve( EntId)
|
|
-- cerco se ho la nota OPEN che definisce quale entità è quella aperta per le svuotature
|
|
local sNumOpen = EgtGetInfo( EntId, 'OPEN', 'i')
|
|
if sNumOpen then
|
|
if sNumOpen > 0 then
|
|
EgtSetInfo( EntId, 'OPEN', 0)
|
|
else
|
|
local nNumEnt1, nNumEnt2 = EgtCurveDomain( EntId)
|
|
if nNumEnt2 > 1 then
|
|
EgtSetInfo( nHint, 'OPEN', nNumEnt2-1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
--[[
|
|
local dAreaXY = EgtCurveAreaXY( EntId)
|
|
if dAreaXY and abs( dAreaXY) < 1 then
|
|
-- provo con EgtCurveArea
|
|
local vtV1, dDist, dArea = EgtCurveArea( EntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
else
|
|
dAreaXY = dArea
|
|
end
|
|
end
|
|
local frEnt = EgtFR( EgtGetParent( EntId), GDB_ID.ROOT)
|
|
if nLocMach ~= 2 then
|
|
if dAreaXY and dAreaXY * frEnt:getVersZ():getZ() > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
else
|
|
if dAreaXY and dAreaXY * frEnt:getVersZ():getZ() < 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
end
|
|
]]--
|
|
end
|
|
return true, nNumSkip, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustHole( EntId, bMakeGhostGeom, bForceHorizontalDir)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
|
|
if bForceHorizontalDir then -- se c'è forzatura orizzontale
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
-- EgtSetInfo( EntId, 'OL', 0.16)
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
end
|
|
|
|
-- impongo senso di rotazione orario relativo alla normale del versore
|
|
if abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
local frEnt = EgtGetGlobFrame( EntId)
|
|
vtMPlane:toGlob(frEnt)
|
|
|
|
if dArea * ( vtMPlane * vtExtr) > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjPreHoleAndPocket( EntId, bMakeGhostGeom, tsProperties, tsFind, bFoundProperty)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
|
|
-- impongo senso di rotazione orario relativo alla normale del versore
|
|
if abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
local frEnt = EgtGetGlobFrame( EntId)
|
|
vtMPlane:toGlob(frEnt)
|
|
|
|
if dArea * ( vtMPlane * vtExtr) > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
-- cerco se nella tabella c'è la chiave find, se c'è assegno la nota mach a 2
|
|
local bMatchProp
|
|
if tsFind and tsProperties then
|
|
for g = 1, #tsFind do
|
|
for h = 1, #tsProperties do
|
|
if string.lower(tsProperties[h]) == string.lower(tsFind[g]) then
|
|
bMatchProp = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- verifico se la proprietà è già stata trovata (nuovo metodo),
|
|
-- è mutuamente esclusivo della ricerca nella tabella proprietà appena qua sopra
|
|
if bFoundProperty then
|
|
bMatchProp = true
|
|
end
|
|
|
|
-- se ho trovato corrispondenza di proprietà
|
|
if bMatchProp then
|
|
-- nota seconda colonna
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
else
|
|
-- nessuna nota
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
end
|
|
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustHead( EntId, nNumTopGeom, nNumBottomGeom, dPosShuttleChange, nForceUseShuttle)
|
|
-- controllo dalla nota se non è già stata lavorata prima
|
|
local nSetSide = EgtGetInfo( EntId, 'Mach', 'i') or 0
|
|
|
|
if nSetSide < 10 then
|
|
|
|
-- recupero il minimo e massimo valore in X e decido in base ai range dove metterlo
|
|
local b3Ent = EgtGetBBoxGlob( EntId, GDB_BB.STANDARD)
|
|
local dMin = b3Ent:getMin():getX()
|
|
local dMax = b3Ent:getMax():getX()
|
|
|
|
-- se ho forzato ad usare uno shuttle, setto a tutte le geometrie lo shuttle disponibile
|
|
if nForceUseShuttle and nForceUseShuttle > 0 then
|
|
if nForceUseShuttle == 1 then -- se forzo uso shuttle 1 (il valore assegnato a 3 è l'id della MTABLE)
|
|
nSetSide = 3 -- setto lower
|
|
nNumBottomGeom = nNumBottomGeom + 1
|
|
else -- altrimenti lo shuttle 2
|
|
nSetSide = 2 -- setto upper
|
|
nNumTopGeom = nNumTopGeom + 1
|
|
end
|
|
else
|
|
-- se il minimo geometria è tutto con lo shuttle superiore ( di destra)
|
|
if dMin >= dPosShuttleChange then
|
|
nSetSide = 2 -- setto upper
|
|
nNumTopGeom = nNumTopGeom + 1
|
|
else -- altrimenti sfora o è completamente nella parte dello shuttle inferiore ( di sinistra)
|
|
-- se il massimo è oltre il limite lo setto neutro
|
|
if dMax > dPosShuttleChange then
|
|
nSetSide = 0 -- setto neutro
|
|
else
|
|
nSetSide = 3 -- setto lower
|
|
nNumBottomGeom = nNumBottomGeom + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se neutro decido da che parte stare in base al numero delle rispettive parti
|
|
if nSetSide == 0 then
|
|
if nNumTopGeom == 0 then -- se shuttle alto senza assegnazioni lo assegno alto
|
|
nSetSide = 2
|
|
nNumTopGeom = nNumTopGeom + 1
|
|
else -- altrimenti shuttle alto ha già assegnazioni
|
|
if nNumBottomGeom == 0 then -- se shuttle basso senza assegnazioni lo assegno basso
|
|
nSetSide = 3 -- setto lower
|
|
nNumBottomGeom = nNumBottomGeom + 1
|
|
else -- altrimenti shuttle basso con già assegnazioni
|
|
-- confronto tra quale dei due ha più assegnazioni
|
|
if nNumBottomGeom >= nNumTopGeom then -- se shuttle basso ne ha uguali o di più lo assegno alto
|
|
nSetSide = 2
|
|
nNumTopGeom = nNumTopGeom + 1
|
|
else -- altrimenti shuttle basso ne ha di meno, assegno basso
|
|
nSetSide = 3 -- setto lower
|
|
nNumBottomGeom = nNumBottomGeom + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
EgtSetInfo( EntId, 'Mach', nSetSide)
|
|
end
|
|
|
|
return true, nNumTopGeom, nNumBottomGeom, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustHeadOnASplint( EntId, nNumTopGeom, nNumBottomGeom, dPosShuttleChange, nForceUseShuttle,
|
|
nDispType, bFlipDoor, nMaxMach)
|
|
|
|
-- controllo dalla nota se non è già stata lavorata prima
|
|
local nSetSide = EgtGetInfo( EntId, 'Mach', 'i') or 0
|
|
|
|
if nSetSide < 10 then
|
|
|
|
-- verifico se è possibile lavorarla
|
|
nSetSide = MachiningBase.DefineASplint( EntId, nDispType, bFlipDoor, nMaxMach)
|
|
|
|
if nSetSide < 4 then
|
|
|
|
nSetSide = 0
|
|
-- recupero il minimo e massimo valore in X e decido in base ai range dove metterlo
|
|
local b3Ent = EgtGetBBoxGlob( EntId, GDB_BB.STANDARD)
|
|
local dMin = b3Ent:getMin():getX()
|
|
local dMax = b3Ent:getMax():getX()
|
|
|
|
-- se ho forzato ad usare uno shuttle, setto a tutte le geometrie lo shuttle disponibile
|
|
if nForceUseShuttle and nForceUseShuttle > 0 then
|
|
if nForceUseShuttle == 1 then -- se forzo uso shuttle 1 (il valore assegnato a 3 è l'id della MTABLE)
|
|
nSetSide = 3 -- setto lower
|
|
nNumBottomGeom = nNumBottomGeom + 1
|
|
else -- altrimenti lo shuttle 2
|
|
nSetSide = 2 -- setto upper
|
|
nNumTopGeom = nNumTopGeom + 1
|
|
end
|
|
else
|
|
-- se il minimo geometria è tutto con lo shuttle superiore ( di destra)
|
|
if dMin >= dPosShuttleChange then
|
|
nSetSide = 2 -- setto upper
|
|
nNumTopGeom = nNumTopGeom + 1
|
|
else -- altrimenti sfora o è completamente nella parte dello shuttle inferiore ( di sinistra)
|
|
-- se il massimo è oltre il limite lo setto neutro
|
|
if dMax > dPosShuttleChange then
|
|
nSetSide = 0 -- setto neutro
|
|
else
|
|
nSetSide = 3 -- setto lower
|
|
nNumBottomGeom = nNumBottomGeom + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se neutro decido da che parte stare in base al numero delle rispettive parti
|
|
if nSetSide == 0 then
|
|
if nNumTopGeom == 0 then -- se shuttle alto senza assegnazioni lo assegno alto
|
|
nSetSide = 2
|
|
nNumTopGeom = nNumTopGeom + 1
|
|
else -- altrimenti shuttle alto ha già assegnazioni
|
|
if nNumBottomGeom == 0 then -- se shuttle basso senza assegnazioni lo assegno basso
|
|
nSetSide = 3 -- setto lower
|
|
nNumBottomGeom = nNumBottomGeom + 1
|
|
else -- altrimenti shuttle basso con già assegnazioni
|
|
-- confronto tra quale dei due ha più assegnazioni
|
|
if nNumBottomGeom >= nNumTopGeom then -- se shuttle basso ne ha uguali o di più lo assegno alto
|
|
nSetSide = 2
|
|
nNumTopGeom = nNumTopGeom + 1
|
|
else -- altrimenti shuttle basso ne ha di meno, assegno basso
|
|
nSetSide = 3 -- setto lower
|
|
nNumBottomGeom = nNumBottomGeom + 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
EgtSetInfo( EntId, 'Mach', nSetSide)
|
|
end
|
|
end
|
|
|
|
return true, nNumTopGeom, nNumBottomGeom, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustHorizDrillX( EntId, bMakeGhostGeom, bSelecExit, nProbeMode)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione/fresa
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- impongo versore fresa orizzontale
|
|
if abs( vtExtr:getZ()) > GEO.EPS_ZERO then
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
EgtSetInfo( EntId, 'OL', 0.16)
|
|
end
|
|
|
|
if bSelecExit then
|
|
local bLetExit
|
|
-- lavorazione frontale (destra o sinistra)
|
|
-- se probemode disabilitato confronto con valore quasi o nullo
|
|
if nProbeMode < 2 and abs( vtExtr:getY()) < GEO.EPS_ZERO then
|
|
bLetExit = true
|
|
-- se ha fallito l'orientamento e sono in probe mode 2 confronto con un valore più grande
|
|
elseif nProbeMode == 2 and abs( vtExtr:getY()) < 2 then
|
|
bLetExit = true
|
|
-- impongo versore Y a 0
|
|
vtExtr:setY( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
end
|
|
|
|
if bLetExit then
|
|
-- se diretto verso SX
|
|
if vtExtr:getX() < GEO.EPS_ZERO then
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
else
|
|
-- lavorazione diretta verso DX
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
end
|
|
end
|
|
end
|
|
return true, EntId
|
|
end
|
|
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustHorizDrillY( EntId, bMakeGhostGeom, bSelecExit, nProbeMode)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione/fresa
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- impongo versore fresa orizzontale
|
|
if abs( vtExtr:getZ()) > GEO.EPS_ZERO then
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
EgtSetInfo( EntId, 'OL', 0.16)
|
|
end
|
|
|
|
if bSelecExit then
|
|
local bLetExit
|
|
-- lavorazione frontale (dietro o davanti)
|
|
-- se probemode disabilitato confronto con valore quasi o nullo
|
|
if nProbeMode < 2 and abs( vtExtr:getX()) < GEO.EPS_ZERO then
|
|
bLetExit = true
|
|
-- se ha fallito l'orientamento e sono in probe mode 2 confronto con un valore più grande
|
|
elseif nProbeMode == 2 and abs( vtExtr:getX()) < 2 then
|
|
bLetExit = true
|
|
-- impongo versore X a 0
|
|
vtExtr:setX( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
end
|
|
|
|
if bLetExit then
|
|
-- se diretto verso davanti
|
|
if vtExtr:getY() < GEO.EPS_ZERO then
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
else
|
|
-- lavorazione Dietro
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
end
|
|
end
|
|
end
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustHorizAS( EntId, bMakeGhostGeom)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione/fresa
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- se orizzontale
|
|
if abs( vtExtr:getZ()) < GEO.EPS_ZERO then
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
-- se diretto in su
|
|
elseif vtExtr:getZ() > 0 then
|
|
-- lavorazione Up
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
-- altrimenti diretto in giù
|
|
else
|
|
-- lavorazione Dw
|
|
EgtSetInfo( EntId, 'Mach', 3)
|
|
end
|
|
-- impongo versore fresa orizzontale
|
|
if abs( vtExtr:getZ()) > GEO.EPS_ZERO then
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
EgtSetInfo( EntId, 'OL', 0.16)
|
|
end
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustHorNegativeAS( EntId, bMakeGhostGeom)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione/fresa
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
|
|
-- se orizzontale
|
|
if abs( vtExtr:getZ()) < GEO.EPS_ZERO then
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
-- se diretto in su
|
|
elseif vtExtr:getZ() > 0 then
|
|
-- lavorazione Up
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
-- altrimenti diretto in giù
|
|
else
|
|
-- lavorazione Dw
|
|
EgtSetInfo( EntId, 'Mach', 3)
|
|
end
|
|
-- se è negativo impongo versore fresa orizzontale
|
|
if vtExtr:getZ() < GEO.EPS_ZERO then
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
EgtSetInfo( EntId, 'OL', 0.16)
|
|
end
|
|
return true, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustMortise( EntId, nNumMachSkip, bNoWorkUnderSquare, bMakeGhostGeom, bNoWorkUpSquare,
|
|
bForceHorizontalDir)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- contatore disabilitazione lavorazione
|
|
local nNumSkip = nNumMachSkip
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
|
|
-- se orizzontale
|
|
if abs( vtExtr:getZ()) < GEO.EPS_ZERO then
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
-- se diretto in su
|
|
elseif vtExtr:getZ() > 0 then
|
|
-- lavorazione Up a meno che c'è la forzatura orizzontale
|
|
if bForceHorizontalDir then -- se c'è forzatura orizzontale
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
EgtSetInfo( EntId, 'OL', 0.16)
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
else
|
|
if bNoWorkUpSquare then -- se non è possibile lavorare soprasquadra
|
|
EgtSetInfo( EntId, 'Mach', 12)
|
|
nNumSkip = nNumSkip + 1
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
end
|
|
end
|
|
-- altrimenti diretto in giù
|
|
else
|
|
-- lavorazione Dw a meno che c'è la forzatura orizzontale
|
|
if bForceHorizontalDir then -- se c'è forzatura orizzontale
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
EgtSetInfo( EntId, 'OL', 0.16)
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
else
|
|
if bNoWorkUnderSquare then -- se non è possibile lavorare sottosquadra
|
|
EgtSetInfo( EntId, 'Mach', 13)
|
|
nNumSkip = nNumSkip + 1
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', 3)
|
|
end
|
|
end
|
|
end
|
|
|
|
if vtMPlane then
|
|
local frEnt = EgtGetGlobFrame( EntId)
|
|
vtMPlane:toGlob(frEnt)
|
|
|
|
if dArea * ( vtMPlane * vtExtr) > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
end
|
|
|
|
return true, nNumSkip, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustBevelChisel( EntId, nNumMachSkip, bNoWorkUnderSquare, bMakeGhostGeom, bNoWorkUpSquare, bForceChiselHoriz)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- contatore disabilitazione lavorazione
|
|
local nNumSkip = nNumMachSkip
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
|
|
-- se orizzontale
|
|
if abs( vtExtr:getZ()) < GEO.EPS_ZERO then
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
-- se diretto in su
|
|
elseif vtExtr:getZ() > 0 then
|
|
-- lavorazione Up
|
|
if bNoWorkUpSquare then -- se non è possibile lavorare soprasquadra
|
|
EgtSetInfo( EntId, 'Mach', 12)
|
|
nNumSkip = nNumSkip + 1
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
if bForceChiselHoriz then
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
-- EgtSetInfo( EntId, 'OL', 0.16)
|
|
end
|
|
end
|
|
-- altrimenti diretto in giù
|
|
else
|
|
-- lavorazione Dw
|
|
if bNoWorkUnderSquare then -- se non è possibile lavorare sottosquadra
|
|
EgtSetInfo( EntId, 'Mach', 13)
|
|
nNumSkip = nNumSkip + 1
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', 3)
|
|
if bForceChiselHoriz then
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
-- EgtSetInfo( EntId, 'OL', 0.16)
|
|
end
|
|
end
|
|
end
|
|
|
|
if vtMPlane then
|
|
local frEnt = EgtGetGlobFrame( EntId)
|
|
vtMPlane:toGlob(frEnt)
|
|
|
|
if dArea * ( vtMPlane * vtExtr) > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
end
|
|
|
|
return true, nNumSkip, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustHeadChisel( EntId, bMakeGhostGeom, bWorkOnlyHoriz, nNumMachSkip, bNoWorkUpSquare, bNoWorkUnderSquare)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- contatore disabilitazione lavorazione
|
|
local nNumSkip = nNumMachSkip
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
|
|
-- se area piccola esco
|
|
if dArea and abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
|
|
-- se valore quasi o nullo
|
|
if abs( vtExtr:getX()) < GEO.EPS_ZERO then
|
|
-- lavorazione frontale (dietro o davanti)
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
-- se abilitata verifica e modifica versore z per lavorazione orizzontale ( non segue il bevel)
|
|
if bWorkOnlyHoriz then
|
|
-- se non orizzontale impongo versore fresa orizzontale
|
|
if abs( vtExtr:getZ()) > GEO.EPS_ZERO then
|
|
vtExtr:setZ( 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
-- EgtSetInfo( EntId, 'OL', 0.16)
|
|
end
|
|
else
|
|
-- se diretto in su
|
|
if vtExtr:getZ() > 0 then
|
|
-- lavorazione Up
|
|
if bNoWorkUpSquare then -- se non è possibile lavorare soprasquadra
|
|
EgtSetInfo( EntId, 'Mach', 11)
|
|
nNumSkip = nNumSkip + 1
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', 1)
|
|
end
|
|
-- altrimenti diretto in giù
|
|
elseif vtExtr:getZ() < 0 then
|
|
-- lavorazione Dw
|
|
if bNoWorkUnderSquare then -- se non è possibile lavorare sottosquadra
|
|
EgtSetInfo( EntId, 'Mach', 11)
|
|
nNumSkip = nNumSkip + 1
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', 1)
|
|
end
|
|
end
|
|
end
|
|
-- se diretto verso DX
|
|
elseif vtExtr:getX() > 0 then
|
|
-- lavorazione DX
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
-- altrimenti diretto s SX
|
|
else
|
|
-- lavorazione SX
|
|
EgtSetInfo( EntId, 'Mach', 3)
|
|
end
|
|
|
|
-- impongo senso di rotazione orario relativo alla normale del versore
|
|
if vtMPlane then
|
|
local frEnt = EgtGetGlobFrame( EntId)
|
|
vtMPlane:toGlob(frEnt)
|
|
|
|
if dArea * ( vtMPlane * vtExtr) > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
end
|
|
|
|
return true, EntId, nNumSkip
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustVertHole( EntId, DimZ, ptMin, ptMax, nNumMachSkip, bFirstStep, bWorkUnder, bMakeGhostGeom, dExtraThruDepth)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- contatore disabilitazione lavorazione
|
|
local nNumSkip = nNumMachSkip
|
|
local nTypeGeom = 0 -- 1: passante up, 2: passante dw, 3: cieca up, 4: cieca dw
|
|
-- recupero spessore e verifico se passante
|
|
local dTh = EgtCurveThickness( EntId)
|
|
local bTrhu = ( abs( dTh) > DimZ - GEO.EPS_SMALL)
|
|
-- se passante, aggiunto affondamento
|
|
if bTrhu then
|
|
local dOl = -2 -- valore in mm
|
|
if dExtraThruDepth then
|
|
dOl = -abs(dExtraThruDepth)
|
|
end
|
|
EgtSetInfo( EntId, 'OL', dOl)
|
|
end
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- recupero flag di lavorazione
|
|
local nLocMach = EgtGetInfo( EntId, 'Mach', 'i') or 1
|
|
-- se versore fresa diretto come Z- (da sotto)
|
|
if vtExtr:getZ() < 0 then
|
|
-- se passante, lo cambio in Z+
|
|
if bTrhu then
|
|
vtExtr = - vtExtr
|
|
local pIni = EgtSP( EntId, GDB_ID.ROOT)
|
|
if abs( pIni:getZ() - ptMin:getZ()) < GEO.EPS_SMALL then -- se il foro parte sulla faccia sotto
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
|
|
-- leggo la nota Mach2nd che indica se l'entità è già stata lavorata
|
|
local nMach2nd = EgtGetInfo( EntId, 'Mach2nd', 'i') or 0
|
|
|
|
if nMach2nd == 0 then
|
|
-- se è una geometria che avevo escluso la riabilito
|
|
if nLocMach >= 10 then
|
|
nLocMach = nLocMach - 10
|
|
elseif nLocMach > 0 then -- se è una che non avevo scluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
end
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
EgtMove( EntId, vtExtr * abs(dTh), GDB_RT.GLOB)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
end
|
|
nTypeGeom = 2
|
|
elseif abs( pIni:getZ() - ptMax:getZ()) < GEO.EPS_SMALL then -- se il foro parte sulla faccia sopra
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
|
|
-- leggo la nota Mach2nd che indica se l'entità è già stata lavorata
|
|
local nMach2nd = EgtGetInfo( EntId, 'Mach2nd', 'i') or 0
|
|
|
|
if nMach2nd == 0 then
|
|
if nLocMach >= 10 then
|
|
if nLocMach <= 21 then
|
|
nLocMach = nLocMach - 10
|
|
end
|
|
elseif nLocMach > 0 then -- se è una che non avevo escluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
end
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
EgtMove( EntId, -vtExtr * abs(dTh), GDB_RT.GLOB)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
end
|
|
nTypeGeom = 2
|
|
else -- altrimenti lo salto perché è in una Z diversa da sopra o sotto
|
|
EgtSetInfo( EntId, 'Mach', 0)
|
|
end
|
|
-- altrimenti non passante
|
|
else
|
|
-- se non posso lavorare da sotto
|
|
if not bWorkUnder then
|
|
-- se non era ancora stato escluso, lo escludo sommando 10 al valore
|
|
if nLocMach < 10 then
|
|
nLocMach = nLocMach + 10
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
nNumSkip = nNumSkip + 1
|
|
else
|
|
nLocMach = 2
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
nTypeGeom = 4
|
|
end
|
|
else -- versore Z diretto in Z+
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
-- leggo la nota Mach2nd che indica se l'entità è già stata lavorata
|
|
local nMach2nd = EgtGetInfo( EntId, 'Mach2nd', 'i') or 0
|
|
if nMach2nd == 0 then
|
|
if nLocMach >= 10 then
|
|
if nLocMach <= 21 then
|
|
nLocMach = nLocMach - 10
|
|
end
|
|
elseif nLocMach > 0 then -- se è una che non avevo scluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
end
|
|
if bTrhu then
|
|
nTypeGeom = 1
|
|
else
|
|
nTypeGeom = 3
|
|
end
|
|
end
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
local vtMPlane, dDist, dArea
|
|
-- verifico se il percorso è chiuso
|
|
if EgtCurveIsClosed( EntId) then
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
if abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
end
|
|
-- altrimenti è aperto
|
|
else
|
|
-- faccio una copia del percorso
|
|
local sParnt = EgtGetParent( EntId)
|
|
local nNewEntId = EgtCopyGlob( EntId, sParnt)
|
|
-- chiudo il percorso
|
|
if EgtCloseCurveCompo( nNewEntId) then
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
vtMPlane, dDist, dArea = EgtCurveArea( nNewEntId)
|
|
EgtErase(nNewEntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
end
|
|
else
|
|
EgtErase(nNewEntId)
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
if not dArea or abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
end
|
|
end
|
|
end
|
|
local frEnt = EgtGetGlobFrame( EntId)
|
|
if vtMPlane then
|
|
vtMPlane:toGlob(frEnt)
|
|
if nLocMach ~= 2 then
|
|
if dArea and dArea * ( vtMPlane * vtExtr) > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
else
|
|
if dArea and dArea * ( vtMPlane * vtExtr) < 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
end
|
|
end
|
|
--[[
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
|
|
if not dArea or abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
end
|
|
local frEnt = EgtGetGlobFrame( EntId)
|
|
vtMPlane:toGlob(frEnt)
|
|
if nLocMach ~= 2 then
|
|
if dArea * ( vtMPlane * vtExtr) > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
else
|
|
if dArea * ( vtMPlane * vtExtr) < 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
end
|
|
]]--
|
|
--[[
|
|
local dAreaXY = EgtCurveAreaXY( EntId)
|
|
if dAreaXY and abs( dAreaXY) < 1 then
|
|
-- provo con EgtCurveArea
|
|
local vtV1, dDist, dArea = EgtCurveArea( EntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip, EntId
|
|
else
|
|
dAreaXY = dArea
|
|
end
|
|
end
|
|
local frEnt = EgtFR( EgtGetParent( EntId), GDB_ID.ROOT)
|
|
if nLocMach ~= 2 then
|
|
if dAreaXY and dAreaXY * frEnt:getVersZ():getZ() > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
else
|
|
if dAreaXY and dAreaXY * frEnt:getVersZ():getZ() < 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
end
|
|
]]--
|
|
end
|
|
return true, nNumSkip, EntId, nTypeGeom
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustProbeHole( EntId, DimZ, ptMin, ptMax, nNumMachSkip, bFirstStep, bWorkUnder, bMakeGhostGeom)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- contatore disabilitazione lavorazione
|
|
local nNumSkip = nNumMachSkip
|
|
-- recupero spessore e verifico se passante
|
|
local dTh = EgtCurveThickness( EntId)
|
|
local bTrhu = ( abs( dTh) > DimZ - GEO.EPS_SMALL)
|
|
-- se passante, aggiunto affondamento
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- recupero flag di lavorazione
|
|
local nLocMach = EgtGetInfo( EntId, 'Mach', 'i') or 1
|
|
-- se versore fresa diretto come Z-,
|
|
if vtExtr:getZ() < 0 then
|
|
-- se passante, lo cambio in Z+
|
|
if bTrhu then
|
|
vtExtr = - vtExtr
|
|
local pIni = EgtSP( EntId, GDB_ID.ROOT)
|
|
if abs( pIni:getZ() - ptMin:getZ()) < GEO.EPS_SMALL then -- se il foro parte sulla faccia sotto
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
-- se è una geometria che avevo escluso la riabilito
|
|
if nLocMach >= 10 then
|
|
nLocMach = nLocMach - 10
|
|
elseif nLocMach > 0 then -- se è una che non avevo escluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
EgtMove( EntId, vtExtr * abs(dTh), GDB_RT.GLOB)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
end
|
|
elseif abs( pIni:getZ() - ptMax:getZ()) < GEO.EPS_SMALL then -- se il foro parte sulla faccia sopra
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
if nLocMach >= 10 then
|
|
nLocMach = nLocMach - 10
|
|
elseif nLocMach > 0 then -- se è una che non avevo scluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
EgtMove( EntId, -vtExtr * abs(dTh), GDB_RT.GLOB)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
end
|
|
else -- altrimenti lo salto perché è in una Z diversa da sopra o sotto
|
|
EgtSetInfo( EntId, 'Mach', 0)
|
|
end
|
|
-- altrimenti lo salto
|
|
else
|
|
-- se non posso lavorare da sotto
|
|
if not bWorkUnder then
|
|
-- se non era ancora stato escluso, lo escludo sommando 10 al valore
|
|
if nLocMach < 10 then
|
|
nLocMach = nLocMach + 10
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
nNumSkip = nNumSkip + 1
|
|
else
|
|
nLocMach = 2
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
end
|
|
else
|
|
-- in seconda fase controllo la nota mach se devo ristabilirla o escluderla
|
|
if not bFirstStep then
|
|
if nLocMach >= 10 then
|
|
nLocMach = nLocMach - 10
|
|
elseif nLocMach > 0 then -- se è una che non avevo scluso la escludo
|
|
nLocMach = nLocMach + 10
|
|
else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
nLocMach = 11
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
end
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
-- impongo senso di rotazione orario visto da sopra
|
|
local dAreaXY
|
|
_ , _ , dAreaXY = EgtCurveArea( EntId)
|
|
if dAreaXY and abs( dAreaXY) < 0.1 then
|
|
-- Rimando il valore originario in caso avessi skippato la lavorazione
|
|
return false, nNumMachSkip
|
|
end
|
|
local frEnt = EgtFR( EgtGetParent( EntId), GDB_ID.ROOT)
|
|
if nLocMach ~= 2 then
|
|
if dAreaXY and dAreaXY * frEnt:getVersZ():getZ() > 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
else
|
|
if dAreaXY and dAreaXY * frEnt:getVersZ():getZ() < 0 then
|
|
EgtInvertCurve( EntId)
|
|
end
|
|
end
|
|
EgtSetInfo( EntId, 'ProbeMachZ', 3)
|
|
end
|
|
return true, nNumSkip, EntId
|
|
end
|
|
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustProbeMill( EntId, DimZ, ptMin, ptMax, nNumMachSkip,
|
|
bFirstStep, bNoWorkUnderSquare, bMakeGhostGeom, bNoWorkUpSquare, dThickPrb,
|
|
dDepthPrb)
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- se versore fresa diretto come Z-,
|
|
if vtExtr:getZ() < 0 then
|
|
EgtModifyCurveExtrusion( EntId, Z_AX(), GDB_RT.GLOB)
|
|
end
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- contatore disabilitazione lavorazione
|
|
local nNumSkip = nNumMachSkip
|
|
-- recupero spessore e verifico se passante
|
|
local dTh = EgtCurveThickness( EntId)
|
|
local bTrhu = ( abs( dTh) > DimZ - GEO.EPS_SMALL)
|
|
-- recupero flag di lavorazione
|
|
local nLocMach = EgtGetInfo( EntId, 'Mach', 'i') or 1
|
|
local sProfile = EgtGetInfo( EntId, 'ProfSide', 's') or ''
|
|
-- verifico direzione lavorazione
|
|
local pt1 = EgtSP( EntId, GDB_ID.ROOT)
|
|
local pt2 = EgtEP( EntId, GDB_ID.ROOT)
|
|
-- calcolo direzione entrante
|
|
vtExtr = pt2 - pt1; vtExtr:normalize()
|
|
-- se si trova a Z0 lo sposto a quota spessore porta
|
|
if abs( pt1:getZ() - ptMin:getZ()) < GEO.EPS_SMALL then
|
|
EgtMove( EntId, Point3d( 0, 0, ( ptMax:getZ()-ptMin:getZ())), GDB_RT.GLOB)
|
|
end
|
|
-- se vettore estrusione è all'interno della tangente di 3° proseguo con la verifica
|
|
if abs(vtExtr:getZ()) < 0.0525 then
|
|
-- se non sono al primo giro setto profili bevel invertiti
|
|
if not bFirstStep and sProfile == 'BD' then
|
|
sProfile = 'BU'
|
|
elseif not bFirstStep and sProfile == 'BU' then
|
|
sProfile = 'BD'
|
|
end
|
|
if sProfile == 'BD' then
|
|
if bNoWorkUnderSquare then -- se non è possibile lavorare sottosquadra
|
|
EgtSetInfo( EntId, 'Mach', 13)
|
|
nNumSkip = nNumSkip + 1
|
|
EgtModifyCurveThickness( EntId, 0)
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', 3)
|
|
EgtModifyCurveThickness( EntId, -( dThickPrb + dDepthPrb))
|
|
end
|
|
elseif sProfile == 'BU' then
|
|
if bNoWorkUpSquare then -- se non è possibile lavorare soprasquadra
|
|
EgtSetInfo( EntId, 'Mach', 12)
|
|
nNumSkip = nNumSkip + 1
|
|
EgtModifyCurveThickness( EntId, 0)
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', 2)
|
|
EgtModifyCurveThickness( EntId, -dDepthPrb)
|
|
end
|
|
else
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
-- -- elimino il percorso ProbeSidePoint_ per non lavorarlo in un a fase successiva
|
|
-- if bFirstStep then
|
|
-- local nPar = EgtGetParent(EntId)
|
|
-- local tEnt = MachiningBase.FindGroupWithPartName( nPar, sParzName..'_secure')
|
|
-- if tEnt and #tEnt > 0 then
|
|
-- for i = 1, #tEnt do
|
|
-- EgtErase(tEnt[i])
|
|
-- end
|
|
-- end
|
|
-- tEnt = MachiningBase.FindGroupWithPartName( nPar, sParzName..'_keyway')
|
|
-- if tEnt and #tEnt > 0 then
|
|
-- for i = 1, #tEnt do
|
|
-- EgtErase(tEnt[i])
|
|
-- end
|
|
-- end
|
|
-- end
|
|
end
|
|
-- se diretto verso X+
|
|
if vtExtr:getX() > 0.98 then
|
|
EgtSetInfo( EntId, 'ProbeMachXY', 1) -- E101 = 1
|
|
-- altrimenti se diretto verso X-
|
|
elseif vtExtr:getX() < -0.98 then
|
|
EgtSetInfo( EntId, 'ProbeMachXY', -1) -- E101 = 4
|
|
-- altrimenti se diretto verso Y+
|
|
elseif vtExtr:getY() > 0.98 then
|
|
EgtSetInfo( EntId, 'ProbeMachXY', 2) -- E101 = 2
|
|
-- altrimenti se diretto verso Y-
|
|
elseif vtExtr:getY() < -0.98 then
|
|
EgtSetInfo( EntId, 'ProbeMachXY', -2) -- E101 = 6
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', nLocMach + 20)
|
|
return false, nNumSkip, EntId
|
|
end
|
|
else
|
|
EgtSetInfo( EntId, 'Mach', nLocMach + 20)
|
|
return false, nNumSkip, EntId
|
|
end
|
|
|
|
return true, nNumSkip, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.AdjustVertAsOnHeads( EntId, bMakeGhostGeom)
|
|
if bMakeGhostGeom then
|
|
EntId = MachiningBase.MakeGhostCopy( EntId)
|
|
end
|
|
-- recupero versore estrusione/fresa
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- recupero punti inziale e finale
|
|
local pIni = EgtSP( EntId, GDB_ID.ROOT)
|
|
local pNewIni = Point3d( pIni)
|
|
local pEnd = EgtEP( EntId, GDB_ID.ROOT)
|
|
local pNewEnd = Point3d( pEnd)
|
|
local bExit = true
|
|
|
|
-- se punti diversi
|
|
if dist( pIni, pEnd) > GEO.EPS_SMALL then
|
|
-- se versore Y verso Y+ (faccia dietro)
|
|
if vtExtr:getY() > 0.99 then
|
|
-- se punto iniziale ha Y verso Y-
|
|
if pIni:getY() < ( pEnd:getY() - GEO.EPS_SMALL) then
|
|
-- ricostruisco il percorso tenendo la posizione di Y più interno
|
|
pNewEnd = Point3d( pEnd:getX(), pIni:getY(), pEnd:getZ())
|
|
-- se punto iniziale ha Y verso Y+
|
|
elseif pIni:getY() > ( pEnd:getY() + GEO.EPS_SMALL) then
|
|
-- ricostruisco il percorso tenendo la posizione di Y più interno
|
|
pNewIni = Point3d( pIni:getX(), pEnd:getY(), pIni:getZ())
|
|
end
|
|
-- se versore Y verso Y+ (faccia dietro)
|
|
elseif vtExtr:getY() < -0.99 then
|
|
-- se punto iniziale ha Y verso Y-
|
|
if pIni:getY() < ( pEnd:getY() - GEO.EPS_SMALL) then
|
|
-- ricostruisco il percorso tenendo la posizione di Y più interno
|
|
pNewIni = Point3d( pIni:getX(), pEnd:getY(), pIni:getZ())
|
|
-- se punto iniziale ha Y verso Y+
|
|
elseif pIni:getY() > ( pEnd:getY() + GEO.EPS_SMALL) then
|
|
-- ricostruisco il percorso tenendo la posizione di Y più interno
|
|
pNewEnd = Point3d( pEnd:getX(), pIni:getY(), pEnd:getZ())
|
|
end
|
|
end
|
|
|
|
-- se ho cambiato almeno 1 punto ricotruisco il percorso
|
|
if not AreSamePointExact( pIni, pNewIni) or not AreSamePointExact( pEnd, pNewEnd) then
|
|
nParent = EgtGetParent( EntId)
|
|
local sName = EgtGetName( EntId)
|
|
EgtErase (EntId)
|
|
EntId = EgtLine( nParent, pNewIni, pNewEnd, GDB_RT.GLOB)
|
|
EgtSetName( EntId, sName)
|
|
EgtModifyCurveThickness( EntId, 0)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_ID.ROOT)
|
|
EgtSetStatus( EntId, GDB_ST.OFF)
|
|
end
|
|
else
|
|
bExit = false
|
|
end
|
|
|
|
-- lavorazione standard
|
|
EgtRemoveInfo( EntId, 'Mach')
|
|
|
|
return bExit, EntId
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.InvertGeom( EntId)
|
|
-- recupero spessore e verifico se passante
|
|
local dTh = EgtCurveThickness( EntId)
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- recupero flag di lavorazione
|
|
local nLocMach = EgtGetInfo( EntId, 'Mach', 'i') or 1
|
|
|
|
vtExtr = - vtExtr
|
|
-- se da lavorare ora
|
|
if nLocMach > 0 and nLocMach < 10 then
|
|
EgtMove( EntId, vtExtr * abs(dTh), GDB_RT.GLOB)
|
|
EgtModifyCurveExtrusion( EntId, vtExtr, GDB_RT.GLOB)
|
|
|
|
if nLocMach == 1 then
|
|
-- nLocMach = nLocMach + 10 + 1
|
|
nLocMach = 2
|
|
elseif nLocMach == 2 then
|
|
-- nLocMach = nLocMach + 10 - 1
|
|
nLocMach = 1
|
|
-- else -- altrimenti la escludo perché è già stata fatta nella fase precedente
|
|
-- nLocMach = nLocMach + 10
|
|
end
|
|
EgtSetInfo( EntId, 'Mach', nLocMach)
|
|
end
|
|
return true
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** Test Functions ***
|
|
-----------------------------------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.TestThrouIsle( EntId, DimZ, ptMin, ptMax, bWorkUnder)
|
|
-- skip geometria, con spessore passante e geometria valida restituisce 0 perché è neutro
|
|
-- restituisce +1 se è sotto, restituisce -1 se è sopra
|
|
local nSkipGeom
|
|
local nTypeGeom = 0 -- 1: passante up, 2: passante dw, 3: cieca up, 4: cieca dw
|
|
-- recupero spessore e verifico se passante
|
|
local dTh = EgtCurveThickness( EntId)
|
|
local bTrhu = ( abs( dTh) > DimZ - GEO.EPS_SMALL)
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- se versore fresa diretto come Z-,
|
|
if vtExtr:getZ() < 0 then
|
|
-- se passante, lo cambio in Z+
|
|
if bTrhu then
|
|
local pIni = EgtSP( EntId, GDB_ID.ROOT)
|
|
if abs( pIni:getZ() - ptMin:getZ()) < GEO.EPS_SMALL then -- se geometria è sulla faccia sotto
|
|
nSkipGeom = 0
|
|
nTypeGeom = 2
|
|
elseif abs( pIni:getZ() - ptMax:getZ()) < GEO.EPS_SMALL then -- se geometria è sulla faccia sopra
|
|
nSkipGeom = 0
|
|
nTypeGeom = 2
|
|
end
|
|
-- altrimenti lo salto
|
|
else
|
|
if not bWorkUnder then
|
|
nSkipGeom = 1
|
|
else
|
|
nSkipGeom = 0
|
|
end
|
|
nTypeGeom = 4
|
|
end
|
|
else -- altrimenti versore fresa diretto come Z+
|
|
if bTrhu then
|
|
local pIni = EgtSP( EntId, GDB_ID.ROOT)
|
|
if abs( pIni:getZ() - ptMin:getZ()) < GEO.EPS_SMALL then -- se geometria è sulla faccia sotto
|
|
nSkipGeom = 0
|
|
nTypeGeom = 1
|
|
elseif abs( pIni:getZ() - ptMax:getZ()) < GEO.EPS_SMALL then -- se geometria è sulla faccia sopra
|
|
nSkipGeom = 0
|
|
nTypeGeom = 1
|
|
end
|
|
-- altrimenti lo salto
|
|
else
|
|
nSkipGeom = -1
|
|
nTypeGeom = 3
|
|
end
|
|
end
|
|
|
|
-- verifico se il percorso è chiuso
|
|
if EgtCurveIsClosed( EntId) then
|
|
-- verifico se area è troppo piccola
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
if abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
-- altrimenti è aperto
|
|
else
|
|
-- faccio una copia del percorso
|
|
local sParnt = EgtGetParent( EntId)
|
|
local nNewEntId = EgtCopyGlob( EntId, sParnt)
|
|
-- chiudo il percorso
|
|
if EgtCloseCurveCompo( nNewEntId) then
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( nNewEntId)
|
|
-- cancello percorso copia
|
|
EgtErase(nNewEntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
else
|
|
-- cancello percorso copia
|
|
EgtErase(nNewEntId)
|
|
-- verifico se area è troppo piccola
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
|
|
--[[
|
|
local dAreaXY = EgtCurveAreaXY( EntId)
|
|
if dAreaXY and abs( dAreaXY) < 1 then
|
|
-- provo con EgtCurveArea
|
|
local vtV1, dDist, dArea = EgtCurveArea( EntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
return false
|
|
else
|
|
dAreaXY = dArea
|
|
end
|
|
end
|
|
]]--
|
|
return true, nSkipGeom, nTypeGeom
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.TestVertHole( EntId, DimZ, ptMin, ptMax, bWorkUnder)
|
|
-- skip geometria, con spessore passante e geometria valida restituisce 0 perché è neutro
|
|
-- restituisce +1 se è sotto, restituisce -1 se è sopra
|
|
local nSkipGeom
|
|
local nTypeGeom = 0 -- 1: passante up, 2: passante dw, 3: cieca up, 4: cieca dw
|
|
-- recupero spessore e verifico se passante
|
|
local dTh = EgtCurveThickness( EntId)
|
|
local bTrhu = ( abs( dTh) > DimZ - GEO.EPS_SMALL)
|
|
-- recupero versore estrusione
|
|
local vtExtr = EgtCurveExtrusion( EntId, GDB_ID.ROOT)
|
|
-- se versore fresa diretto come Z-,
|
|
if vtExtr:getZ() < 0 then
|
|
-- se passante, lo cambio in Z+
|
|
if bTrhu then
|
|
local pIni = EgtSP( EntId, GDB_ID.ROOT)
|
|
if abs( pIni:getZ() - ptMin:getZ()) < GEO.EPS_SMALL then -- se il foro parte sulla faccia sotto
|
|
nSkipGeom = 0
|
|
nTypeGeom = 2
|
|
elseif abs( pIni:getZ() - ptMax:getZ()) < GEO.EPS_SMALL then -- se il foro parte sulla faccia sopra
|
|
nSkipGeom = 0
|
|
nTypeGeom = 2
|
|
end
|
|
-- altrimenti lo salto
|
|
else
|
|
if not bWorkUnder then
|
|
nSkipGeom = 1
|
|
else
|
|
nSkipGeom = 0
|
|
end
|
|
nTypeGeom = 4
|
|
end
|
|
else -- altrimenti versore fresa diretto come Z+
|
|
if bTrhu then
|
|
local pIni = EgtSP( EntId, GDB_ID.ROOT)
|
|
if abs( pIni:getZ() - ptMin:getZ()) < GEO.EPS_SMALL then -- se geometria è sulla faccia sotto
|
|
nSkipGeom = 0
|
|
nTypeGeom = 1
|
|
elseif abs( pIni:getZ() - ptMax:getZ()) < GEO.EPS_SMALL then -- se geometria è sulla faccia sopra
|
|
nSkipGeom = 0
|
|
nTypeGeom = 1
|
|
end
|
|
-- altrimenti lo salto
|
|
else
|
|
nSkipGeom = -1
|
|
nTypeGeom = 3
|
|
end
|
|
end
|
|
|
|
-- verifico se il percorso è chiuso
|
|
if EgtCurveIsClosed( EntId) then
|
|
-- verifico se area è troppo piccola
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
if abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
-- altrimenti è aperto
|
|
else
|
|
-- faccio una copia del percorso
|
|
local sParnt = EgtGetParent( EntId)
|
|
local nNewEntId = EgtCopyGlob( EntId, sParnt)
|
|
-- chiudo il percorso
|
|
if EgtCloseCurveCompo( nNewEntId) then
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( nNewEntId)
|
|
-- cancello percorso copia
|
|
EgtErase(nNewEntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
else
|
|
-- cancello percorso copia
|
|
EgtErase(nNewEntId)
|
|
-- verifico se area è troppo piccola
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
if not dArea or abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
--[[
|
|
-- verifico se area è troppo piccola
|
|
local vtMPlane, dDist, dArea = EgtCurveArea( EntId)
|
|
|
|
if not dArea or abs( dArea) < 1 then
|
|
return false
|
|
end
|
|
]]--
|
|
--[[
|
|
local dAreaXY = EgtCurveAreaXY( EntId)
|
|
if dAreaXY and abs( dAreaXY) < 1 then
|
|
-- provo con EgtCurveArea
|
|
local vtV1, dDist, dArea = EgtCurveArea( EntId)
|
|
if dArea and abs( dArea) < 1 then
|
|
return false
|
|
else
|
|
dAreaXY = dArea
|
|
end
|
|
end
|
|
]]--
|
|
return true, nSkipGeom, nTypeGeom
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.TestMachining( sMach, EntId, bCheckPos)
|
|
-- verifico inserimento e applicazione della lavorazione alla geometria
|
|
if not sMach or ( sMach and #sMach == 0) then
|
|
return false, sMach
|
|
end
|
|
local nMach = EgtAddMachining( 'Dummy', sMach)
|
|
if not nMach then
|
|
return false
|
|
end
|
|
local bOk = EgtSetMachiningGeometry( EntId) and EgtApplyMachining()
|
|
local bBoxMach
|
|
if bOk and bCheckPos then
|
|
bBoxMach = EgtGetBBoxGlob ( nMach, GDB_BB.STANDARD)
|
|
end
|
|
EgtRemoveOperation( nMach)
|
|
-- ripristino ultima lavorazione rimasta
|
|
local nOper = EgtGetLastActiveOperation() or GDB_ID.NULL
|
|
local nType = EgtGetOperationType( nOper)
|
|
if nType ~= MCH_OY.NONE and nType ~= MCH_OY.DISP then
|
|
EgtSetCurrMachining( nOper)
|
|
EgtApplyMachining()
|
|
end
|
|
return bOk, sMach, bBoxMach
|
|
end
|
|
|
|
-----------------------------------------------------------------
|
|
-- *** MachTable Functions ***
|
|
-----------------------------------------------------------------
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.GetToolDiamFromAttrib( sName, nInd)
|
|
|
|
--[[
|
|
local sCamData = 'CurrCamInfo'
|
|
local mCamData = require( sCamData)
|
|
|
|
local MachiningsTable = mCamData[DGD.MCC].MachiningsTable
|
|
local MachName = mCamData[DGD.MCC].MachName
|
|
local sLocMachname
|
|
|
|
local MTable = require( MachiningsTable)
|
|
]]--
|
|
|
|
-- prendo dalle note il nome tabella e poi da questa le macchine indicate
|
|
-- devo cercare per ogni macchina, che esiste
|
|
-- cerco nella tabella le associazioni che siano abilitate, che abbiano la macchina compatibile,
|
|
-- che ci sia il nome geometria corrispondente
|
|
local MachiningsTable = EgtGetInfo( DGD.PZ, 'MTable')
|
|
local MachiningsPath = EgtGetInfo( DGD.PZ, 'MTablePath')
|
|
|
|
-- se tavola non trovata esco subito
|
|
if not MachiningsTable or not MachiningsPath then return -8 end
|
|
|
|
local M = dofile( MachiningsPath..MachiningsTable..'.mtl')
|
|
local MTable = M.MTable
|
|
local MachinesName = M.MMachineData
|
|
local sLocMachId
|
|
local sMachine
|
|
|
|
-- per ogni macchina faccio il giro della tabella
|
|
for j = 1, #MachinesName do
|
|
|
|
sMachine = MachinesName[j].MachName
|
|
-- imposto la macchina corrente
|
|
if sMachine and EgtSetCurrMachine( sMachine) then
|
|
|
|
for i = 1, #MTable do
|
|
|
|
if MTable[i].On ~= 0 then
|
|
|
|
-- se non presente il nome macchina di default setto l'associazione per la macchina 1
|
|
sLocMachId = MTable[i].MachId
|
|
if not sLocMachId then sLocMachId = 1 end
|
|
|
|
if string.lower(MTable[i].Name) == string.lower(sName) and sLocMachId == j then
|
|
-- recupero il nome della lavorazione
|
|
local sMach
|
|
if nInd == 2 then
|
|
sMach = MTable[i].MachUp
|
|
elseif nInd == 3 then
|
|
sMach = MTable[i].MachDw
|
|
else
|
|
sMach = MTable[i].Mach
|
|
end
|
|
if not sMach then return -1 end -- errore su lavorazione non trovata
|
|
-- imposto la lavorazione come corrente
|
|
if not EgtMdbSetCurrMachining( sMach) then return -2, nil, sMach end
|
|
-- recupero l'utensile della lavorazione
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if not sTuuid then return -3, nil, sMach end
|
|
local sTool = EgtTdbGetToolFromUUID( sTuuid)
|
|
if not sTool then return -4, nil, sMach end
|
|
EgtTdbSetCurrTool( sTool)
|
|
local dDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
|
|
if not dDiam then return -5, nil, sMach end
|
|
return dDiam, nil, sMach
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return - 6
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
function MachiningBase.GetToolDataFromAttrib( sName, nInd, bReadNotes, bForceReadThick)
|
|
|
|
-- prendo dalle note il nome tabella e poi da questa le macchine indicate
|
|
-- devo cercare per ogni macchina, che esiste
|
|
-- cerco nella tabella le associazioni che siano abilitate, che abbiano la macchina compatibile,
|
|
-- che ci sia il nome geometria corrispondente
|
|
local MachiningsTable = EgtGetInfo( DGD.PZ, 'MTable')
|
|
local MachiningsPath = EgtGetInfo( DGD.PZ, 'MTablePath')
|
|
|
|
-- se tavola non trovata esco subito
|
|
if not MachiningsTable or not MachiningsPath then return -8 end
|
|
|
|
local M = dofile( MachiningsPath..MachiningsTable..'.mtl')
|
|
local MTable = M.MTable
|
|
local MachinesName = M.MMachineData
|
|
local sLocMachId
|
|
local sMachine
|
|
|
|
-- per ogni macchina faccio il giro della tabella
|
|
for j = 1, #MachinesName do
|
|
|
|
sMachine = MachinesName[j].MachName
|
|
-- imposto la macchina corrente
|
|
if sMachine and EgtSetCurrMachine( sMachine) then
|
|
|
|
for i = 1, #MTable do
|
|
|
|
if MTable[i].On ~= 0 then
|
|
|
|
-- se non presente il nome macchina di default setto l'associazione per la macchina 1
|
|
sLocMachId = MTable[i].MachId
|
|
if not sLocMachId then sLocMachId = 1 end
|
|
|
|
if string.lower(MTable[i].Name) == string.lower(sName) and sLocMachId == j then
|
|
-- recupero il nome della lavorazione
|
|
local sMach
|
|
if nInd == 2 then
|
|
sMach = MTable[i].MachUp
|
|
elseif nInd == 3 then
|
|
sMach = MTable[i].MachDw
|
|
else
|
|
sMach = MTable[i].Mach
|
|
end
|
|
if not sMach then return -1 end
|
|
-- imposto la lavorazione come corrente
|
|
if not EgtMdbSetCurrMachining( sMach) then return -2, nil, sMach end
|
|
-- recupero l'eventuale nota
|
|
local sMachNotes = ''
|
|
if bReadNotes then
|
|
sMachNotes = EgtMdbGetCurrMachiningParam( MCH_MP.USERNOTES)
|
|
end
|
|
-- recupero l'utensile della lavorazione
|
|
local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
|
|
if not sTuuid then return -3, nil, sMach end
|
|
local sTool = EgtTdbGetToolFromUUID( sTuuid)
|
|
if not sTool then return -4, nil, sMach end
|
|
EgtTdbSetCurrTool( sTool)
|
|
local dDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
|
|
if not dDiam then return -5, nil, sMach end -- se non trovato diametro esco
|
|
local dHWork = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
|
|
if not dHWork then return -7, nil, sMach end -- se non trovato massimo materiale esco
|
|
local dHType = EgtTdbGetCurrToolParam( MCH_TP.TYPE)
|
|
local dThBlade
|
|
-- se forzata lettura spessore lama
|
|
if bForceReadThick then
|
|
-- se tipo utensile lama
|
|
if dHType == MCH_TY.SAW_STD or dHType == MCH_TY.SAW_FLAT then
|
|
dThBlade = EgtTdbGetCurrToolParam( MCH_TP.THICK)
|
|
-- se è tipo fresa allaora lo spessore lama setto uguale all'altezza tagliente
|
|
elseif dHType == MCH_TY.MILL_STD or dHType == MCH_TY.MILL_NOTIP then
|
|
dThBlade = dHWork
|
|
end
|
|
-- se utensile lama
|
|
elseif dHType == MCH_TY.SAW_STD or dHType == MCH_TY.SAW_FLAT then
|
|
dThBlade = EgtTdbGetCurrToolParam( MCH_TP.THICK)
|
|
end
|
|
-- ritorno i valori diametro utensile e lunghezza massima
|
|
return dDiam, dHWork, sMach, dThBlade, sMachNotes
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return - 6
|
|
end
|
|
|
|
return MachiningBase
|