Egalware/datadoors
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
datadoors/Main.lua
T
Dario Sassi b472c6b88e DataDoors 3.1a1 : 
- aggiunta gestione ProbeId anche per Probe su Pivot del lato cerniere (intermediatepivot).
2026-01-07 18:17:12 +01:00

12940 lines
551 KiB
Lua
Raw Permalink Blame History

-- Main.lua by EgalWare s.r.l. 2026.01.07
-- Main creazione porte da descrizione DDF
-- 2016.09.07 V1.001 FM Modificata gestione flush bolt
-- 2016.09.14 V1.002 FM Aggiunta gestione log file
-- 2017.06.27 V1.013 FM Manage frame jamb ( hinges jamb and lock jamb)
-- 2017.07.24 V1.014 FM Manage frame jamb ( top frame) and assembly ( more pieces into one ddf file)
-- 2017.12.13 V1.014 FM Manage parameter side on groove and face on flushpull models
-- 2018.01.12 V1.015 FM Fix errors on calculate frame point
-- 2018.01.22 V1.016 FM Manage Arc on top door side
-- 2018.02.14 V1.017 FM Add sizing
-- 2018.02.16 V1.018 FM Sizing top arc
-- 2018.02.16 V1.018 FM Fix missing assignement of DGD.SIDE with Stop & Closer and OverHead hardware model
-- 2018.03.23 V1.019 FM Add notes on side paths
-- 2018.04.09 V1.01a FM Manage KeepBackSet notes on flush pull geometries (into MoveFlushPull) and
-- on Lock sides (keyway and secure) rectangles and lines geometries (into MoveSubGeomLock)
-- 2018.04.17 V1.01b FM Manage new ddf parameters for viewers, louver and vision cutouts (to manage different application points)
-- 2018.05.09 V1.01c FM Assign name to all face surfaces ( before only on top and bottom surfaces)
-- 2018.05.17 V1.01d FM Manage position of Groove on narrow face and its surface
-- 2018.05.23 V1.01e FM Manage grove for all 4 sides
-- 2018.06.01 V1.01f FM Manage Z probe geometry near hardware templates
-- 2018.06.15 V1.020 FM Manage Rebuid Door and hardware application by probe point
-- 2018.06.22 V1.021 FM Fix bug on calculate rebuildel door
-- 2018.06.25 V1.022 FM Read different probe distance from dat file and extend line by these values
-- 2018.06.27 V1.023 FM Modify dat table, add manage error messages if dat file is missing and if enable side trim with probe mode
-- 2018.07.18 V1.024 FM Manage new groove parameters into ddf
-- 2018.07.19 V1.025 FM Manage properties field into DDF
-- 2018.07.20 V1.026 FM Fix bug on Strike Half disposition ( modify also EdgePullFlat component)
-- 2018.07.23 V1.027 FM Manage Alias Swing (actually for Haley Bros)
-- 2018.08.24 V1.028 FM Manage data.dat file instead of <ddfname>.dat into LoadDataProbeFile function
-- 2018.10.01 V1.029 FM Manage read zero value parameter (means disable probe in Z) into LoadDataProbeFile function
-- 2018.10.17 V1.02a FM Manage by parameter DGC.Edp ( into CurrDoorsCustomData.lua) differents profiles on Top Arc between top and sdes
-- 2018.10.17 V1.02a FM Fix error on create top arc beveled machining path
-- 2018.10.18 V1.02b FM Manage better recognizing opposite bevel profile (between sides) on Inactive doors
-- 2018.10.19 V1.02c FM Manage better recognize bad swing code from ddf
-- 2018.10.19 V1.02c FM Fix pivot disposition with new offset pivot dispositions
-- 2018.10.22 V1.02d FM Manage reference position (backset or door side) for secure and keyway geometries, for: lock
-- 2018.10.23 V1.02e FM DDF can manage more LouverCutOut items
-- 2018.10.26 V1.02f FM Manage disposition of flush bolt extra geometries
-- 2018.10.31 V1.030 FM Fix error on check backset (when backset is not defined into ddf)
-- 2018.11.09 V1.031 FM Move hinges geometries by new function MoveSubGeomHinge to manage which geometries have to rotate on profile or not
-- 2018.11.16 V1.032 FM Manage OH Stop and Closer aggregate of lua templates
-- 2018.11.26 V1.033 FM Manage Lock hardware disposition also on top and bottom door side by ddf parameter 'side:'
-- 'lock', 'bottom', 'top'. If ddf parameter is missing the default application side is 'lock'
-- 2018.11.30 V1.034 FM Manage RollerLatch hardware disposition also on lock door side
-- 2018.12.06 V1.035 FM Fix error on move keyway geometries into MoveSubGeomFlushBolt function
-- 2018.12.10 V1.036 FM Manage better solid geometry/shape with deepr striker horizontal faces:
-- (Roller latch strike, Edge pull flat, Mortise hinge, Over head Arm, Stop and Closer Arm)
-- 2018.12.11 V1.037 FM Manage reading DDF radius parameter on VisionCutOut with rectangle shape
-- 2018.12.17 V1.038 FM Fix bug on contour machining paths when profiles between head (top, bottom) and side (lock, hinge) are differents
-- 2018.12.18 V1.039 FM Make anti-splint machining path on top bottom side ( for horizontal tool)
-- 2018.12.20 V1.03a FM Extend previous feature V1.033 to different disposition side/reference assigned to ddf parameter 'side:'
-- 'lock_top', 'lock_bottom', 'bottom', 'top'. If ddf parameter is missing the default application side is 'lock_top'
-- 2019.01.15 V1.03b FM Fix error when load old ddf that not have lock reference with 'lock_top', 'lock_bottom' but only 'lock'
-- 2019.03.22 V1.03c FM Make better top arc paths with precise end point
-- 2019.03.29 V1.03d FM Manage Edge break (EB) and Bevel Edge break (BVEB) profiles
-- 2019.04.11 V1.03e FM Fix bug on calculate top arc points with new mode to set side profile (now top and side profiles can be set indipendent)
-- 2019.04.19 V1.03e FM Fix import hinges as nge file
-- 2019.04.29 V1.03f FM Manage new disposition for Flush_pull hardware, now dispose geometries one by one
-- 2019.05.06 V1.040 FM Fix semantic error on assign value = 0 to a not specified variable: tHinge.thickness into GetOneHinge function
-- 2019.05.15 V1.041 FM Manage new hardware type: Decoration
-- 2019.05.21 V1.042 FM Draw short sides on Draw mode only
-- 2019.05.30 V1.043 FM Fix error on calculate negative value for sqrt into CalcSideRectTringle function
-- 2019.07.01 V1.044 FM Manage new probe modes by variable DGC.Pms: 0 old complete probe (8 probe points) and door rebuild;
-- 1: recalculate dimension only on door width (4 probe points); 2: recalculate dimension on door width and length (5 probe points)
-- 2019.08.16 V1.045 FM Fix error on Move strike geometry managed as EdgePull, now it manage also 'upper' geometry in case side face is deep than 1/6 of door thickness
-- 2019.08.16 V1.046 FM Fix error on Move strike geometry managed as EdgePull, now not consider the backset value (that's used for locks and not for EdgePull)
-- 2019.08.27 V1.046 FM Modify the disposition of Pivot, now it move one by one geometry instead of move layer
-- 2019.08.30 V1.047 FM Manage 8 bullnose radius (according to default.ini Compo configuration amd CurrDoorsCustomdata.lua)
-- 2019.09.16 V1.048 FM Identify door properties by DGC settings variables
-- 2019.09.19 V1.049 FM Add manage new ddf side distance parameters for Decoration
-- 2019.10.03 V1.048 FM Remove: identify door properties by DGC settings variables
-- 2019.10.04 V1.049 FM Manage new ddf section: material. Now, by material value, lua components change geometries
-- 2019.10.18 V2.000 FM Manage use Materials
-- 2019.11.11 V2.001 FM Manage Top Chamfer Shape
-- 2019.11.22 V2.002 FM Manage let any profiles (SQ,BV,EB,BVEB,1B,2B,3B,4B,5B,6B,7B,8B,CV) to any sides (Top, Top Arc, Top Angle, Bottom, Hinge, Lock)
-- 2019.12.19 V2.003 FM Fix error on double use of SetInvertEdgeTrimming when bevel lock side is set to opposite bevel
-- 2020.05.06 V2.004 FM Enable roller latch, pivot, flush bolt also on frame bottom
-- 2020.05.18 V2.005 FM Manage frame disposition (on wide side or narrow side) by CurrDoorCustomData parameter DGC.Dxjs (x depend to material)
-- 2020.05.20 V2.006 FM Manage frame disposition narrow face limit by CurrDoorCustomData parameter DGC.Mjn
-- if narros side is smaller than this parameter then frame is dispossed on wide side (wide side on pods)
-- 2020.05.20 V2.007 FM Enable roller latch also on lock jamb, enable lock also on top and bottom frames
-- 2020.10.28 V2.008 FM Fix lock/strike disposition on top and bottom frames
-- 2020.11.12 V2.009 FM Fix flush_bolt disposition on top and bottom frames with or without lock/hinge rabbets
-- 2020.11.13 V2.00a FM Fix type error on definition of name variable sLocalHingeProf was sLocalHingeProfm
-- 2021.02.10 V3.000 FM Manage apply rabbet on opposite face (than standard)
-- 2021.04.23 V3.001 FM set DGD variable if a cut out has not hatching
-- 2021.05.27 V3.002 FM Manage special region (added to main region) from hatching paths to remove pods under hatching paths
-- 2021.06.01 V3.003 FM If not run by dProd, Show a message to update the ddf if ddf parameter 'piece:' not exists
-- 2021.08.05 V3.004 FM Fix error on disposition of geometry used to calculate regions of EdgePull flat hardware
-- 2021.10.11 V3.005 FM I not agree to this modification: manage DGC.Bwd parameter to refer the backset on wide side dimension, but this modification is not
-- for general purpose but apply this reference change only to some geometries that are on keyway/secure faces
-- 2021.10.26 V3.006 FM Manage FD Wedge Cup (FDWC) profile
-- 2021.11.23 V3.007 FM Manage option side probing. Expand function number of CurrDoorCustomData DGC.Pms: 3 side probe on all hardware (for NE machines) ;
-- 4: side probe on all hardware except hardware on hinge side (for machines with shuttles)
-- 2022.01.17 V3.008 FM Manage Split door cut by new Vision CutOut type
-- 2022.03.11 V3.009 FM Fix error (into MoveFlushBolt function) on calculate probe path with corner flush bolt and into InsertProbeGeom when side probe path has not to does
-- 2022.04.12 V3.00a FM Manage better the Sideprobe info into function InsertProbeGeom
-- 2022.04.28 V3.00a FM Manage Split door on door width direction
-- 2022.07.07 V3.00b FM Manage Lock aggregate of lua templates
-- 2022.07.27 V3.00c FM Modification to use compiled code
-- 2022.08.31 V3.00d FM Manage groove applied on top angle
-- 2022.11.15 V3.00e FM Manage side grove region as throu region and not as blind region
-- 2023.04.26 V3.00f FM Manage new DDF format by new ddf version number parameter
-- 2023.04.27 Max num error message DGD.ERR = 28
-- 2023.05.11 V3.010 FM Read new ddf group 'options:' (actually not used) at the end of ddf file
-- 2023.09.07 V3.011 FM try to delete the .tok file (it's a copy of .txt file) that dProd uses
-- 2023.12.01 V3.012 FM Manage new CurrDoorCustomData parameter DGC.CVP to define a small line on both corner of Convex profile
-- 2023.12.04 V3.013 FM Fix errors on build solid with bevel profile on top arc
-- 2024.02.01 V3.014 FM Manage new CurrCamInfo parameter 'SideDoorDefined' to manage door disposition with lock side machined by shuttle/s
-- 2024.07.01 V3.015 FM Fix error (that it appens only with frames) on DGD variable assignemente into InsertGeom function
-- 2024.10.15 V3.016 FM Manage new DGC.NPM parameter to indicate new DGD.PROBE meaning
-- 2024.10.31 V3.017 FM Manage probe id number and note 'ProbeId' on geometries that have hinge or lock probe geometry
-- 202x.xx.xx V3.xxx FM Manage new CurrCamInfo parameter 'WideDoorWidth' to manage large wide doors stored into new DGD.Part parameter
-- 2025.05.06 v2.7e1 DS Correzione funzione SubAndDeleteTempSurf.
-- 2025.10.29 v2.7j3 DS Correzione a SubAndDeleteTempSurf (aggiunto controllo esistenza regioni).
-- 2025.12.16 v2.7l1 DS Aggiunta gestione TrimLTHB per distanze dai bordi del trim decorazioni.
-- 2026.01.07 v3.1a1 DS Gestione indice probe anche per Pivot su Hinge (intermediatepivot).
-- Intestazioni
require( 'EgtBase')
_ENV = EgtProtectGlobal()
EgtEnableDebug( false)
if not _G.DGD then
_G.DGD = {}
end
local sBaseDir = DGD.BASEDIR
EgtAddToPackagePath( sBaseDir .. 'LuaLibs\\?.lua')
EgtAddToPackagePath( sBaseDir .. 'MTables\\?.mtl')
EgtAddToPackagePath( sBaseDir .. '?.lua')
require( 'EgtDoorsBase')
require( 'EgtDoorsData')
require( 'CurrDoorsCustomData')
local EgtDoorsMsg = require( 'EgtDoorsMsg')
-- variabili gestione macchine
local tMachineData
local sMTable
local sMTablePath
local sMTableOri
-- info della porta
local tGenInfo={}
local tProbeDoor={}
local nNumHingePivot = 0
local nCountPieces = 0
local nTypePiece = 0
local sFirstDoor
local sSecondDoor
local sFrameSx
local sFrameDx
local sFrameTop
local sFrameBot
-- variabili dei file
local sFileDir, sFileName, sFileExt
local sErrFileM
local sErrFile
local sTxtOkFile
local sCncFile
local sLogFile
local sNgeFile
local sPrbFile
local sOriPrbFile
-- variabili percorsi creati da probe 2
local nDoorLeft
local nDoorRight
local nDoorTop
local nDoorBot
local nDoorLeftTop
local nDoorRightTop
local nDoorTopTop
local nDoorBotTop
local nDoorLeftMid
local nDoorRightMid
local nDoorTopMid
local nDoorBotMid
local bRemake = false
----------------------------------------------------------------
-- *** Error write file functions ***
-----------------------------------------------------------------
local function WriteErrFile( sFileErr, sDispMsg)
local nIdFile = io.open( sFileErr, 'w')
if nIdFile then
if DGD.ERM and string.len(DGD.ERM) > 0 then
nIdFile:write( 'Err=' .. tostring( DGD.ERR) .. '\n' .. DGD.ERM)
if DGD.EGR == 0 then
DGD.EGR = DGD.ERR
end
if DGD.EGM then
DGD.EGM = DGD.EGM .. '\n' .. DGD.ERM
end
else
nIdFile:write( 'Err=' .. tostring( DGD.ERR))
end
if sDispMsg and string.len(sDispMsg) > 0 then
nIdFile:write('\n' .. sDispMsg)
DoorOutLog( sDispMsg, 0)
if DGD.EGM then
DGD.EGM = DGD.EGM .. '\n' .. sDispMsg
end
end
nIdFile:close()
end
end
local function WriteErrFileAsmbl( sFileErr, sDispMsg)
local nIdFile = io.open( sFileErr, 'w')
if nIdFile then
if DGD.EGR ~= 0 then
nIdFile:write( 'Err=' .. tostring( DGD.EGR) .. DGD.EGM)
else
nIdFile:write( 'Err=' .. tostring( DGD.EGR))
end
if sDispMsg and string.len(sDispMsg) > 0 then
nIdFile:write('\n' .. sDispMsg)
DoorOutLog( sDispMsg, 0)
end
nIdFile:close()
end
end
-----------------------------------------------------------------
-- *** Geometry Calc ***
-----------------------------------------------------------------
local function CalcSideRectTringle( dCat1, dCat2, dIpo)
local dSide = 0
-- se manca ipotenusa
if not dIpo then
dSide = sqrt( ( dCat1 * dCat1) + ( dCat2 * dCat2))
-- se manca cateto 1
elseif not dCat1 then
dSide = sqrt( max( ( dIpo * dIpo) - ( dCat2 * dCat2), 0))
-- se manca cateto 2
elseif not dCat2 then
dSide = sqrt( max( ( dIpo * dIpo) - ( dCat1 * dCat1), 0))
end
return dSide
end
-----------------------------------------------------------------
-- *** DDF file parsing ***
-----------------------------------------------------------------
local function KeyFromLine( sKey)
local sLine = GetLine()
if not sLine then
return false
end
if not sLine:find( sKey, 1, true) then
UngetLine( sLine)
return false
end
return true
end
-----------------------------------------------------------------
local function CheckKeyFromLine( sKey)
local sLine = GetLine()
if not sLine then
return false
end
if not sLine:find( sKey, 1, true) then
UngetLine( sLine)
return false
else
UngetLine( sLine)
end
return true
end
-----------------------------------------------------------------
local function EndOfFile( )
local sLine = GetLine()
if not sLine then
return true
else
UngetLine( sLine)
return nil
end
end
-----------------------------------------------------------------
local function StringFromLine( sKey)
local sLine = GetLine()
if not sLine then
return nil
end
if not sLine:find( sKey, 1, true) then
UngetLine( sLine)
return nil
end
local sVal = sLine:gsub( sKey, '')
return EgtTrim( sVal)
end
-----------------------------------------------------------------
local function LenFromLine( sKey, bNotConv)
local sVal = StringFromLine( sKey)
if not sVal then return nil end
local dVal = tonumber( sVal)
if not dVal then return nil end
if not bNotConv and not DGD.bMM then dVal = dVal * GEO.ONE_INCH end
return dVal
end
-----------------------------------------------------------------
local function GetVersion()
-- leggo il parametro di produzione del pezzo
local nPr = LenFromLine( 'version:', true)
if not nPr then
DGD.nVersion = 1
else
DGD.nVersion = nPr
end
-- salvo in tabella
table.insert( tGenInfo, {'DDF version', DGD.nVersion})
return true
end
-----------------------------------------------------------------
local function GetProoduce()
-- leggo il parametro di produzione del pezzo
local sPr = StringFromLine( 'produce:')
if not sPr then
DGD.bProoduce = true
else
-- la interpreto
DGD.bProoduce = sPr == 'true'
end
-- salvo in tabella
table.insert( tGenInfo, {'Produce',DGD.bProoduce})
return true
end
-----------------------------------------------------------------
local function GetMeasures()
-- leggo l'unità di misura
local sUM = StringFromLine( 'measures:')
if not sUM then return false end
-- la interpreto
DGD.bMM = not ( sUM == 'inches')
-- salvo in tabella
table.insert( tGenInfo, {'MM',DGD.bMM})
return true
end
-----------------------------------------------------------------
local function GetCode()
-- leggo il codice
DGD.sCode = StringFromLine( 'code:')
if not ( DGD.sCode and DGD.sCode:len() > 0) then
return false
end
-- salvo in tabella
table.insert( tGenInfo, {'Code',DGD.sCode})
return true
end
-----------------------------------------------------------------
local function GetOrder()
-- leggo la chiave
if not KeyFromLine( 'order:') then
return false
end
-- leggo tutte le voci dell'ordine
line = GetLine()
while line do
-- se trovo la data ho finito
if line:find( 'date:', 1, true) then
UngetLine( line)
break
end
-- leggo la voce
line = EgtTrim( line)
table.insert( DGD.tOrder, line)
-- leggo la prossima linea utile
line = GetLine()
end
-- salvo in tabella
table.insert( tGenInfo, {'Order', table.concat( DGD.tOrder, ',')})
return true
end
-----------------------------------------------------------------
local function GetDate()
-- leggo la data
DGD.sDate = StringFromLine( 'date:')
if not ( DGD.sDate and DGD.sDate:len() > 0) then
return false
end
-- salvo in tabella
table.insert( tGenInfo, {'Date',DGD.sDate})
return true
end
-----------------------------------------------------------------
local function GetPiece()
-- leggo se è un pezzo porta o telaio
local sPiece = StringFromLine( 'piece:')
-- se non trovato Piece assegno codice come porta singola e visualizzo un avviso
if not ( sPiece and sPiece:len() > 0) then
nTypePiece = 1
DGD.nTypePz = nTypePiece
DoorOutLog( string.format( EgtDoorsMsg[691], DGD.FILE), 0)
if not DGD.NCGEN then
EgtOutBox( string.format(EgtDoorsMsg[691], DGD.FILE), EgtDoorsMsg[501], EgtDoorsMsg[502])
end
return false
end
if string.find( sPiece, 'DO_1') then
nTypePiece = 1
DGD.sFrame = nil
elseif string.find( sPiece, 'DO_2') then
nTypePiece = 2
DGD.sFrame = nil
elseif string.find( sPiece, 'FL_') then
nTypePiece = 3
DGD.sFrame = string.gsub( sPiece, 'FL_', '')
elseif string.find( sPiece, 'FR_') then
nTypePiece = 4
DGD.sFrame = string.gsub( sPiece, 'FR_', '')
elseif string.find( sPiece, 'FT_') then
nTypePiece = 5
DGD.sFrame = string.gsub( sPiece, 'FT_', '')
elseif string.find( sPiece, 'FB_') then
nTypePiece = 6
DGD.sFrame = string.gsub( sPiece, 'FB_', '')
else
nTypePiece = 1
DGD.sFrame = nil
end
DGD.nTypePz = nTypePiece
-- salvo in tabella
table.insert( tGenInfo, {'Frame',DGD.sFrame})
table.insert( tGenInfo, {'Piece Type',nTypePiece})
return true
end
-----------------------------------------------------------------
local function GetPosition()
if not KeyFromLine( 'position:') then
return false
end
-- leggo la posizione in X
table.insert( DGD.tPosition, LenFromLine( 'x:'))
-- leggo la posizione in Y
table.insert( DGD.tPosition, LenFromLine( 'y:'))
-- leggo la posizione in Z
table.insert( DGD.tPosition, LenFromLine( 'z:'))
if not ( DGD.tPosition[1] and DGD.tPosition[2] and DGD.tPosition[3]) then
return false
end
table.insert( tGenInfo, {'PosFromDoor', DGD.tPosition})
return true
end
-----------------------------------------------------------------
local function GetSize()
-- leggo la chiave
if not KeyFromLine( 'size:') then
return false
end
-- leggo la larghezza
DGD.dW = LenFromLine( 'width:')
-- leggo l'altezza
DGD.dH = LenFromLine( 'height:')
-- leggo lo spessore
DGD.dT = LenFromLine( 'thickness:')
-- leggo la pressione
local sPressure = StringFromLine( 'pressure:') or '0'
DGD.Pressure = tonumber(sPressure)
if DGD.Pressure < 0 then
DGD.Pressure = 0
elseif DGD.Pressure > 20 then
DGD.Pressure = 20
end
-- verifico le letture
if not ( DGD.dW and DGD.dH and DGD.dT) then
return false
end
-- salvo in tabella
if DGD.sFrame then
if DGD.nTypePz == 5 or DGD.nTypePz == 6 then
table.insert( tGenInfo, {'W',DGD.dT})
table.insert( tGenInfo, {'H',DGD.dW})
table.insert( tGenInfo, {'T',DGD.dH})
else
table.insert( tGenInfo, {'W',DGD.dT})
table.insert( tGenInfo, {'H',DGD.dH})
table.insert( tGenInfo, {'T',DGD.dW})
end
else
table.insert( tGenInfo, {'W',DGD.dW})
table.insert( tGenInfo, {'H',DGD.dH})
table.insert( tGenInfo, {'T',DGD.dT})
end
table.insert( tGenInfo, {'P',DGD.Pressure})
return true
end
-----------------------------------------------------------------
local function GetDoorHeight()
-- leggo l'altezza originale porta
DGD.dOH = LenFromLine( 'origdoorheight:')
if not DGD.dOH then
return false
end
-- salvo in tabella
table.insert( tGenInfo, {'OH', DGD.dOH})
return true
end
-----------------------------------------------------------------
local function GetSwing()
-- leggo il brandeggio
DGD.sAliasSwng = StringFromLine( 'swing:')
if not ( DGD.sAliasSwng and #DGD.sAliasSwng > 0) then
return false, ''
end
DGD.sAliasSwng = string.upper(DGD.sAliasSwng)
-----------------------------------------------------
-- interpretazione swing e gestione alias per Haley
-----------------------------------------------------
if DGD.sAliasSwng == 'LW' or DGD.sAliasSwng == 'RM' or DGD.sAliasSwng == 'BLANK' then -- alias per RH
DGD.sSwing = 'RH'
elseif DGD.sAliasSwng == 'RW' or DGD.sAliasSwng == 'LM' then -- alias per LH
DGD.sSwing = 'LH'
else -- per tutti gli altri casi
if DGD.sAliasSwng == 'RH' or DGD.sAliasSwng == 'RHA' or DGD.sAliasSwng == 'RHI' or
DGD.sAliasSwng == 'RHR' or DGD.sAliasSwng == 'RHRA' or DGD.sAliasSwng == 'RHRI' or
DGD.sAliasSwng == 'LH' or DGD.sAliasSwng == 'LHA' or DGD.sAliasSwng == 'LHI' or
DGD.sAliasSwng == 'LHR' or DGD.sAliasSwng == 'LHRA' or DGD.sAliasSwng == 'LHRI' then
DGD.sSwing = DGD.sAliasSwng
else
return false, DGD.sAliasSwng
end
end
-- salvo in tabella
table.insert( tGenInfo, {'AliasSwing', DGD.sAliasSwng})
table.insert( tGenInfo, {'Swing', DGD.sSwing})
return true
end
-----------------------------------------------------------------
local function GetSecurSide()
-- leggo la disposzione del lato secure
DGD.sSecSide = StringFromLine( 'secure:')
if not ( DGD.sSecSide and #DGD.sSecSide > 0) then
return false
end
-- salvo in tabella
table.insert( tGenInfo, {'Secure', DGD.sSecSide})
return true
end
-----------------------------------------------------------------
local function GetDoorMaterial()
-- leggo il materiale porta
DGD.Material = StringFromLine( 'material:')
if not DGD.Material then
return false
end
-- se nome materiale esiste tolgo eventuali spazi vuoti
if #DGD.Material > 0 then
DGD.Material = string.gsub( DGD.Material, ' ', '')
else
return false
end
-- salvo in tabella
table.insert( tGenInfo, {'Material', DGD.Material})
return true
end
-----------------------------------------------------------------
local function GetDoorProperties()
-- leggo i parametri di proprietà
local sProperties = StringFromLine( 'properties:')
if not ( sProperties and sProperties:len() > 0) then
return false
end
-- converto in tabella
DGD.Properties = EgtSplitString( sProperties)
-- salvo in tabella
table.insert( tGenInfo, {'Properties', sProperties})
return true
end
-----------------------------------------------------------------
local function GetOneProfile( sName, nFindTopCurve)
local tProf = {}
-- tProf.trimming = EgtIf( DGD.sFrame, 'SQ', StringFromLine( sName..':'))
tProf.trimming = StringFromLine( sName..':')
if DGD.nVersion >= 2 then
tProf.trimming = StringFromLine( 'type:')
end
if not ( #tProf.trimming > 0) then
if DGD.nVersion >= 2 then
return 11
else
return 5
end
end
if StringFromLine( 'machining:') == 'ON' then
tProf.machining = true
else
tProf.machining = false
end
tProf.offset = LenFromLine( 'overmaterial:')
if not tProf.offset then
return 1
end
if nFindTopCurve == 1 and not DGD.sFrame then
tProf.radius = LenFromLine( 'radius:')
tProf.xdeltapos = LenFromLine( 'posx:')
tProf.angle = LenFromLine( 'angle:', true)
-- se c'è il parametro del raggio e dell'angolo do errore
if tProf.angle and tProf.radius then
return 6
-- se c'è l'angolo ma non il parametro della posizione x do errore
elseif tProf.angle and not tProf.xdeltapos then
return 7
elseif tProf.angle and abs(tProf.angle) < GEO.EPS_SMALL then
tProf.angle = nil
tProf.xdeltapos = 0
-- se c'è l'angolo e il parametro della posizione centro/inizio angolo in x è negativo, cambio di segno senza dare errore
elseif tProf.angle and tProf.xdeltapos < 0 then
tProf.xdeltapos = abs(tProf.xdeltapos)
-- se c'è l'angolo e il parametro posizione supera o eguaglia la larghezza porta azzero l'angolo e non do errore
elseif tProf.angle and tProf.xdeltapos > DGD.dW then
tProf.xdeltapos = 0
tProf.angle = 0
-- se c'è l'angolo e il suo valore supera i 45° do errore
elseif tProf.angle and abs(tProf.angle) > 45 then
return 9
-- se c'è l'angolo e la risultante della parte inclinata in Y supera l'altezza porta do errore
elseif tProf.angle and abs((( DGD.dW - tProf.xdeltapos)*tan(abs(tProf.angle))) - DGD.dH) < GEO.EPS_SMALL*1000 then
return 10
-- se c'è il parametro del centro in x ma non c'è il raggio o l'angolo do errore
elseif tProf.xdeltapos and not tProf.radius and not tProf.angle then
return 2
-- se il raggio è inferiore alla metà larghezza porta do errore
elseif tProf.radius and tProf.radius < (DGD.dW/2) then
return 3
-- Se la posizione X del centro sommata alla metà larghezza porta è maggiore del raggio
-- do errore perché non crea un arco che va tangente o secante al lato della porta opposto alla
-- posizione X del centro
elseif tProf.radius and tProf.xdeltapos and
abs(tProf.xdeltapos) + (DGD.dW/2) > tProf.radius then
return 3
-- se profilo ad arco controllo i settaggi dei profili consentiti
elseif tProf.radius then
if DGC.Edp then -- se sono consentiti i profili differenti tra top e sides
-- in questo caso almeno i due lati devono essere uguali, se non lo sono do errore
-- if DGD.tProfs.lockedge.trimming ~= DGD.tProfs.hingeedge.trimming then
-- return 4
-- end
-- altrimenti se non sono consentiti differenti profili tra top e sides e non lo sono do errore
elseif DGD.tProfs.lockedge.trimming ~= tProf.trimming or DGD.tProfs.hingeedge.trimming ~= tProf.trimming then
return 4
end
end
end
DGD.tProfs[sName] = tProf
-- salvo in tabella
table.insert( tGenInfo, { sName..'_trimming',tProf.trimming})
table.insert( tGenInfo, { sName..'_machining',tProf.machining})
table.insert( tGenInfo, { sName..'_offset',tProf.offset})
if nFindTopCurve == 1 then
if tProf.radius then
table.insert( tGenInfo, { sName..'_radius',tProf.radius})
end
if tProf.xdeltapos then
table.insert( tGenInfo, { sName..'_xdeltapos',tProf.xdeltapos})
end
if tProf.angle then
table.insert( tGenInfo, { sName..'_angle',tProf.angle})
end
end
return 0
end
-----------------------------------------------------------------
local function GetProfiles()
-- leggo la chiave
if not KeyFromLine( 'profiles:') then
return 1
end
-- leggo le diverse parti
local nCodeErr = GetOneProfile( 'lockedge', 0)
if nCodeErr > 0 then
return nCodeErr
end
nCodeErr = GetOneProfile( 'hingeedge', 0)
if nCodeErr > 0 then
return nCodeErr
end
nCodeErr = GetOneProfile( 'top', 1)
if nCodeErr > 0 then
return nCodeErr
end
nCodeErr = GetOneProfile( 'bottom', 0)
if nCodeErr > 0 then
return nCodeErr
end
return 0
end
-----------------------------------------------------------------
local function GetOneVisionCutOut()
local tVision = {}
tVision.shape = StringFromLine( '- shape:')
if not tVision.shape then
return false
end
local sSplit = StringFromLine( 'split:')
tVision.length = LenFromLine( 'length:')
tVision.width = LenFromLine( 'width:')
tVision.dir = StringFromLine( 'direction:')
tVision.top_rail = LenFromLine( 'top_rail:')
tVision.lock_stile = LenFromLine( 'lock_stile:')
tVision.radius = LenFromLine( 'radius:')
tVision.center_from_top = LenFromLine( 'center_from_top:')
tVision.center_from_lock = LenFromLine( 'center_from_lock:')
tVision.door_center = StringFromLine( 'door_center:') or 'lock' -- se nulla assegno vecchio valore default
tVision.split = sSplit == '1'
if ( tVision.split and not tVision.width) or
( sSplit == nil and
not ( tVision.length and tVision.width and tVision.top_rail and tVision.lock_stile) and
not ( tVision.radius and tVision.center_from_top and tVision.center_from_lock)) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[513]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[513])
DGD.ERR = -9
return false
end
-- se ho split abilitato ( == '1')
if tVision.split then
tVision.lock_stile = 0
if not tVision.dir or tVision.dir == '0' then
tVision.door_center = 'center'
tVision.top_rail = 0
else
if not tVision.top_rail then
tVision.top_rail = 0
end
end
-- altrimenti se ho split assente
elseif sSplit == nil then
tVision.split = sSplit
end
table.insert( DGD.tVisions, tVision)
-- salvo in tabella
local sName = 'vision_cut_out'..tostring(#DGD.tVisions)
table.insert( tGenInfo, {sName ..'_shape',tVision.shape})
table.insert( tGenInfo, {sName ..'_split',tVision.split})
table.insert( tGenInfo, {sName ..'_length',tVision.length})
table.insert( tGenInfo, {sName ..'_width',tVision.width})
table.insert( tGenInfo, {sName ..'_direction',tVision.dir})
table.insert( tGenInfo, {sName ..'_top_rail',tVision.top_rail})
table.insert( tGenInfo, {sName ..'_lock_stile',tVision.lock_stile})
table.insert( tGenInfo, {sName ..'_radius',tVision.radius})
table.insert( tGenInfo, {sName ..'_center_from_top',tVision.center_from_top})
table.insert( tGenInfo, {sName ..'_center_from_lock',tVision.center_from_lock})
table.insert( tGenInfo, {sName ..'_door_center',tVision.door_center})
return true
end
-----------------------------------------------------------------
local function GetVisionCutOuts()
-- leggo la chiave
if not KeyFromLine( 'vision_cut_outs:') then
return false
end
-- leggo le diverse sfinestrature
while GetOneVisionCutOut() do
end
return true
end
-----------------------------------------------------------------
local function GetOneLouverCutOut()
local tLouver = {}
tLouver.shape = StringFromLine( '- shape:')
if not tLouver.shape then
return false
end
tLouver.length = LenFromLine( 'length:')
tLouver.width = LenFromLine( 'width:')
tLouver.bottom_rail = LenFromLine( 'bottom_rail:')
tLouver.lock_stile = LenFromLine( 'lock_stile:')
tLouver.door_center = StringFromLine( 'door_center:') or 'lock' -- se nulla assegno vecchio valore default
if not ( tLouver.length and tLouver.width and tLouver.bottom_rail and tLouver.lock_stile) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[514]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[514])
DGD.ERR = -9
return false
end
table.insert( DGD.tLouvers, tLouver)
-- salvo in tabella
local sName = 'louver_cut_out'..tostring(#DGD.tLouvers)
table.insert( tGenInfo, {sName ..'_shape',tLouver.shape})
table.insert( tGenInfo, {sName ..'_length',tLouver.length})
table.insert( tGenInfo, {sName ..'_width',tLouver.width})
table.insert( tGenInfo, {sName ..'_bottom_rail',tLouver.bottom_rail})
table.insert( tGenInfo, {sName ..'_lock_stile',tLouver.lock_stile})
table.insert( tGenInfo, {sName ..'_door_center',tLouver.door_center})
return true
end
-----------------------------------------------------------------
local function GetLouverCutOut()
-- leggo la chiave
if not KeyFromLine( 'louver_cut_outs:') then
return false
end
-- leggo le diverse sfinestrature
while GetOneLouverCutOut() do
end
return true
end
-----------------------------------------------------------------
local function GetOneMailSlot( ) -- i parametri acquisiti in questa funzione e i loro nomi, possono non essere quelli passati
local tMailSlot = {}
tMailSlot.template = StringFromLine( '- template:') -- template o shape ?
if not tMailSlot.template then
return false
end
tMailSlot.length = LenFromLine( 'height:') -- cambiato nome parametro da length a height
tMailSlot.bottom_rail = LenFromLine( 'bottom_rail:')
tMailSlot.delta_center = LenFromLine( 'delta_center:') -- nome inventato
if not ( tMailSlot.length and tMailSlot.bottom_rail and tMailSlot.delta_center) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[515]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[515])
DGD.ERR = -9
return false
end
table.insert( DGD.tMailSlots, tMailSlot)
-- salvo in tabella
local sName = 'mail_slot'..tostring(#DGD.tMailSlots)
table.insert( tGenInfo, {sName ..'_template',tMailSlot.template})
table.insert( tGenInfo, {sName ..'_height',tMailSlot.length})
table.insert( tGenInfo, {sName ..'_bottom_rail',tMailSlot.bottom_rail})
table.insert( tGenInfo, {sName ..'_delta_center',tMailSlot.delta_center})
return true
end
-----------------------------------------------------------------
local function GetMailSlots()
-- leggo la chiave
if not KeyFromLine( 'mail_slots:') then
return false
end
-- leggo le diverse sfinestrature
while GetOneMailSlot() do
end
return true
end
-----------------------------------------------------------------
local function GetOneViewer( ) -- i parametri acquisiti in questa funzione e i loro nomi, possono non essere quelli passati
local tViewer = {}
tViewer.template = StringFromLine( '- template:') -- template
if not tViewer.template then
return false
end
tViewer.bottom_rail = LenFromLine( 'bottom_rail:')
tViewer.delta_center = LenFromLine( 'delta_center:') -- nome inventato
tViewer.side = StringFromLine( 'side:')
if not ( tViewer.bottom_rail and tViewer.delta_center) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[516]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[516])
DGD.ERR = -9
return false
end
table.insert( DGD.tViewers, tViewer)
-- salvo in tabella
local sName = 'viewer'..tostring(#DGD.tViewers)
table.insert( tGenInfo, {sName ..'_template',tViewer.template})
table.insert( tGenInfo, {sName ..'_bottom_rail',tViewer.bottom_rail})
table.insert( tGenInfo, {sName ..'_delta_center',tViewer.delta_center})
table.insert( tGenInfo, {sName ..'_side',tViewer.side})
return true
end
-----------------------------------------------------------------
local function GetViewers()
-- leggo la chiave
if not KeyFromLine( 'viewers:') then
return false
end
-- leggo le diverse sfinestrature
while GetOneViewer() do
end
return true
end
-----------------------------------------------------------------
local function GetOneFlushPull()
local tFlushPull = {}
tFlushPull.template = StringFromLine( '- template:') -- template o shape ?
if not tFlushPull.template then
return false
end
tFlushPull.position = LenFromLine( 'position:')
tFlushPull.back_set = LenFromLine( 'back_set:')
tFlushPull.depth = LenFromLine( 'depth:')
tFlushPull.face = StringFromLine( 'face:')
if not ( tFlushPull.position and tFlushPull.back_set) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[517]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[517])
DGD.ERR = -9
return false
end
table.insert( DGD.tFlushPulls, tFlushPull)
-- salvo in tabella
local sName = 'flush_pull'..tostring(#DGD.tFlushPulls)
table.insert( tGenInfo, {sName ..'_template',tFlushPull.template})
table.insert( tGenInfo, {sName ..'_position',tFlushPull.position})
table.insert( tGenInfo, {sName ..'_back_set',tFlushPull.back_set})
table.insert( tGenInfo, {sName ..'_depth',tFlushPull.depth})
table.insert( tGenInfo, {sName ..'_face',tFlushPull.face})
return true
end
-----------------------------------------------------------------
local function GetFlushPulls()
-- leggo la chiave
if not KeyFromLine( 'flush_pulls:') then
return false
end
-- leggo le diverse sfinestrature
while GetOneFlushPull() do
end
return true
end
-----------------------------------------------------------------
local function GetOneHinge( )
local tHinge = {}
tHinge.template = StringFromLine( '- template:')
if not tHinge.template then
return false
end
tHinge.position = LenFromLine( 'ToptoTop:')
if not tHinge.position then
tHinge.position = LenFromLine( 'ToptoCL:')
end
tHinge.back_set = LenFromLine( 'back_set:')
tHinge.thickness = LenFromLine( 'thickness:')
-- if not tHinge.thickness then tHinge.thickness = 0 end
if not ( tHinge.position and tHinge.back_set) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[518]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[518])
DGD.ERR = -9
return false
end
table.insert( DGD.tHinges, tHinge)
-- salvo in tabella
local sName = 'hinge'..tostring(#DGD.tHinges)
table.insert( tGenInfo, {sName ..'_template',tHinge.template})
table.insert( tGenInfo, {sName ..'_position',tHinge.position})
table.insert( tGenInfo, {sName ..'_back_set',tHinge.back_set})
table.insert( tGenInfo, {sName ..'_thickness',tHinge.thickness})
return true
end
-----------------------------------------------------------------
local function GetHinges()
-- leggo la chiave
if not KeyFromLine( 'hinges:') then
return false
end
-- leggo le diverse parti
while GetOneHinge() do
end
return true
end
-----------------------------------------------------------------
local function GetOneEPT( )
local tEPT = {}
tEPT.template = StringFromLine( '- template:')
if not tEPT.template then
return false
end
tEPT.position = LenFromLine( 'ToptoCL:')
tEPT.back_set = LenFromLine( 'FacetoCL:')
if not ( tEPT.position and tEPT.back_set) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[588]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[588])
DGD.ERR = -9
return false
end
table.insert( DGD.tEPTs, tEPT)
-- salvo in tabella
local sName = 'ept'..tostring(#DGD.tEPTs)
table.insert( tGenInfo, {sName ..'_template',tEPT.template})
table.insert( tGenInfo, {sName ..'_toptocl',tEPT.position})
table.insert( tGenInfo, {sName ..'_facetocl',tEPT.back_set})
return true
end
-----------------------------------------------------------------
local function GetEPT()
-- leggo la chiave
if not KeyFromLine( 'ept:') then
return false
end
-- leggo le diverse parti
while GetOneEPT() do
end
return true
end
-----------------------------------------------------------------
local function GetOneLock( )
local tLock = {}
tLock.template = StringFromLine( '- template:')
if not tLock.template then
return false
end
tLock.position = LenFromLine( 'position:')
tLock.back_set = LenFromLine( 'back_set:')
tLock.offset = LenFromLine( 'offset_WS:')
tLock.side = StringFromLine( 'side:')
tLock.other_door = StringFromLine( 'other_door:')
-- per compatibilità con vecchie versioni, se parametro .side == 'lock' lo rinomino in 'lock_top'
if tLock.side and tLock.side == 'lock' then
tLock.side = 'lock_top'
end
if not ( tLock.position and tLock.back_set) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[519]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[519])
DGD.ERR = -9
return false
end
table.insert( DGD.tLocks, tLock)
-- salvo in tabella
local sName = 'lock'..tostring(#DGD.tLocks)
table.insert( tGenInfo, {sName ..'_template',tLock.template})
table.insert( tGenInfo, {sName ..'_position',tLock.position})
table.insert( tGenInfo, {sName ..'_back_set',tLock.back_set})
table.insert( tGenInfo, {sName ..'_offset_WS',tLock.offset})
table.insert( tGenInfo, {sName ..'_side',tLock.side})
table.insert( tGenInfo, {sName ..'_other_door',tLock.other_door})
return true
end
-----------------------------------------------------------------
local function GetLocks()
-- leggo la chiave
if not KeyFromLine( 'locks:') then
return false
end
-- leggo le diverse parti
while GetOneLock() do
end
return true
end
-----------------------------------------------------------------
local function GetOneFlushBolt( )
local tFlushBolt = {}
tFlushBolt.template = StringFromLine( '- template:')
if not tFlushBolt.template then
return false
end
tFlushBolt.type = StringFromLine( 'type:')
tFlushBolt.side = StringFromLine( 'side:')
tFlushBolt.position = LenFromLine( 'position:')
tFlushBolt.offset = LenFromLine( 'offset_WS:')
tFlushBolt.back_set = LenFromLine( 'back_set:')
tFlushBolt.other_door = StringFromLine( 'other_door:')
if not ( tFlushBolt.type and tFlushBolt.side and tFlushBolt.position) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[520]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[520])
DGD.ERR = -9
return false
end
table.insert( DGD.tFlushBolts, tFlushBolt)
-- salvo in tabella
local sName = 'flush bolt'..tostring(#DGD.tFlushBolts)
table.insert( tGenInfo, {sName ..'_template',tFlushBolt.template})
table.insert( tGenInfo, {sName ..'_type',tFlushBolt.type})
table.insert( tGenInfo, {sName ..'_side',tFlushBolt.side})
table.insert( tGenInfo, {sName ..'_position',tFlushBolt.position})
table.insert( tGenInfo, {sName ..'_offset_WS',tFlushBolt.offset})
table.insert( tGenInfo, {sName ..'_back_set',tFlushBolt.back_set})
table.insert( tGenInfo, {sName ..'_other_door',tFlushBolt.other_door})
return true
end
-----------------------------------------------------------------
local function GetFlushBolts()
-- leggo la chiave
if not KeyFromLine( 'flush_bolts:') then
return false
end
-- leggo le diverse parti
while GetOneFlushBolt() do
end
return true
end
-----------------------------------------------------------------
local function GetOneEdgePull()
local tEdgePull = {}
tEdgePull.template = StringFromLine( '- template:')
if not tEdgePull.template then
return false
end
tEdgePull.position = LenFromLine( 'position:')
tEdgePull.offset = LenFromLine( 'offset_WS:')
if not ( tEdgePull.position) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[521]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[521])
DGD.ERR = -9
return false
end
table.insert( DGD.tEdgePulls, tEdgePull)
-- salvo in tabella
local sName = 'edge_pull'..tostring(#DGD.tEdgePulls)
table.insert( tGenInfo, {sName ..'_template',tEdgePull.template})
table.insert( tGenInfo, {sName ..'_position',tEdgePull.position})
table.insert( tGenInfo, {sName ..'_offset_WS',tEdgePull.offset})
return true
end
-----------------------------------------------------------------
local function GetEdgePulls()
-- leggo la chiave
if not KeyFromLine( 'edge_pulls:') then
return false
end
-- leggo le diverse parti
while GetOneEdgePull() do
end
return true
end
-----------------------------------------------------------------
local function GetOneRollerLatch()
local tRollerLatch = {}
tRollerLatch.template = StringFromLine( '- template:')
if not tRollerLatch.template then
return false
end
tRollerLatch.side = StringFromLine( 'side:')
tRollerLatch.position = LenFromLine( 'position:')
tRollerLatch.offset = LenFromLine( 'offset_WS:')
tRollerLatch.other_door = StringFromLine( 'other_door:')
if not ( tRollerLatch.side and tRollerLatch.position) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[522]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[522])
DGD.ERR = -9
return false
end
table.insert( DGD.tRollerLatchs, tRollerLatch)
-- salvo in tabella
local sName = 'roller_latch'..tostring(#DGD.tRollerLatchs)
table.insert( tGenInfo, {sName ..'_template',tRollerLatch.template})
table.insert( tGenInfo, {sName ..'_side',tRollerLatch.side})
table.insert( tGenInfo, {sName ..'_position',tRollerLatch.position})
table.insert( tGenInfo, {sName ..'_offset_WS',tRollerLatch.offset})
table.insert( tGenInfo, {sName ..'_other_door',tRollerLatch.other_door})
return true
end
-----------------------------------------------------------------
local function GetRollerLatchs()
-- leggo la chiave
if not KeyFromLine( 'roller_latchs:') then
return false
end
-- leggo le diverse parti
while GetOneRollerLatch() do
end
return true
end
-----------------------------------------------------------------
local function GetOnePivot()
local tPivot = {}
tPivot.template = StringFromLine( '- template:')
if not tPivot.template then
return false
end
tPivot.type = StringFromLine( 'type:')
tPivot.side = StringFromLine( 'side:')
tPivot.radius = LenFromLine( 'radius:')
tPivot.position = LenFromLine( 'position:')
tPivot.back_set = LenFromLine( 'back_set:')
tPivot.depth_f = LenFromLine( 'depth:')
tPivot.offset = LenFromLine( 'offset_WS:')
tPivot.other_door = StringFromLine( 'other_door:')
if not ( tPivot.type and tPivot.side and tPivot.position and tPivot.back_set) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[523]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[523])
DGD.ERR = -9
return false
end
table.insert( DGD.tPivots, tPivot)
-- salvo in tabella
local sName = 'pivot'..tostring(#DGD.tPivots)
table.insert( tGenInfo, {sName ..'_template',tPivot.template})
table.insert( tGenInfo, {sName ..'_type',tPivot.type})
table.insert( tGenInfo, {sName ..'_side',tPivot.side})
table.insert( tGenInfo, {sName ..'_radius',tPivot.radius})
table.insert( tGenInfo, {sName ..'_position',tPivot.position})
table.insert( tGenInfo, {sName ..'_back_set',tPivot.back_set})
table.insert( tGenInfo, {sName ..'_depth',tPivot.depth_f})
table.insert( tGenInfo, {sName ..'_offset_WS',tPivot.offset})
table.insert( tGenInfo, {sName ..'_other_door',tPivot.other_door})
return true
end
-----------------------------------------------------------------
local function GetPivots()
-- leggo la chiave
if not KeyFromLine( 'pivot:') then
return false
end
-- leggo le diverse parti
while GetOnePivot() do
end
return true
end
-----------------------------------------------------------------
local function GetOneStopAndCloser( )
local tStopAndCloser = {}
tStopAndCloser.template = StringFromLine( '- template:')
if not tStopAndCloser.template then
return false
end
tStopAndCloser.position = LenFromLine( 'position:')
tStopAndCloser.pocket_offset = LenFromLine( 'pocket_offset_WS:')
tStopAndCloser.other_door = StringFromLine( 'other_door:')
if not ( tStopAndCloser.position) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[524]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[524])
DGD.ERR = -9
return false
end
table.insert( DGD.tStopsAndClosers, tStopAndCloser)
-- salvo in tabella
local sName = 'StopAndCloser'..tostring(#DGD.tStopsAndClosers)
table.insert( tGenInfo, {sName ..'_template',tStopAndCloser.template})
table.insert( tGenInfo, {sName ..'_position',tStopAndCloser.position})
table.insert( tGenInfo, {sName ..'_pocket_offset',tStopAndCloser.pocket_offset})
table.insert( tGenInfo, {sName ..'_other_door',tStopAndCloser.other_door})
return true
end
-----------------------------------------------------------------
local function GetStopsAndClosers()
-- leggo la chiave
if not KeyFromLine( 'stops_and_closers:') then
return false
end
-- leggo le diverse parti
while GetOneStopAndCloser() do
end
return true
end
-----------------------------------------------------------------
local function GetOneOHead( )
local tOHead = {}
tOHead.template = StringFromLine( '- template:')
if not tOHead.template then
return false
end
tOHead.pockpos = LenFromLine( 'point_to_pocket:')
tOHead.pocklength = LenFromLine( 'pocket_length:')
tOHead.pocket_offset = LenFromLine( 'pocket_offset_WS:')
tOHead.armpos = LenFromLine( 'point_to_arm:')
tOHead.armlength = LenFromLine( 'arm_length:')
tOHead.other_door = StringFromLine( 'other_door:')
if not ( tOHead.pockpos and tOHead.pocklength and
tOHead.armpos and tOHead.armlength) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[525]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[525])
DGD.ERR = -9
return false
end
table.insert( DGD.tOHeads, tOHead)
-- salvo in tabella
local sName = 'OverHead'..tostring(#DGD.tOHeads)
table.insert( tGenInfo, {sName ..'_template',tOHead.template})
table.insert( tGenInfo, {sName ..'_point_to_pocket',tOHead.pockpos})
table.insert( tGenInfo, {sName ..'_pocket_length',tOHead.pocklength})
table.insert( tGenInfo, {sName ..'_pocket_offset_WS',tOHead.pocket_offset})
table.insert( tGenInfo, {sName ..'_point_to_arm',tOHead.armpos})
table.insert( tGenInfo, {sName ..'_arm_length',tOHead.armlength})
table.insert( tGenInfo, {sName ..'_other_door',tOHead.other_door})
return true
end
-----------------------------------------------------------------
local function GetOverHeads()
-- leggo la chiave
if not KeyFromLine( 'oh_stop_closer:') then
return false
end
-- leggo le diverse parti
while GetOneOHead() do
end
return true
end
-----------------------------------------------------------------
local function GetOneStrike( )
local tStrike = {}
tStrike.template = StringFromLine( '- template:')
if not tStrike.template then
return false
end
tStrike.position = LenFromLine( 'position:')
tStrike.back_set = LenFromLine( 'back_set:')
tStrike.offset = LenFromLine( 'offset_WS:')
tStrike.other_door = StringFromLine( 'other_door:')
if not ( tStrike.position and tStrike.back_set) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[538]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[538])
DGD.ERR = -9
return false
end
if not DGD.sFrame or DGD.sFrame == 'L' or DGD.sFrame == 'LE' then
table.insert( DGD.tStrikes, tStrike)
-- salvo in tabella
local sName = 'strike'..tostring(#DGD.tStrikes)
table.insert( tGenInfo, {sName ..'_template',tStrike.template})
table.insert( tGenInfo, {sName ..'_position',tStrike.position})
table.insert( tGenInfo, {sName ..'_back_set',tStrike.back_set})
table.insert( tGenInfo, {sName ..'_offset_WS',tStrike.offset})
table.insert( tGenInfo, {sName ..'_other_door',tStrike.other_door})
end
return true
end
-----------------------------------------------------------------
local function GetStrikes()
-- leggo la chiave
if not KeyFromLine( 'strikes:') then
return false
end
-- leggo le diverse parti
while GetOneStrike() do
end
return true
end
-----------------------------------------------------------------
local function GetOneGroove( )
local tGroove = {}
tGroove.template = StringFromLine( '- template:')
if not tGroove.template then
return false
end
tGroove.type = StringFromLine( 'type:')
tGroove.width = LenFromLine( 'width:')
tGroove.depth = LenFromLine( 'depth:')
tGroove.fst = LenFromLine( 'face skin thick:')
tGroove.hst = LenFromLine( 'hinge style thick:')
tGroove.lst = LenFromLine( 'lock style thick:')
tGroove.groove_offset = LenFromLine( 'offset_WS:')
tGroove.side = StringFromLine( 'side:')
if not ( tGroove.type and tGroove.width and tGroove.depth) and
not ( tGroove.type and tGroove.fst and tGroove.hst and tGroove.lst and tGroove.depth) then
-- messaggio errore dati incongruenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[539]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[539])
DGD.ERR = -9
return false
end
table.insert( DGD.tGrooves, tGroove)
-- salvo in tabella
local sName = 'Groove'..tostring(#DGD.tGrooves)
table.insert( tGenInfo, {sName ..'_template',tGroove.template})
table.insert( tGenInfo, {sName ..'_type',tGroove.type})
table.insert( tGenInfo, {sName ..'_width',tGroove.width})
table.insert( tGenInfo, {sName ..'_depth',tGroove.depth})
table.insert( tGenInfo, {sName ..'_face_skin_thick',tGroove.fst})
table.insert( tGenInfo, {sName ..'_hinge_skin_thick',tGroove.hst})
table.insert( tGenInfo, {sName ..'_lock_skin_thick',tGroove.lst})
table.insert( tGenInfo, {sName ..'_offset_WS',tGroove.groove_offset})
table.insert( tGenInfo, {sName ..'_side',tGroove.side})
return true
end
-----------------------------------------------------------------
local function GetGrooves()
-- leggo la chiave
if not KeyFromLine( 'groove:') then
return false
end
-- leggo le diverse parti
while GetOneGroove() do
end
return true
end
-----------------------------------------------------------------
local function GetOneRabbet( )
local tRabbet = {}
tRabbet.template = StringFromLine( '- template:')
if not tRabbet.template then
return false
end
tRabbet.side = StringFromLine( 'side:')
tRabbet.width = LenFromLine( 'width:')
tRabbet.depth = LenFromLine( 'depth:')
tRabbet.angle = LenFromLine( 'angle:', true)
tRabbet.oppo = LenFromLine( 'opposite:', true)
if not ( tRabbet.side and tRabbet.width and tRabbet.depth) then
-- messaggio errore dati inconguenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[550]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[550])
DGD.ERR = -9
return false
end
table.insert( DGD.tRabbets, tRabbet)
-- salvo in tabella
local sName = 'Rabbet'..tostring(#DGD.tRabbets)
table.insert( tGenInfo, {sName ..'_template',tRabbet.template})
table.insert( tGenInfo, {sName ..'_side',tRabbet.side})
table.insert( tGenInfo, {sName ..'_width',tRabbet.width})
table.insert( tGenInfo, {sName ..'_depth',tRabbet.depth})
table.insert( tGenInfo, {sName ..'_angle',tRabbet.angle})
table.insert( tGenInfo, {sName ..'_opposite',tRabbet.oppo})
return true
end
-----------------------------------------------------------------
local function GetRabbets()
-- leggo la chiave
if not KeyFromLine( 'rabbet:') then
return false
end
-- leggo le diverse parti
while GetOneRabbet() do
-- se è un frame lato lock o hinge, Exterior
if DGD.sFrame and
( DGD.sFrame == 'LE' or DGD.sFrame == 'HE' or DGD.sFrame == 'TE' or DGD.sFrame == 'BE') then
-- prendo il parametro di affondamento del rabbet sul lato
local sRabbetType = DGD.tRabbets[#DGD.tRabbets].side
if sRabbetType == 'hinge' or sRabbetType == 'lock' then
if DGD.dZedExtFrame == 0 then
DGD.dZedExtFrame = DGD.tRabbets[#DGD.tRabbets].depth
end
if DGD.dSideExtFrame == 0 and ( DGD.sFrame == 'LE' or DGD.sFrame == 'HE') then
DGD.dSideExtFrame = DGD.tRabbets[#DGD.tRabbets].depth
end
-- prendo la larghezza del rabbet per il sill( frame bottom) con angolo
if DGD.sFrame == 'LE' or DGD.sFrame == 'HE' then
if DGD.dWidthRabbet == 0 then
DGD.dWidthRabbet = DGD.tRabbets[#DGD.tRabbets].width
end
end
end
end
end
return true
end
-----------------------------------------------------------------
local function GetOneDecoration( )
local tDecoration = {}
tDecoration.template = StringFromLine( '- template:')
if not tDecoration.template then
return false
end
tDecoration.type = StringFromLine( 'type:')
tDecoration.depth = LenFromLine( 'depth:')
tDecoration.dft = LenFromLine( 'topdistance:')
tDecoration.dfb = LenFromLine( 'bottomdistance:')
tDecoration.dfl = LenFromLine( 'lockstiledistance:')
tDecoration.dfh = LenFromLine( 'hingestiledistance:')
tDecoration.face = StringFromLine( 'face:')
if not ( tDecoration.face and tDecoration.type) then
-- messaggio errore dati incongruenti
DoorOutLog( string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[646]), 0)
DGD.ERM = DGD.ERM .. string.format(EgtDoorsMsg[512], GetLineNumber(), EgtDoorsMsg[646])
DGD.ERR = -9
return false
end
table.insert( DGD.tDecorations, tDecoration)
-- salvo in tabella
local sName = 'Face Decoration'..tostring(#DGD.tDecorations)
table.insert( tGenInfo, {sName ..'_template',tDecoration.template})
table.insert( tGenInfo, {sName ..'_type',tDecoration.type})
table.insert( tGenInfo, {sName ..'_depth',tDecoration.depth})
table.insert( tGenInfo, {sName ..'_distance_from_top',tDecoration.dft})
table.insert( tGenInfo, {sName ..'_distance_from_bottom',tDecoration.dfb})
table.insert( tGenInfo, {sName ..'_distance_from_lock',tDecoration.dfl})
table.insert( tGenInfo, {sName ..'_distance_from_hinge',tDecoration.dfh})
table.insert( tGenInfo, {sName ..'_face',tDecoration.face})
return true
end
-----------------------------------------------------------------
local function GetDecorations()
-- leggo la chiave
if not KeyFromLine( 'face_decoration:') then
return false
end
-- leggo le diverse parti
while GetOneDecoration() do
end
return true
end
-----------------------------------------------------------------
local function GetOptions()
-- leggo la chiave
if not KeyFromLine( 'options:') then
return false
end
-- mentre non è finito il file
while not( CheckKeyFromLine( '---') or CheckKeyFromLine( '...') or EndOfFile()) do
-- leggo tutte le voci dell'ordine
line = GetLine()
-- leggo la voce
line = EgtTrim( line)
table.insert( DGD.tOptions, line)
end
-- salvo in tabella
table.insert( tGenInfo, {'Options', table.concat( DGD.tOptions, ',')})
return true
end
-------------------------------------------------------------------------
-- *** Insert probe point into door piece ***
-------------------------------------------------------------------------
local function InsertProbeGeom( nIdGeom, ptPosGeom, ptFromExt, nTypeHw, nNumSide)
if not DGD.sFrame and DGD.MachEn > 0 then
-- cerco se ho delle geometrie di tastatura con gli shuttle su lato hinge o lato lock
local bFoundShuttleProbe
local nIdEnt = EgtGetFirstInGroup( nIdGeom) -- ottengo prima entità
while nIdEnt do
local sNameEnt = EgtGetName( nIdEnt) or ''
if sNameEnt and string.find( sNameEnt, 'Hinge_Probe') or string.find( sNameEnt, 'Shuttle_Probe') or
( string.find( sNameEnt, 'Pivot_Probe') and nNumSide == 1) then
bFoundShuttleProbe = true
break
end
nIdEnt = EgtGetNext(nIdEnt)
end
-- ottengo le note kbs o pbs dal layer
local bExistsKbs = EgtGetInfo( nIdGeom, 'kbs', 'i') or 0
local bExistspbs = EgtGetInfo( nIdGeom, 'pbs', 'i') or 0
local bProbeParGeom = ptPosGeom and ( bExistsKbs > 0 or bExistspbs > 0)
-- foro lato secure e parametri probe esistenti oppure presente shuttle probe
if bFoundShuttleProbe or bProbeParGeom then
DGD.CPR = DGD.CPR + 1
-- assegnazione nota a tutte le geometrie del layer
nIdEnt = EgtGetFirstInGroup( nIdGeom) -- ottengo prima entità
while nIdEnt do
EgtSetInfo( nIdEnt, 'ProbeId', DGD.CPR)
nIdEnt = EgtGetNext(nIdEnt)
end
end
if bProbeParGeom then
-- se prod comanda tastature (completa o solo ricalcolo dimensioni) ed è presente il flag
if DGD.PROBE == 1 and bExistsKbs > 0 then
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.BOTTOM))
local pCenter = Point3d( ptPosGeom:getX(),-ptPosGeom:getY(),0)
local nCircle = EgtArc( nIdGeom, pCenter, 0.25, 0, 360, 0, GDB_RT.GRID)
if nCircle then
EgtModifyCurveThickness( nCircle, -5)
EgtSetName( nCircle,'ProbePoint_secure')
EgtSetInfo( nCircle, 'ProbeId', DGD.CPR)
end
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
end
-- creazione geometria di tastatura laterale
if DGD.PROBE == 0 and bExistspbs > 0 and DGC.Pms and ( DGC.Pms == 3 or ( DGC.Pms == 4 and nTypeHw and nTypeHw ~= 5 and nTypeHw ~= 17)) and ptFromExt then
local nLine = EgtLine( nIdGeom, Point3d( ptFromExt:getX(), ptFromExt:getY(), 0), Point3d( ptPosGeom:getX(), ptPosGeom:getY(), 0), GDB_RT.GLOB)
if nLine then
-- se linea più lunga di un millimetro la accorcio o viceversa se è più corta
local dDist = dist( Point3d( ptFromExt:getX(), ptFromExt:getY(), 0), Point3d( ptPosGeom:getX(), ptPosGeom:getY(), 0))
if dDist < 0.9 or dDist > 1.1 then
EgtTrimExtendCurveByLen( nLine, 1-dDist, Point3d( ptPosGeom:getX(), ptPosGeom:getY(), 0), GDB_RT.GLOB)
end
EgtModifyCurveThickness( nLine, 0)
EgtSetName( nLine,'ProbeSidePoint_secure')
EgtSetInfo( nLine, 'ProbeId', DGD.CPR)
EgtSetInfo( nLine, 'SideApplied', nNumSide)
end
end
end
-- se prod comanda tastature (completa o solo ricalcolo dimensioni) ed è presente il flag inserisco foro lato keyway
-- foro lato keyway
if DGD.PROBE == 1 and bExistsKbs > 0 and ptPosGeom then
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
local pCenter = Point3d( ptPosGeom:getX(),ptPosGeom:getY(),DGD.dT)
local nCircle = EgtArc( nIdGeom, pCenter, 0.25, 0, 360, 0, GDB_RT.GRID)
if nCircle then
EgtModifyCurveThickness( nCircle, -5)
EgtSetName( nCircle,'ProbePoint_keyway')
EgtSetInfo( nCircle, 'ProbeId', DGD.CPR)
end
end
-- creazione geometria di tastatura laterale
if ptPosGeom and DGD.PROBE == 0 and bExistspbs > 0 and DGC.Pms and ( DGC.Pms == 3 or ( DGC.Pms == 4 and nTypeHw and nTypeHw ~= 5 and nTypeHw ~= 17)) and ptFromExt then
local nLine = EgtLine( nIdGeom, Point3d( ptFromExt:getX(), ptFromExt:getY(), DGD.dT), Point3d( ptPosGeom:getX(), ptPosGeom:getY(), DGD.dT), GDB_RT.GLOB)
if nLine then
-- se linea più lunga di un millimetro la accorcio o viceversa se è più corta
local dDist = dist( Point3d( ptFromExt:getX(), ptFromExt:getY(), DGD.dT), Point3d( ptPosGeom:getX(), ptPosGeom:getY(), DGD.dT))
if dDist < 0.9 or dDist > 1.1 then
EgtTrimExtendCurveByLen( nLine, 1-dDist, Point3d( ptPosGeom:getX(), ptPosGeom:getY(), 0), GDB_RT.GLOB)
end
EgtModifyCurveThickness( nLine, 0)
EgtSetName( nLine,'ProbeSidePoint_keyway')
EgtSetInfo( nLine, 'ProbeId', DGD.CPR)
EgtSetInfo( nLine, 'SideApplied', nNumSide)
end
end
end
end
-------------------------------------------------------------------------
-- *** Geometric processing : VISION, LOUVER, MAIL ***
-------------------------------------------------------------------------
local function MoveCutOuts( tCutOut, sSideLk, bPushDr, bImport, nTypeCout)
if not tCutOut then return end
if not tCutOut.geom then return end
if not DGD.SPLIT and DGD.SPLIT ~= nil then return end
local ptPos
local ptRef
local dZedPos = 0
local dExtraPosX = 0
local dExtraPosY = 0
local nAngleBase
local nRadBase
-- setto presenza cutout
DGD.ExistCutOut = true
-- rilevo e setto presenza hatching sfridi
if not EgtGetInfo( tCutOut.geom, 'hatch', 'b') then
DGD.NotExistHatch = true
end
if bImport then dZedPos = DGD.dT end
-- se vision cut out
if nTypeCout == 1 then
if tCutOut.lock_stile and tCutOut.top_rail then
if tCutOut.split and tCutOut.dir and tCutOut.dir == '1' then
if sSideLk == 'L' then -- se serratura a sinistra
dExtraPosX = 0
else
dExtraPosX = DGD.dW - tCutOut.width
end
if abs(tCutOut.top_rail) > 0 then
dExtraPosY = 0
else
dExtraPosY = (DGD.dH - tCutOut.width) / 2
end
else
dExtraPosX = EgtIf( tCutOut.door_center == 'center', (( DGD.dW - tCutOut.width)/2), 0)
end
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
nAngleBase = atan((tCutOut.lock_stile + dExtraPosX),tCutOut.top_rail)
nRadBase = sqrt(((tCutOut.lock_stile + dExtraPosX)*(tCutOut.lock_stile + dExtraPosX))+(tCutOut.top_rail*tCutOut.top_rail))
ptRef = DGD.PminTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A4+nAngleBase)) , dZedPos)
else
ptPos = Point3d( ( tCutOut.lock_stile + dExtraPosX), ( DGD.dH - tCutOut.top_rail - dExtraPosY), dZedPos)
end
else
-- if tCutOut.width < 0 then tCutOut.width = DGD.dW end -- vecchia modalita per creare porta ad arco
if bRemake then
nAngleBase = atan((tCutOut.lock_stile + tCutOut.width + dExtraPosX),tCutOut.top_rail)
nRadBase = sqrt(((tCutOut.lock_stile + tCutOut.width + dExtraPosX)*(tCutOut.lock_stile + tCutOut.width + dExtraPosX))+(tCutOut.top_rail*tCutOut.top_rail))
ptRef = DGD.PmaxTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A7-nAngleBase)) , dZedPos)
else
ptPos = Point3d( ( DGD.dW - tCutOut.lock_stile - tCutOut.width - dExtraPosX), ( DGD.dH - tCutOut.top_rail - dExtraPosY), dZedPos)
end
end
else
dExtraPosX = EgtIf( tCutOut.door_center == 'center', (DGD.dW/2), 0)
if bRemake then
nAngleBase = atan((tCutOut.center_from_lock + dExtraPosX),tCutOut.center_from_top)
nRadBase = sqrt(((tCutOut.center_from_lock + dExtraPosX)*(tCutOut.center_from_lock + dExtraPosX))+(tCutOut.center_from_top*tCutOut.center_from_top))
end
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
ptRef = DGD.PminTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A4+nAngleBase)) , dZedPos)
else
ptPos = Point3d( ( tCutOut.center_from_lock + dExtraPosX), DGD.dH - tCutOut.center_from_top, dZedPos)
end
else
if bRemake then
ptRef = DGD.PmaxTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A7-nAngleBase)) , dZedPos)
else
ptPos = Point3d( ( DGD.dW - tCutOut.center_from_lock - dExtraPosX), DGD.dH - tCutOut.center_from_top, dZedPos)
end
end
end
-- per non scaricare sfrido quando corto e cade
if DGD.LENGTH and DGD.LENGTH < 400 then
DGD.NotExistHatch = false
end
-- se louver cut out
elseif nTypeCout == 2 then
dExtraPosX = EgtIf( tCutOut.door_center == 'center', (( DGD.dW - tCutOut.width)/2), 0)
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
nAngleBase = atan((tCutOut.lock_stile + dExtraPosX),tCutOut.bottom_rail)
nRadBase = sqrt(((tCutOut.lock_stile + dExtraPosX)*(tCutOut.lock_stile + dExtraPosX))+(tCutOut.bottom_rail*tCutOut.bottom_rail))
ptRef = DGD.PminBot
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A3-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A3-nAngleBase)) , dZedPos)
else
ptPos = Point3d( ( tCutOut.lock_stile + dExtraPosX), tCutOut.bottom_rail, dZedPos)
end
else
if bRemake then
nAngleBase = atan((tCutOut.lock_stile + tCutOut.width + dExtraPosX),tCutOut.bottom_rail)
nRadBase = sqrt(((tCutOut.lock_stile + tCutOut.width + dExtraPosX)*(tCutOut.lock_stile + tCutOut.width + dExtraPosX))+(tCutOut.bottom_rail*tCutOut.bottom_rail))
ptRef = DGD.PmaxBot
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A8+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A8+nAngleBase)) , dZedPos)
else
ptPos = Point3d( ( DGD.dW - tCutOut.lock_stile - tCutOut.width - dExtraPosX), tCutOut.bottom_rail, dZedPos)
end
end
-- per non scaricare sfrido quando corto e cade
if DGD.LENGTH and DGD.LENGTH < 400 then
DGD.NotExistHatch = false
end
-- se mail slot
elseif nTypeCout == 6 then
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
nAngleBase = atan((( DGD.dW / 2) + tCutOut.delta_center),tCutOut.bottom_rail)
nRadBase = sqrt(((( DGD.dW / 2) + tCutOut.delta_center)*(( DGD.dW / 2) + tCutOut.delta_center))+(tCutOut.bottom_rail*tCutOut.bottom_rail))
ptRef = DGD.PminBot
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A3-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A3-nAngleBase)) , dZedPos)
else
ptPos = Point3d( ( ( DGD.dW / 2) + tCutOut.delta_center), tCutOut.bottom_rail, dZedPos)
end
else
if bRemake then
nAngleBase = atan((( DGD.dW / 2) - tCutOut.delta_center),tCutOut.bottom_rail)
nRadBase = sqrt(((( DGD.dW / 2) - tCutOut.delta_center)*(( DGD.dW / 2) - tCutOut.delta_center))+(tCutOut.bottom_rail*tCutOut.bottom_rail))
ptRef = DGD.PmaxBot
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A8+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A8+nAngleBase)) , dZedPos)
else
ptPos = Point3d( ( ( DGD.dW / 2) - tCutOut.delta_center), tCutOut.bottom_rail, dZedPos)
end
end
-- per non scaricare sfrido (in questo caso piccolo e cade)
DGD.NotExistHatch = false
end
EgtMove( tCutOut.geom, ptPos - ORIG())
if bRemake then
if abs(dExtraPosX) > 0 or tCutOut.delta_center then
local dAngleLoc
dAngleLoc = (DGD.A3 + DGD.A8) / 2
EgtRotate( tCutOut.geom, ptPos, Z_AX(), ( dAngleLoc-90))
else
EgtRotate( tCutOut.geom, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
end
if bImport then
-- modifica dello spessore di tutte le curve del gruppo
local EntId = EgtGetFirstInGroup( tCutOut.geom)
while EntId do
if EgtGetInfo( EntId, 'ConeCleanCorner', 'b') then
EgtMove( EntId, Vector3d( 0, 0, -DGD.dT))
else
EgtModifyCurveThickness( EntId, -DGD.dT)
end
EntId = EgtGetNext( EntId)
end
-- se non ci sono tagli di hatching
if DGD.NotExistHatch then
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( tCutOut.geom, tCutOut.geom, false)
else
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( tCutOut.geom, tCutOut.geom, false, 1)
end
end
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( tCutOut.geom, tCutOut.geom)
end
-------------------------------------------------------------------------
-- *** Geometric processing : FLUSH_PULL ***
-------------------------------------------------------------------------
local function MoveFlushPull( tFlushPull, sSideLk, bPushDr, bImport)
if not tFlushPull then return end
if not tFlushPull.geom then return end
local ptPos
local ptPosBox
local ptRef
local dZedPos = 0
local nNewEnt
local sTypeInfo
local sKeepBSNote
local nAngleBase
local nRadBase
local nRadBaseBox
-- sul lato keyway o secure
if bImport then
nNewEnt = EgtGetFirstInGroup( tFlushPull.geom) -- ottengo nuova entità
while nNewEnt do
sTypeInfo = EgtGetInfo( nNewEnt, 'SideDoor')
if sTypeInfo then
EgtSetInfo( nNewEnt, 'SideDoor', '')
end
nNewEnt = EgtGetNext(nNewEnt)
end
end
-- setto la faccia dove portare la geometrie
if not DGD.FACE then -- se non ho definito il face la setto come era prima
if bPushDr then -- se porta a spingere la geometria va dietro
DGD.FACE = 'secure'
else -- altrimenti
DGD.FACE = 'keyway'
end
end
if string.lower(DGD.FACE) == 'secure' then -- se specificato face su lato interno (dietro)
-- faccio il mirror di tutte le geometrie su asse Z
nNewEnt = EgtGetFirstInGroup( tFlushPull.geom) -- ottengo nuova entità
while nNewEnt do
EgtMirror( nNewEnt, ORIG(), Z_AX()) -- faccio il mirror su asse Z
nNewEnt = EgtGetNext(nNewEnt)
end
if not bImport then
dZedPos = DGD.dT
InvertSurfName( tFlushPull.geom)
end
else -- altrimenti va su lato esterno (davanti)
if bImport then
dZedPos = DGD.dT
end
end
if bRemake then
nAngleBase = atan(tFlushPull.back_set,tFlushPull.position)
nRadBase = sqrt((tFlushPull.back_set*tFlushPull.back_set)+(tFlushPull.position*tFlushPull.position))
nRadBaseBox = tFlushPull.position
end
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
ptRef = DGD.PminTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A4+nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A4)), ptRef:getY()+(nRadBaseBox*sin(DGD.A4)) , dZedPos)
else
ptPos = Point3d( tFlushPull.back_set, DGD.dH - tFlushPull.position, dZedPos)
ptPosBox = Point3d( 0, DGD.dH - tFlushPull.position, dZedPos)
end
else
if bRemake then
ptRef = DGD.PmaxTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A7-nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A7)), ptRef:getY()+(nRadBaseBox*sin(DGD.A7)) , dZedPos)
else
ptPos = Point3d( DGD.dW - tFlushPull.back_set, DGD.dH - tFlushPull.position, dZedPos)
ptPosBox = Point3d( DGD.dW, DGD.dH - tFlushPull.position, dZedPos)
end
-- faccio il mirror di tutte le geometrie in X
nNewEnt = EgtGetFirstInGroup( tFlushPull.geom) -- ottengo nuova entità
while nNewEnt do
EgtMirror( nNewEnt, ORIG(), X_AX()) -- faccio il mirror in X
nNewEnt = EgtGetNext(nNewEnt)
end
end
-- ciclo spostamento e rotazione di tutte le geometrie del flush_pull
nNewEnt = EgtGetFirstInGroup( tFlushPull.geom) -- ottengo la prima geometria
while nNewEnt do
local bReference = EgtGetInfo( nNewEnt, 'ReferHw', 'b') or false
local ptPosLoc = ptPos
if bReference then
ptPosLoc = Point3d( ptPosBox:getX(), ptPosLoc:getY() , ptPosLoc:getZ())
end
EgtMove( nNewEnt, ptPosLoc - ORIG())
-- EgtSaveFile( sNgeFile)
if bRemake then
EgtRotate( nNewEnt, ptPosLoc, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
-- EgtSaveFile( sNgeFile)
end
AddSurfTmByExtrusion( EgtGetParent(nNewEnt), nNewEnt, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( tFlushPull.geom, tFlushPull.geom)
nNewEnt = EgtGetNext(nNewEnt)
end
--[[
-- spostamento e rotazione del layer del flush_pull
EgtMove( tFlushPull.geom, ptPos - ORIG())
if bRemake then
EgtRotate( tFlushPull.geom, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
if bImport then
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( tFlushPull.geom, tFlushPull.geom, false)
end
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( tFlushPull.geom, tFlushPull.geom)
]]--
-- setto le note per il probe in Z in base a dove si sono piazzate
-- devo ottenere tutte le geometrie
nNewEnt = EgtGetFirstInGroup( tFlushPull.geom) -- ottengo la prima geometria
while nNewEnt do
sKeepBSNote = EgtGetInfo( nNewEnt, 'KeepBackSet')
if sKeepBSNote == 'x' then -- se ha la nota la modifico in funzione a dove è stata piazzata
-- se geometria su lato wide, risetto la nota opportuna
if ( string.lower(DGD.FACE) == 'secure' and bPushDr) or
( string.lower(DGD.FACE) == 'keyway' and not bPushDr) then
EgtSetInfo( nNewEnt, 'KeepBackSet', 'w') -- setto 'w' perché la profondità non passante è applicata sul lato wide
else -- altrimenti è sul lato narrow
EgtSetInfo( nNewEnt, 'KeepBackSet', 'n') -- setto 'n' perché la profondità non passante è applicata sul lato narrow
end
end
nNewEnt = EgtGetNext(nNewEnt)
end
InsertProbeGeom( tFlushPull.geom, ptPos)
end
-----------------------------------------------
-- *** Geometric subgeom processing : HINGE ***
-----------------------------------------------
local function MoveSubGeomHinge( nSubHingeId, sSideDoor, sSideLk, bPushDr, ptPos, nExtraAngle, ptPosUpGeom, ptPosDwGeom)
local nUpperToDelete
-- rinomino eventuali geometrie che descrivono solo la sezione
if sSideDoor and sSideDoor == 'upper' then
if not DGD.Dws then -- se disposizione frame su lato narrow o porta
if bPushDr then
EgtSetInfo( nSubHingeId, 'SideDoor', 'secure')
sSideDoor = 'secure'
else
EgtSetInfo( nSubHingeId, 'SideDoor', 'keyway')
sSideDoor = 'keyway'
end
else
EgtSetInfo( nSubHingeId, 'SideDoor', 'keyway')
sSideDoor = 'keyway'
end
nUpperToDelete = nSubHingeId
end
-- se non ha nota o ha la nota hinge
if not sSideDoor or string.lower( sSideDoor) == 'hinge' then
EgtRotate( nSubHingeId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubHingeId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
else
EgtRotate( nSubHingeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubHingeId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
EgtMove( nSubHingeId, ptPos - ORIG())
elseif sSideDoor == 'locklh' or sSideDoor == 'sidelh' then -- se posizionamento serratura tipo cerniera
if sSideDoor == 'locklh' then
nExtraAngle = 0
end
EgtRotate( nSubHingeId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubHingeId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
else
EgtRotate( nSubHingeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubHingeId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
EgtMove( nSubHingeId, ptPos - ORIG())
elseif sSideDoor == 'keyway' or sSideDoor == 'secure' then
if not DGD.Dws then -- se disposizione frame su lato narrow o porta
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubHingeId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
else
EgtRotate( nSubHingeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubHingeId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
if sSideDoor == 'keyway' then
EgtMove( nSubHingeId, ptPosUpGeom - ORIG())
elseif sSideDoor == 'secure' then
EgtMove( nSubHingeId, ptPosDwGeom - ORIG())
end
else
EgtRotate( nSubHingeId, ORIG(), X_AX(), 90 ) -- ruoto su faccia frontale con angolo
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubHingeId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
else
EgtRotate( nSubHingeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubHingeId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
EgtMove( nSubHingeId, ptPos - ORIG())
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubHingeId), nSubHingeId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubHingeId), EgtGetParent(nSubHingeId))
end
return nUpperToDelete
end
---------------------------------------------
-- *** Geometric subgeom processing : EPT ***
---------------------------------------------
local function MoveSubGeomEpt( nSubEptId, sSideDoor, sSideLk, bPushDr, ptPos, nExtraAngle)
local nUpperToDelete
-- rinomino eventuali geometrie che descrivono solo la sezione
if sSideDoor and sSideDoor == 'upper' then
if DGD.Dws then -- se disposizione frame su lato wide
EgtSetInfo( nSubEptId, 'SideDoor', 'keyway')
sSideDoor = 'keyway'
end
nUpperToDelete = nSubEptId
end
-- se geometria sul fianco
if sSideDoor == 'lock' or sSideDoor == 'side' then
-- if bPushDr then
-- nExtraAngle = - nExtraAngle
-- end
if sSideDoor == 'lock' then
nExtraAngle = 0
end
EgtRotate( nSubEptId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
EgtRotate( nSubEptId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubEptId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubEptId, ptPos - ORIG())
elseif sSideDoor == 'locklh' or sSideDoor == 'sidelh' then -- se posizionamento serratura tipo cerniera
-- cambio di segno ancora un'altra volta
if bPushDr then
nExtraAngle = - nExtraAngle
end
if sSideDoor == 'locklh' then
nExtraAngle = 0
end
EgtRotate( nSubEptId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubEptId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
else
EgtRotate( nSubEptId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubEptId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
EgtMove( nSubEptId, ptPos - ORIG())
elseif sSideDoor == 'keyway' or sSideDoor == 'secure' then
if DGD.Dws then -- se disposizione frame su lato wide
EgtRotate( nSubEptId, ORIG(), X_AX(), 90) -- ruoto su faccia frontale con angolo
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubEptId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
else
EgtRotate( nSubEptId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubEptId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
EgtMove( nSubEptId, ptPos - ORIG())
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubEptId), nSubEptId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubEptId), EgtGetParent(nSubEptId))
end
return nUpperToDelete
end
-----------------------------------------------------------------------
-- *** Geometric processing : common functions for hinge and Ept ***
-----------------------------------------------------------------------
local function MoveGeometryHng( sTypeGeom, nGeomId, sSideLk, bPushDr, ptPos, nExtraAngle, ptPosUpGeom, ptPosDwGeom)
if not nGeomId then return end
-- se profilo lato cerniere è bevel setto il supplemento di rotazione
local nIdGeomType
local sSideDoorToMove
local sMessageErr = ''
if nExtraAngle > 0 and sTypeGeom == 'ept' then
if bPushDr then
nExtraAngle = - nExtraAngle
end
end
-- ottengo la prima geometria
nIdGeomType = EgtGetFirstInGroup( nGeomId)
local nErr = 0
while nIdGeomType do
sSideDoorToMove = EgtGetInfo( nIdGeomType, 'SideDoor')
local nUpperToDelete
if sSideDoorToMove and sTypeGeom == 'ept' then
-- Controllo se la nota è corretta
local sSideDoor = string.lower(sSideDoorToMove)
-- lock: senza rotazione angolo profilo; side: con rotazione angolo profilo; keyway e Secure: no rotazione angolo profilo;
-- SideLH: con rotazione angolo profilo e disposizione come cerniera ( suffisso LH: like hinge), cioè senza effettuare mirror;
-- LockLH: senza rotazione agolo profilo e disposizione come cerniera ( suffisso LH: like hinge), cioè senza effettuare mirror
-- attenzione! la geometria con nota SideLH DEVE ESSERE SIMMETRICA sulla X e Y locale
-- attenzione! la geometria con nota LockLH DEVE ESSERE SIMMETRICA sulla X e Y locale
if sSideDoor == 'lock' or sSideDoor == 'side' or sSideDoor == 'sidelh' or sSideDoor == 'locklh' or sSideDoor == 'upper' then
nUpperToDelete = MoveSubGeomEpt( nIdGeomType, sSideDoor, sSideLk, bPushDr, ptPos, nExtraAngle)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[413],nIdGeomType,'Ept',nGeomId, sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1019
end
else
-- messaggio di errore in base al tipo di pezzo
if sTypeGeom == 'ept' then
sMessageErr = string.format( EgtDoorsMsg[414],nIdGeomType,'Ept',nEdgePId, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1020
else -- altrimenti è hinge
local sSideDoor
-- Acquisisco la nota
if sSideDoorToMove then
sSideDoor = string.lower(sSideDoorToMove)
end
-- SideLH: con rotazione angolo profilo e disposizione come cerniera ( suffisso LH: like hinge), cioè senza effettuare mirror;
-- LockLH: senza rotazione agolo profilo e disposizione come cerniera ( suffisso LH: like hinge), cioè senza effettuare mirror
nUpperToDelete = MoveSubGeomHinge( nIdGeomType, sSideDoor, sSideLk, bPushDr, ptPos, nExtraAngle, ptPosUpGeom, ptPosDwGeom)
end
end
nIdGeomType = EgtGetNext(nIdGeomType)
-- cancello il percorso 'upper'
if nUpperToDelete then
EgtErase( nUpperToDelete)
end
end
-- assegno codice errore se ancora non fatto
if DGD.ERR == 0 then DGD.ERR = nErr end
end
-----------------------------------------------------------------
-- *** Geometric processing : HINGES ***
-----------------------------------------------------------------
local function MoveHinge( tHinge, sSideLk, bPushDr)
if not tHinge then return end
if not tHinge.geom then return end
local dDeltaPos = 0
local sDeltaPos = EgtGetInfo( tHinge.geom, 'DeltaPos')
if sDeltaPos then
dDeltaPos = tonumber( sDeltaPos)
end
if DGD.sFrame then
sSideLk = EgtIf( sSideLk == 'L', 'R', 'L')
end
local ptPos
local ptRef
local ptProbe
local ptFromExt
local dZedPos = EgtIf( bPushDr, 0, DGD.dT)
local ptPosUpGeom
local ptPosDwGeom
if sSideLk == 'L' then -- se serratura a sinistra
if DGD.sFrame then
ptPos = Point3d( DGD.dW - DGD.dZedExtFrame, ( DGD.dH - tHinge.position - dDeltaPos), dZedPos)
ptProbe = Point3d( DGD.dW - DGD.DPR, ( DGD.dH - tHinge.position - dDeltaPos), 0)
else
if bRemake then
ptRef = DGD.PmaxTop
ptPos = Point3d( ptRef:getX()+((tHinge.position + dDeltaPos)*cos(DGD.A7)), ptRef:getY()+((tHinge.position + dDeltaPos)*sin(DGD.A7)) , dZedPos)
else
ptPos = Point3d( DGD.dW, ( DGD.dH - tHinge.position - dDeltaPos), dZedPos)
ptProbe = Point3d( DGD.dW - DGD.DPR, ( DGD.dH - tHinge.position - dDeltaPos), 0)
ptFromExt = Point3d( DGD.dW, ( DGD.dH - tHinge.position - dDeltaPos), 0)
end
end
else -- serratura a destra
if DGD.sFrame then
ptPos = Point3d( DGD.dZedExtFrame, ( DGD.dH - tHinge.position - dDeltaPos), dZedPos)
ptProbe = Point3d( DGD.DPR, ( DGD.dH - tHinge.position - dDeltaPos), 0)
ptFromExt = Point3d( 0, ( DGD.dH - tHinge.position - dDeltaPos), 0)
else
if bRemake then
ptRef = DGD.PminTop
ptPos = Point3d( ptRef:getX()+((tHinge.position + dDeltaPos)*cos(DGD.A4)), ptRef:getY()+((tHinge.position + dDeltaPos)*sin(DGD.A4)) , dZedPos)
else
ptPos = Point3d( 0, ( DGD.dH - tHinge.position - dDeltaPos), dZedPos)
ptProbe = Point3d( DGD.DPR, ( DGD.dH - tHinge.position - dDeltaPos), 0)
ptFromExt = Point3d( 0, ( DGD.dH - tHinge.position - dDeltaPos), 0)
end
end
end
-- setto i punti sulle facce per le geometrie di ingombro
ptPosUpGeom = Point3d( ptPos:getX(), ptPos:getY() , DGD.dT)
ptPosDwGeom = Point3d( ptPos:getX(), ptPos:getY() , 0)
-- se profilo lato cerniera è bevel setto il supplemento di rotazione
local nExtraAngle = 0
if DGD.tProfs.hingeedge.trimming == 'BD' or DGD.tProfs.hingeedge.trimming == 'BU' or
DGD.tProfs.hingeedge.trimming == 'BDEB' or DGD.tProfs.hingeedge.trimming == 'BUEB' then
nExtraAngle = 3
end
MoveGeometryHng( 'hinge', tHinge.geom, sSideLk, bPushDr, ptPos, nExtraAngle, ptPosUpGeom, ptPosDwGeom)
if bRemake then
EgtRotate( tHinge.geom, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A8, DGD.A3)-90))
end
InsertProbeGeom( tHinge.geom, ptProbe, ptFromExt, 5, 1)
end
-----------------------------------------------------------------
-- *** Geometric subgeom processing : LOCKS ***
-----------------------------------------------------------------
local function MoveSubGeomLock( nSubLockId, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUpGeom, ptPosDwGeom, nExtraAngle, ptPosBox)
local sKeepBSNote
local nUpperToDelete
-- se geometria sul fianco
if sSideDoor == 'lock' or sSideDoor == 'side' then
if sSideDoor == 'lock' or ( DGD.SIDE and DGD.SIDE ~= 'lock_top' and DGD.SIDE ~= 'lock_bottom') then
nExtraAngle = 0
end
EgtRotate( nSubLockId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
if not DGD.SIDE or DGD.SIDE == 'lock_top' or DGD.SIDE == 'lock_bottom' then
EgtRotate( nSubLockId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubLockId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
elseif DGD.SIDE == 'top' then
if not DGD.sFrame then
EgtRotate( nSubLockId, ORIG(), Z_AX(), 180 ) -- ruoto su faccia superiore (già pronta per serratura lato destro)
if sSideLk == 'L' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
EgtMove( nSubLockId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPos, Z_AX(), EgtIf( sSideLk == 'L', DGD.A5, ( DGD.A6-180)))
end
else -- frame inferiore (ha il side opposto)
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
if DGD.OTHERD then
EgtMirror( nSubLockId, ORIG(), X_AX())
end
EgtMirror( nSubLockId, Point3d( 0,DGD.dH/2,0), Y_AX()) -- faccio il mirror su asse Y
EgtMove( nSubLockId, ptPos - ORIG())
end
elseif DGD.SIDE == 'bottom' then
if not DGD.sFrame then
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
EgtMove( nSubLockId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPos, Z_AX(), EgtIf( sSideLk == 'L', DGD.A2, ( DGD.A1-180)))
end
else -- frame superiore ( ha il side opposto)
EgtRotate( nSubLockId, ORIG(), Z_AX(), 180 ) -- ruoto su faccia superiore (già pronta per serratura lato destro)
if sSideLk == 'L' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
if DGD.OTHERD then
EgtMirror( nSubLockId, ORIG(), X_AX())
end
EgtMirror( nSubLockId, Point3d( 0,-DGD.dH/2,0), Y_AX()) -- faccio il mirror su asse Y
EgtMove( nSubLockId, ptPos - ORIG())
end
end
elseif ( sSideDoor == 'sidelh') then -- se posizionamento serratura tipo cerniera
-- si presume che sia su bordo SQ ( non BV)
EgtRotate( nSubLockId, ORIG(), X_AX(), 90) -- ruoto su faccia frontale senza angolo
if not DGD.SIDE or DGD.SIDE == 'lock_top' or DGD.SIDE == 'lock_bottom' then
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubLockId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
else
EgtRotate( nSubLockId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubLockId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
EgtMove( nSubLockId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
elseif DGD.SIDE == 'top' then
EgtRotate( nSubLockId, ORIG(), Z_AX(), 180 ) -- ruoto su faccia superiore (già pronta per serratura lato destro)
if sSideLk == 'L' then -- se serratura a sinistra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubLockId, ORIG(), Y_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
EgtMove( nSubLockId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPos, Z_AX(), EgtIf( sSideLk == 'L', DGD.A5, ( DGD.A6-180)))
end
elseif DGD.SIDE == 'bottom' then
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubLockId, ORIG(), Y_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
EgtMove( nSubLockId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPos, Z_AX(), EgtIf( sSideLk == 'L', DGD.A2, ( DGD.A1-180)))
end
end
elseif ( sSideDoor == 'keyway') then
if not DGD.SIDE or DGD.SIDE == 'lock_top' or DGD.SIDE == 'lock_bottom' then
EgtRotate( nSubLockId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
local bReference = EgtGetInfo( nSubLockId, 'ReferHw', 'b') or false
if bReference then
ptPosUpGeom = Point3d( ptPosBox:getX(), ptPosUpGeom:getY() , ptPosUpGeom:getZ())
end
EgtMove( nSubLockId, ptPosUpGeom - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPosUpGeom, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
elseif DGD.SIDE == 'top' then
EgtRotate( nSubLockId, ORIG(), Z_AX(), 180 ) -- ruoto su faccia superiore (già pronta per serratura lato destro)
if sSideLk == 'L' then -- se serratura a sinistra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
local bReference = EgtGetInfo( nSubLockId, 'ReferHw', 'b') or false
if bReference then
ptPosUpGeom = Point3d( ptPosBox:getX(), ptPosUpGeom:getY() , ptPosUpGeom:getZ())
end
EgtMove( nSubLockId, ptPosUpGeom - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPosUpGeom, Z_AX(), EgtIf( sSideLk == 'L', DGD.A5, ( DGD.A6-180)))
end
elseif DGD.SIDE == 'bottom' then
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
local bReference = EgtGetInfo( nSubLockId, 'ReferHw', 'b') or false
if bReference then
ptPosUpGeom = Point3d( ptPosBox:getX(), ptPosUpGeom:getY() , ptPosUpGeom:getZ())
end
EgtMove( nSubLockId, ptPosUpGeom - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPosUpGeom, Z_AX(), EgtIf( sSideLk == 'L', DGD.A2, ( DGD.A1-180)))
end
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubLockId), nSubLockId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubLockId), EgtGetParent(nSubLockId))
-- se c'è la nota per mantenere la posizione con il probe
sKeepBSNote = EgtGetInfo( nSubLockId, 'KeepBackSet')
if sKeepBSNote == 'x' then -- se ha la nota la modifico in funzione a dove è stata piazzata
if bPushDr then -- se porta a spingere allora la geometrie è sul lato narrow
EgtSetInfo( nSubLockId, 'KeepBackSet', 'n') -- setto 'n' perché la profondità non passante è applicata sul lato narroe
else -- atrimenti è sul lato wide
EgtSetInfo( nSubLockId, 'KeepBackSet', 'w') -- setto 'w' perché la profondità non passante è applicata sul lato wide
end
end
elseif ( sSideDoor == 'secure') then
EgtRotate( nSubLockId, ORIG(), X_AX(), 180 ) -- ruoto su faccia inferiore
if not DGD.SIDE or DGD.SIDE == 'lock_top' or DGD.SIDE == 'lock_bottom' then
EgtRotate( nSubLockId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
local bReference = EgtGetInfo( nSubLockId, 'ReferHw', 'b') or false
if bReference then
ptPosDwGeom = Point3d( ptPosBox:getX(), ptPosDwGeom:getY() , ptPosDwGeom:getZ())
end
EgtMove( nSubLockId, ptPosDwGeom - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPosDwGeom, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
elseif DGD.SIDE == 'top' then
EgtRotate( nSubLockId, ORIG(), Z_AX(), 180 ) -- ruoto su faccia superiore (già pronta per serratura lato destro)
if sSideLk == 'L' then -- se serratura a sinistra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
local bReference = EgtGetInfo( nSubLockId, 'ReferHw', 'b') or false
if bReference then
ptPosDwGeom = Point3d( ptPosBox:getX(), ptPosDwGeom:getY() , ptPosDwGeom:getZ())
end
EgtMove( nSubLockId, ptPosDwGeom - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPosDwGeom, Z_AX(), EgtIf( sSideLk == 'L', DGD.A5, ( DGD.A6-180)))
end
elseif DGD.SIDE == 'bottom' then
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
local bReference = EgtGetInfo( nSubLockId, 'ReferHw', 'b') or false
if bReference then
ptPosDwGeom = Point3d( ptPosBox:getX(), ptPosDwGeom:getY() , ptPosDwGeom:getZ())
end
EgtMove( nSubLockId, ptPosDwGeom - ORIG())
if bRemake then
EgtRotate( nSubLockId, ptPosDwGeom, Z_AX(), EgtIf( sSideLk == 'L', DGD.A2, ( DGD.A1-180)))
end
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubLockId), nSubLockId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubLockId), EgtGetParent(nSubLockId))
-- se c'è la nota per mantenere la posizione con il probe
sKeepBSNote = EgtGetInfo( nSubLockId, 'KeepBackSet')
if sKeepBSNote == 'x' then -- se ha la nota la modifico in funzione a dove è stata piazzata
if bPushDr then -- se porta a spingere allora la geometrie è sul lato wide
EgtSetInfo( nSubLockId, 'KeepBackSet', 'w') -- setto 'w' perché la profondità non passante è applicata sul lato wide
else -- atrimenti è sul lato narrow
EgtSetInfo( nSubLockId, 'KeepBackSet', 'n') -- setto 'n' perché la profondità non passante è applicata sul lato narroe
end
end
elseif ( sSideDoor == 'upper') then
EgtRotate( nSubLockId, ORIG(), X_AX(), 90) -- ruoto su faccia frontale
if not DGD.SIDE or DGD.SIDE == 'lock_top' or DGD.SIDE == 'lock_bottom' then
EgtRotate( nSubLockId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubLockId, ptPos - ORIG())
elseif DGD.SIDE == 'top' then
if not DGD.sFrame then
EgtRotate( nSubLockId, ORIG(), Z_AX(), 180 ) -- ruoto su faccia superiore (già pronta per serratura lato destro)
if sSideLk == 'L' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
EgtMirror( nSubLockId, Point3d( 0,-DGD.dH/2,0), Y_AX()) -- faccio il mirror su asse Y
EgtMove( nSubLockId, ptPos - ORIG())
else -- frame inferiore (ha il side opposto)
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
if DGD.OTHERD then
EgtMirror( nSubLockId, ORIG(), X_AX())
end
EgtMirror( nSubLockId, Point3d( 0,DGD.dH/2,0), Y_AX()) -- faccio il mirror su asse Y
EgtMove( nSubLockId, ptPos - ORIG())
end
elseif DGD.SIDE == 'bottom' then
if not DGD.sFrame then
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
EgtMirror( nSubLockId, Point3d( 0,DGD.dH/2,0), Y_AX()) -- faccio il mirror su asse Y
EgtMove( nSubLockId, ptPos - ORIG())
else -- frame superiore ( ha il side opposto)
EgtRotate( nSubLockId, ORIG(), Z_AX(), 180 ) -- ruoto su faccia superiore (già pronta per serratura lato destro)
if sSideLk == 'L' then -- se serratura a destra
EgtMirror( nSubLockId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
if DGD.OTHERD then
EgtMirror( nSubLockId, ORIG(), X_AX())
end
EgtMirror( nSubLockId, Point3d( 0,-DGD.dH/2,0), Y_AX()) -- faccio il mirror su asse Y
EgtMove( nSubLockId, ptPos - ORIG())
end
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubLockId), nSubLockId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubLockId), EgtGetParent(nSubLockId))
nUpperToDelete = nSubLockId
end
return nUpperToDelete
end
-----------------------------------------------------------------
-- *** Geometric subgeom processing : FLUSHBOLTS ***
-----------------------------------------------------------------
local function MoveSubGeomFlushBolt( nSubFlushBId, sSideDoor, sSideLk, bPushDr, ptPos, ptPosHead, ptPosHeadExt, nExtraAngle, dPosXHead, ptPosBox, ptPosUpGeom, ptPosDwGeom)
local nUpperToDelete
-- se geometria sul fianco
if sSideDoor == 'lock' or sSideDoor == 'side' then
if sSideDoor == 'lock' then
nExtraAngle = 0
else
-- se geometria sotto inverto il lato di rotazione
if DGD.SIDE == 'bottom' then
nExtraAngle = - nExtraAngle
end
end
-- se sono in remake sposto le geometrie della testa prima nel loro zero originale
if bRemake then
sSideDoorHead = EgtGetInfo( nSubFlushBId, 'HeadSide')
if sSideDoorHead == 'head' and string.lower(DGD.TYPE) == 'extension' then
EgtMove( nSubFlushBId, Point3d(DGD.POSITION,0,dPosXHead) - ORIG())
end
end
EgtRotate( nSubFlushBId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
EgtRotate( nSubFlushBId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if DGD.sFrame then
if ( string.lower(DGD.SIDE) == 'bottom') then
EgtRotate( nSubFlushBId, ORIG(), X_AX(), 180 ) -- ribalto in Y
end
if ( string.lower(DGD.SIDE) == 'top') then
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubFlushBId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
EgtMirror( nSubFlushBId, ORIG(), Y_AX()) -- faccio il mirror su asse Y
else
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubFlushBId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
EgtMirror( nSubFlushBId, Point3d( 0,DGD.dH/2,0), Y_AX()) -- faccio il mirror su asse Y
end
else
if ( string.lower(DGD.SIDE) == 'bottom') then
EgtRotate( nSubFlushBId, ORIG(), X_AX(), 180 ) -- ribalto in Y
end
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubFlushBId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
end
if bRemake then
sSideDoorHead = EgtGetInfo( nSubFlushBId, 'HeadSide')
if sSideDoorHead == 'head' then
if string.lower(DGD.TYPE) == 'extension' then
EgtMove( nSubFlushBId, ptPosHeadExt - ORIG())
EgtRotate( nSubFlushBId, ptPosHeadExt, Z_AX(), EgtIf( DGD.SIDE == 'top', DGD.A5, DGD.A2))
else
EgtMove( nSubFlushBId, ptPosHead - ORIG())
EgtRotate( nSubFlushBId, ptPosHead, Z_AX(), EgtIf( DGD.SIDE == 'top', DGD.A5, DGD.A2))
end
else
EgtMove( nSubFlushBId, ptPos - ORIG())
EgtRotate( nSubFlushBId, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
else
sSideDoorHead = EgtGetInfo( nSubFlushBId, 'HeadSide')
if sSideDoorHead == 'head' and DGC.Bwd and DGC.Bwd >= 1 then
EgtMove( nSubFlushBId, Point3d( ptPosBox:getX(), ptPos:getY(), ptPos:getZ()) - ORIG())
else
EgtMove( nSubFlushBId, ptPos - ORIG())
end
end
elseif ( sSideDoor == 'sidelh') then -- se posizionamento serratura tipo cerniera
-- cambio di segno ancora un'altra volta
if bPushDr then
nExtraAngle = - nExtraAngle
end
-- se sono in remake sposto le geometrie della testa prima nel loro zero originale
if bRemake then
sSideDoorHead = EgtGetInfo( nSubFlushBId, 'HeadSide')
if sSideDoorHead == 'head' and string.lower(DGD.TYPE) == 'extension' then
EgtMove( nSubFlushBId, Point3d(DGD.POSITION,0,dPosXHead) - ORIG())
end
end
EgtRotate( nSubFlushBId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubFlushBId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
else
EgtRotate( nSubFlushBId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubFlushBId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
if bRemake then
sSideDoorHead = EgtGetInfo( nSubFlushBId, 'HeadSide')
if sSideDoorHead == 'head' then
if string.lower(DGD.TYPE) == 'extension' then
EgtMove( nSubFlushBId, ptPosHeadExt - ORIG())
EgtRotate( nSubFlushBId, ptPosHeadExt, Z_AX(), EgtIf( DGD.SIDE == 'top', DGD.A5, DGD.A2))
else
EgtMove( nSubFlushBId, ptPosHead - ORIG())
EgtRotate( nSubFlushBId, ptPosHead, Z_AX(), EgtIf( DGD.SIDE == 'top', DGD.A5, DGD.A2))
end
else
EgtMove( nSubFlushBId, ptPos - ORIG())
EgtRotate( nSubFlushBId, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
else
sSideDoorHead = EgtGetInfo( nSubFlushBId, 'HeadSide')
if sSideDoorHead == 'head' and DGC.Bwd and DGC.Bwd >= 1 then
EgtMove( nSubFlushBId, Point3d( ptPosBox:getX(), ptPos:getY(), ptPos:getZ()) - ORIG())
else
EgtMove( nSubFlushBId, ptPos - ORIG())
end
end
elseif ( sSideDoor == 'keyway') then
EgtRotate( nSubFlushBId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubFlushBId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
local bReference = EgtGetInfo( nSubFlushBId, 'ReferHw', 'b') or false
if bReference then
ptPosUpGeom = Point3d( ptPosBox:getX(), ptPosUpGeom:getY() , ptPosUpGeom:getZ())
end
EgtMove( nSubFlushBId, ptPosUpGeom - ORIG())
if bRemake then
EgtRotate( nSubFlushBId, ptPosUpGeom, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubFlushBId), nSubFlushBId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubFlushBId), EgtGetParent(nSubFlushBId))
-- se c'è la nota per mantenere la posizione con il probe
sKeepBSNote = EgtGetInfo( nSubFlushBId, 'KeepBackSet')
if sKeepBSNote == 'x' then -- se ha la nota la modifico in funzione a dove è stata piazzata
if bPushDr then -- se porta a spingere allora la geometrie è sul lato narrow
EgtSetInfo( nSubFlushBId, 'KeepBackSet', 'n') -- setto 'n' perché la profondità non passante è applicata sul lato narroe
else -- atrimenti è sul lato wide
EgtSetInfo( nSubFlushBId, 'KeepBackSet', 'w') -- setto 'w' perché la profondità non passante è applicata sul lato wide
end
end
elseif ( sSideDoor == 'secure') then
EgtRotate( nSubFlushBId, ORIG(), X_AX(), 180 ) -- ruoto su faccia inferiore
EgtRotate( nSubFlushBId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubFlushBId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
local bReference = EgtGetInfo( nSubFlushBId, 'ReferHw', 'b') or false
if bReference then
ptPosDwGeom = Point3d( ptPosBox:getX(), ptPosDwGeom:getY() , ptPosDwGeom:getZ())
end
EgtMove( nSubFlushBId, ptPosDwGeom - ORIG())
if bRemake then
EgtRotate( nSubFlushBId, ptPosDwGeom, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubFlushBId), nSubFlushBId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubFlushBId), EgtGetParent(nSubFlushBId))
-- se c'è la nota per mantenere la posizione con il probe
sKeepBSNote = EgtGetInfo( nSubFlushBId, 'KeepBackSet')
if sKeepBSNote == 'x' then -- se ha la nota la modifico in funzione a dove è stata piazzata
if bPushDr then -- se porta a spingere allora la geometrie è sul lato wide
EgtSetInfo( nSubFlushBId, 'KeepBackSet', 'w') -- setto 'w' perché la profondità non passante è applicata sul lato wide
else -- atrimenti è sul lato narrow
EgtSetInfo( nSubFlushBId, 'KeepBackSet', 'n') -- setto 'n' perché la profondità non passante è applicata sul lato narroe
end
end
elseif ( sSideDoor == 'upper') then
EgtRotate( nSubFlushBId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale
EgtRotate( nSubFlushBId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if ( string.lower(DGD.SIDE) == 'bottom') then
EgtRotate( nSubFlushBId, ORIG(), X_AX(), 180 ) -- ribalto in Y
end
if ( string.lower(DGD.SIDE) == 'top') then
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubFlushBId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
EgtMirror( nSubFlushBId, ORIG(), Y_AX()) -- faccio il mirror su asse Y
else
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubFlushBId, ORIG(), X_AX()) -- faccio il mirror su asse X
end
EgtMirror( nSubFlushBId, Point3d( 0,DGD.dH/2,0), Y_AX()) -- faccio il mirror su asse Y
end
sSideDoorHead = EgtGetInfo( nSubFlushBId, 'HeadSide')
if sSideDoorHead == 'head' and DGC.Bwd and DGC.Bwd >= 1 then
EgtMove( nSubFlushBId, Point3d( ptPosBox:getX(), ptPos:getY(), ptPos:getZ()) - ORIG())
else
EgtMove( nSubFlushBId, ptPos - ORIG())
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubFlushBId), nSubFlushBId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubFlushBId), EgtGetParent(nSubFlushBId))
nUpperToDelete = nSubFlushBId
end
return nUpperToDelete
end
-----------------------------------------------------------------
-- *** Geometric subgeom processing : EDGEPULLS ***
-----------------------------------------------------------------
local function MoveSubGeomEdgePull( nSubEdgePId, sSideDoor, sSideLk, bPushDr, ptPos, nExtraAngle, ptPosUpGeom, ptPosDwGeom)
local nUpperToDelete
-- rinomino eventuali geometrie che descrivono solo la sezione
if sSideDoor == 'upper' then
if not DGD.Dws then
if bPushDr then
EgtSetInfo( nSubEdgePId, 'SideDoor', 'secure')
sSideDoor = 'secure'
else
EgtSetInfo( nSubEdgePId, 'SideDoor', 'keyway')
sSideDoor = 'keyway'
end
else
EgtSetInfo( nSubEdgePId, 'SideDoor', 'keyway')
sSideDoor = 'keyway'
end
nUpperToDelete = nSubEdgePId
end
-- se geometria sul fianco
if sSideDoor == 'lock' or sSideDoor == 'side' then
if sSideDoor == 'lock' then
nExtraAngle = 0
end
EgtRotate( nSubEdgePId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubEdgePId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubEdgePId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubEdgePId, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
elseif sSideDoor == 'sidelh' then -- se posizionamento serratura tipo cerniera
-- cambio di segno ancora un'altra volta
if bPushDr then
nExtraAngle = - nExtraAngle
end
EgtRotate( nSubEdgePId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
else
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubEdgePId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
EgtMove( nSubEdgePId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubEdgePId, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
elseif sSideDoor == 'keyway' then
if DGD.Dws == nil and nUpperToDelete then -- se disposizione frame su porta
EgtRotate( nSubEdgePId, ORIG(), X_AX(), 90) -- ruoto su faccia frontale
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
else
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
end
EgtMove( nSubEdgePId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubEdgePId, ptPosUpGeom, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
elseif not DGD.Dws then -- se disposizione frame su lato narrow
if nUpperToDelete then -- se non è una geometria di ingombro/box
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
else
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
end
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubEdgePId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubEdgePId, ptPosUpGeom - ORIG())
if bRemake then
EgtRotate( nSubEdgePId, ptPosUpGeom, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
else
EgtRotate( nSubEdgePId, ORIG(), X_AX(), 90) -- ruoto su faccia frontale
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubEdgePId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubEdgePId, ptPos - ORIG())
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubEdgePId), nSubEdgePId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubEdgePId), EgtGetParent(nSubEdgePId))
if not nUpperToDelete then -- se non è una geometria di ingombro/box
-- se c'è la nota per mantenere la posizione con il probe
sKeepBSNote = EgtGetInfo( nSubEdgePId, 'KeepBackSet')
if sKeepBSNote == 'x' then -- se ha la nota la modifico in funzione a dove è stata piazzata
if bPushDr then -- se porta a spingere allora la geometrie è sul lato narrow
EgtSetInfo( nSubEdgePId, 'KeepBackSet', 'n') -- setto 'n' perché la profondità non passante è applicata sul lato narroe
else -- atrimenti è sul lato wide
EgtSetInfo( nSubEdgePId, 'KeepBackSet', 'w') -- setto 'w' perché la profondità non passante è applicata sul lato wide
end
end
end
elseif sSideDoor == 'secure' then
if DGD.Dws == nil and nUpperToDelete then -- se disposizione frame su porta
EgtRotate( nSubEdgePId, ORIG(), X_AX(), 90) -- ruoto su faccia frontale
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
else
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
end
EgtRotate( nSubEdgePId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
EgtMove( nSubEdgePId, ptPos - ORIG())
else
EgtRotate( nSubEdgePId, ORIG(), X_AX(), 180 ) -- ruoto su faccia inferiore
EgtRotate( nSubEdgePId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubEdgePId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubEdgePId, ptPosDwGeom - ORIG())
end
if bRemake then
EgtRotate( nSubEdgePId, ptPosDwGeom, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubEdgePId), nSubEdgePId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubEdgePId), EgtGetParent(nSubEdgePId))
if not nUpperToDelete then -- se non è una geometria di ingombro/box
-- se c'è la nota per mantenere la posizione con il probe
sKeepBSNote = EgtGetInfo( nSubEdgePId, 'KeepBackSet')
if sKeepBSNote == 'x' then -- se ha la nota la modifico in funzione a dove è stata piazzata
if bPushDr then -- se porta a spingere allora la geometrie è sul lato wide
EgtSetInfo( nSubEdgePId, 'KeepBackSet', 'w') -- setto 'w' perché la profondità non passante è applicata sul lato wide
else -- atrimenti è sul lato narrow
EgtSetInfo( nSubEdgePId, 'KeepBackSet', 'n') -- setto 'n' perché la profondità non passante è applicata sul lato narroe
end
end
end
end
return nUpperToDelete
end
-----------------------------------------------------------------
-- *** Geometric subgeom processing : STRIKES ***
-----------------------------------------------------------------
local function MoveSubGeomStrike( nSubStrikeId, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUpGeom, ptPosDwGeom, nExtraAngle, ptPosBox)
local sKeepBSNote
-- Controllo se la nota è corretta
local sLikeStrike = EgtGetInfo( nSubStrikeId, 'LikeStrike')
local nUpperToDelete
-- se geometria sul fianco
if sSideDoor == 'lock' or sSideDoor == 'side' then
-- cambio di segno ancora un'altra volta
if bPushDr then
nExtraAngle = - nExtraAngle
end
if sSideDoor == 'lock' then
nExtraAngle = 0
end
EgtRotate( nSubStrikeId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
EgtRotate( nSubStrikeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra RHR(I) e LHR(I)
if bPushDr and not sLikeStrike then -- se apertura a spingere RH(I) LH(I)
EgtMirror( nSubStrikeId, ORIG(), Z_AX())
end
if sSideLk == 'R' then -- se serratura a destra LH(I) LHR(I)
EgtMirror( nSubStrikeId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubStrikeId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubStrikeId, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
elseif ( sSideDoor == 'sidelh') then -- se posizionamento serratura tipo cerniera
if not sLikeStrike then
EgtRotate( nSubStrikeId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
EgtRotate( nSubStrikeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra RHR(I) e LHR(I)
if bPushDr then -- se apertura a spingere RH(I) LH(I)
EgtMirror( nSubStrikeId, ORIG(), Z_AX())
end
if sSideLk == 'R' then -- se serratura a destra LH(I) LHR(I)
EgtMirror( nSubStrikeId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
else
-- cambio di segno ancora un'altra volta
if bPushDr then
nExtraAngle = - nExtraAngle
end
EgtRotate( nSubStrikeId, ORIG(), X_AX(), ( 90 + nExtraAngle)) -- ruoto su faccia frontale con angolo
if sSideLk == 'L' then -- se serratura a sinistra
EgtRotate( nSubStrikeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
else
EgtRotate( nSubStrikeId, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
end
if bPushDr then -- se apertura a spingere
EgtRotate( nSubStrikeId, ORIG(), X_AX(), 180 ) -- ruoto attorno a X per capovolgere la cerniera
end
end
EgtMove( nSubStrikeId, ptPos - ORIG())
if bRemake then
EgtRotate( nSubStrikeId, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
elseif ( sSideDoor == 'keyway') then
EgtRotate( nSubStrikeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubStrikeId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
local bReference = EgtGetInfo( nSubStrikeId, 'ReferHw', 'b') or false
if bReference then
ptPosUpGeom = Point3d( ptPosBox:getX(), ptPosUpGeom:getY() , ptPosUpGeom:getZ())
end
EgtMove( nSubStrikeId, ptPosUpGeom - ORIG())
if bRemake then
EgtRotate( nSubStrikeId, ptPosUpGeom, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubStrikeId), nSubStrikeId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubStrikeId), EgtGetParent(nSubStrikeId))
-- se c'è la nota per mantenere la posizione con il probe
sKeepBSNote = EgtGetInfo( nSubStrikeId, 'KeepBackSet')
if sKeepBSNote == 'x' then -- se ha la nota la modifico in funzione a dove è stata piazzata
if bPushDr then -- se porta a spingere allora la geometrie è sul lato narrow
EgtSetInfo( nSubStrikeId, 'KeepBackSet', 'n') -- setto 'n' perché la profondità non passante è applicata sul lato narroe
else -- atrimenti è sul lato wide
EgtSetInfo( nSubStrikeId, 'KeepBackSet', 'w') -- setto 'w' perché la profondità non passante è applicata sul lato wide
end
end
elseif ( sSideDoor == 'secure') then
EgtRotate( nSubStrikeId, ORIG(), X_AX(), 180 ) -- ruoto su faccia inferiore
EgtRotate( nSubStrikeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubStrikeId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
local bReference = EgtGetInfo( nSubStrikeId, 'ReferHw', 'b') or false
if bReference then
ptPosDwGeom = Point3d( ptPosBox:getX(), ptPosDwGeom:getY() , ptPosDwGeom:getZ())
end
EgtMove( nSubStrikeId, ptPosDwGeom - ORIG())
if bRemake then
EgtRotate( nSubStrikeId, ptPosDwGeom, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubStrikeId), nSubStrikeId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubStrikeId), EgtGetParent(nSubStrikeId))
-- se c'è la nota per mantenere la posizione con il probe
sKeepBSNote = EgtGetInfo( nSubStrikeId, 'KeepBackSet')
if sKeepBSNote == 'x' then -- se ha la nota la modifico in funzione a dove è stata piazzata
if bPushDr then -- se porta a spingere allora la geometrie è sul lato wide
EgtSetInfo( nSubStrikeId, 'KeepBackSet', 'w') -- setto 'w' perché la profondità non passante è applicata sul lato wide
else -- atrimenti è sul lato narrow
EgtSetInfo( nSubStrikeId, 'KeepBackSet', 'n') -- setto 'n' perché la profondità non passante è applicata sul lato narroe
end
end
elseif ( sSideDoor == 'upper') then
if not DGD.Dws then -- se disposizione frame su lato narrow o porta
EgtRotate( nSubStrikeId, ORIG(), X_AX(), 90) -- ruoto su faccia frontale
EgtRotate( nSubStrikeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra RHR(I) e LHR(I)
if bPushDr and not sLikeStrike then -- se apertura a spingere RH(I) LH(I)
EgtMirror( nSubStrikeId, ORIG(), Z_AX())
end
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubStrikeId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubStrikeId, ptPos - ORIG())
else
EgtRotate( nSubStrikeId, ORIG(), X_AX(), 90) -- ruoto su faccia frontale
EgtRotate( nSubStrikeId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra RHR(I) e LHR(I)
if bPushDr and not sLikeStrike then -- se apertura a spingere RH(I) LH(I)
EgtMirror( nSubStrikeId, ORIG(), Z_AX())
end
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubStrikeId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
EgtMove( nSubStrikeId, ptPos - ORIG())
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubStrikeId), nSubStrikeId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubStrikeId), EgtGetParent(nSubStrikeId))
-- nUpperToDelete = nSubStrikeId
end
return nUpperToDelete
end
-----------------------------------------------------------------------------------------------
-- *** Geometric processing : common functions for locks, flushbolts, edgepulls, strikes ***
-----------------------------------------------------------------------------------------------
local function MoveGeometryLck( sTypeGeom, nGeomId, sSideLk, bPushDr, ptPos, ptPosUpGeom, ptPosDwGeom, dPosXHead, ptPosBox, ptPosUpGeomFB, ptPosDwGeomFB)
if not nGeomId then return end
-- se profilo lato serratura è bevel setto il supplemento di rotazione
local nExtraAngle
local nIdGeomType
local sSideDoorToMove
local sMessageErr = ''
-- stabilisco l'angolo extra di inclinazione in base al profilo e alla direzione di apertura porta ( Push o Pull)
if DGD.tProfs.lockedge.trimming == 'BD' or DGD.tProfs.lockedge.trimming == 'BU' or
DGD.tProfs.lockedge.trimming == 'BDEB' or DGD.tProfs.lockedge.trimming == 'BUEB' then
nExtraAngle = 3
if bPushDr then
nExtraAngle = - nExtraAngle
end
-- se è un lato senza maniglia e abilitazione inversione profilo, re-inverto l'angolo
if ( DGD.sSwing == 'LHI' or DGD.sSwing == 'RHI' or DGD.sSwing == 'RHRI' or DGD.sSwing == 'LHRI') and
( ( DGD.RevInBv and DGD.RevInBv == 1) or DGD.bBothOppoBevel) then
nExtraAngle = - nExtraAngle
end
else
nExtraAngle = 0
end
-- devo ottenere tutte le geometrie della serratura
nIdGeomType = EgtGetFirstInGroup( nGeomId) -- ottengo la prima geometria
local nErr = 0
local nUpperToDelete
while nIdGeomType do
sSideDoorToMove = EgtGetInfo( nIdGeomType, 'SideDoor')
if sSideDoorToMove then
-- Controllo se la nota è corretta
local sSideDoor = string.lower(sSideDoorToMove)
-- lock: senza rotazione angolo profilo; side: con rotazione angolo profilo; keyway e Secure: no rotazione angolo profilo;
-- SideLH: senza rotazione angolo profilo e disposizione come cerniera ( suffisso LH: like hinge), cioè senza effettuare mirror
-- attenzione! la geometria con nota SideLH DEVE ESSERE SIMMETRICA sulla X e Y locale
if sTypeGeom == 'lock' then
if sSideDoor == 'lock' or sSideDoor == 'side' or sSideDoor == 'sidelh' or
sSideDoor == 'keyway' or sSideDoor == 'secure' or sSideDoor == 'upper' then
if DGD.sFrame and DGD.nTypePz == 5 then
DGD.SIDE = 'bottom'
elseif DGD.sFrame and DGD.nTypePz == 6 then
DGD.SIDE = 'top'
end
nUpperToDelete = MoveSubGeomLock( nIdGeomType, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUpGeom, ptPosDwGeom, nExtraAngle, ptPosBox)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[413],nIdGeomType,'Lock',nGeomId, sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1001
end
elseif sTypeGeom == 'flushbolt' then
if sSideDoor == 'lock' or sSideDoor == 'side' or sSideDoor == 'sidelh' or
sSideDoor == 'keyway' or sSideDoor == 'secure' or sSideDoor == 'upper' then
nUpperToDelete = MoveSubGeomFlushBolt( nIdGeomType, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUpGeom, ptPosDwGeom, nExtraAngle, dPosXHead, ptPosBox, ptPosUpGeomFB, ptPosDwGeomFB)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[413],nIdGeomType,'Flush Bolt',nGeomId, sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1003
end
elseif sTypeGeom == 'edgepull' then
if sSideDoor == 'lock' or sSideDoor == 'side' or sSideDoor == 'sidelh' or
sSideDoor == 'keyway' or sSideDoor == 'secure' or sSideDoor == 'upper' then
nUpperToDelete = MoveSubGeomEdgePull( nIdGeomType, sSideDoor, sSideLk, bPushDr, ptPos, nExtraAngle, ptPosUpGeom, ptPosDwGeom)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[413],nIdGeomType,'Edge Pull',nGeomId, sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1005
end
elseif sTypeGeom == 'strike' then
if sSideDoor == 'lock' or sSideDoor == 'side' or sSideDoor == 'sidelh' or
sSideDoor == 'keyway' or sSideDoor == 'secure' or sSideDoor == 'upper' then
nUpperToDelete = MoveSubGeomStrike( nIdGeomType, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUpGeom, ptPosDwGeom, nExtraAngle, ptPosBox)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[413],nIdGeomType,'Strike',nGeomId, sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1017
end
end
else
-- messaggio di errore in base al tipo di pezzo
if sTypeGeom == 'lock' then
sMessageErr = string.format( EgtDoorsMsg[414],nIdGeomType,'Lock',nGeomId, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1002
elseif sTypeGeom == 'flushbolt' then
sMessageErr = string.format( EgtDoorsMsg[414],nIdGeomType,'Flush Bolt',nGeomId, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1004
elseif sTypeGeom == 'edgepull' then
sMessageErr = string.format( EgtDoorsMsg[414],nIdGeomType,'Edge Pull',nEdgePId, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1006
elseif sTypeGeom == 'strike' then
sMessageErr = string.format( EgtDoorsMsg[414],nIdGeomType,'Strike',nEdgePId, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1018
end
end
nIdGeomType = EgtGetNext(nIdGeomType)
-- cancello il percorso 'upper'
if nUpperToDelete then
EgtErase( nUpperToDelete)
nUpperToDelete = nil
end
end
-- assegno codice errore se ancora non fatto
if DGD.ERR == 0 then DGD.ERR = nErr end
end
-------------------------------------------------------------------------------
-- *** Geometric main processing : LOCKS, FLUSHBOLTS, EDGEPULLS, STRIKES ***
-------------------------------------------------------------------------------
local function MoveLock( tLock, sSideLk, bPushDr)
local ptPos
local ptPosBox
local ptRef
local ptFromExt
local ptPosUpGeom
local ptPosDwGeom
local dPosX
local dPosXUpDw
local dPosZ
local dDeltaX
local dZedPos = 0
local nAngleBase
local nRadBase
local nRadBaseBox
local nAngleBaseUpDw
local nRadBaseUpDw
local nSideApplied = 3
if tLock.offset and tLock.offset > 0 then
dDeltaX = tLock.offset * TAN3
dPosZ = tLock.offset
else
dDeltaX = (DGD.dT/2) * TAN3
dPosZ = (DGD.dT/2)
end
if ( DGD.tProfs.lockedge.trimming == 'BU' or DGD.tProfs.lockedge.trimming == 'BD' or
DGD.tProfs.lockedge.trimming == 'BDEB' or DGD.tProfs.lockedge.trimming == 'BUEB') and
( not DGD.SIDE or DGD.SIDE == 'lock_top' or DGD.SIDE == 'lock_bottom') then -- se profilo bevel su lato lock
dPosX = dDeltaX
dPosXUpDw = dDeltaX
else
dPosX = 0
dPosXUpDw = 0
end
-- by DGC.Bwd setting set to 0 the dPosXUpDw and dPosX parameters
if DGC.Bwd and DGC.Bwd >= 1 then
dPosXUpDw = 0
if DGC.Bwd == 2 then
dPosX = 0
end
end
if DGD.sFrame then
if ( DGD.nTypePz == 3 or DGD.nTypePz == 4) then
sSideLk = EgtIf( sSideLk == 'L', 'R', 'L')
end
if DGD.nTypePz == 5 then
tLock.side = 'bottom'
elseif DGD.nTypePz == 6 then
tLock.side = 'top'
end
end
if bRemake then
nAngleBase = atan(dPosX/tLock.position)
nRadBase = sqrt((dPosX*dPosX)+(tLock.position*tLock.position))
nRadBaseBox = tLock.position
nAngleBaseUpDw = atan((dPosXUpDw+tLock.back_set)/tLock.position)
nRadBaseUpDw = sqrt(((dPosXUpDw+tLock.back_set)*(dPosXUpDw+tLock.back_set))+(tLock.position*tLock.position))
end
if bPushDr then
dZedPos = dPosZ
else
dZedPos = (DGD.dT - dPosZ)
end
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
if not DGD.SIDE or DGD.SIDE == 'lock_top' then
ptRef = DGD.PminTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A4+nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A4)), ptRef:getY()+(nRadBaseBox*sin(DGD.A4)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A4+nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A4+nAngleBaseUpDw)) , DGD.dT)
elseif DGD.SIDE == 'lock_bottom' then
ptRef = DGD.PminBot
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A3-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A3-nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A3)), ptRef:getY()+(nRadBaseBox*sin(DGD.A3)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A3-nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A3-nAngleBaseUpDw)) , DGD.dT)
elseif DGD.SIDE == 'top' then
ptRef = DGD.PminTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A5+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A5+nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A5)), ptRef:getY()+(nRadBaseBox*sin(DGD.A5)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A5-nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A5-nAngleBaseUpDw)) , DGD.dT)
nSideApplied = 2
elseif DGD.SIDE == 'bottom' then
ptRef = DGD.PminBot
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A2+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A2+nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A2)), ptRef:getY()+(nRadBaseBox*sin(DGD.A2)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A2+nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A2+nAngleBaseUpDw)) , DGD.dT)
nSideApplied = 4
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
else
if not DGD.SIDE or DGD.SIDE == 'lock_top' then
ptPos = Point3d( dPosX + EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tLock.position) , dZedPos)
ptPosBox = Point3d( EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tLock.position) , dZedPos)
ptPosUpGeom = Point3d( ( dPosXUpDw + tLock.back_set + EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tLock.position) , DGD.dT)
ptFromExt = Point3d( EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tLock.position) , DGD.dT)
elseif DGD.SIDE == 'lock_bottom' then
ptPos = Point3d( dPosX + EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), tLock.position , dZedPos)
ptPosBox = Point3d( EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), tLock.position , dZedPos)
ptPosUpGeom = Point3d( ( dPosXUpDw + tLock.back_set + EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), tLock.position , DGD.dT)
ptFromExt = Point3d( EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), tLock.position , DGD.dT)
elseif DGD.SIDE == 'top' then
ptPos = Point3d( tLock.position, DGD.dH, dZedPos)
ptPosBox = Point3d( tLock.position, DGD.dH, dZedPos)
ptPosUpGeom = Point3d( tLock.position, ( DGD.dH - tLock.back_set) , DGD.dT)
ptFromExt = Point3d( tLock.position, DGD.dH , DGD.dT)
nSideApplied = 2
elseif DGD.SIDE == 'bottom' then
ptPos = Point3d( tLock.position, 0, dZedPos)
ptPosBox = Point3d( tLock.position, 0, dZedPos)
ptPosUpGeom = Point3d( tLock.position, tLock.back_set , DGD.dT)
ptFromExt = Point3d( tLock.position, 0 , DGD.dT)
nSideApplied = 4
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
end
else -- serratura a destra
if bRemake then
if not DGD.SIDE or DGD.SIDE == 'lock_top' then
ptRef = DGD.PmaxTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A7-nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A7)), ptRef:getY()+(nRadBaseBox*sin(DGD.A7)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A7-nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A7-nAngleBaseUpDw)) , DGD.dT)
elseif DGD.SIDE == 'lock_bottom' then
ptRef = DGD.PmaxBot
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A8+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A8+nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A8)), ptRef:getY()+(nRadBaseBox*sin(DGD.A8)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A8+nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A8+nAngleBaseUpDw)) , DGD.dT)
elseif DGD.SIDE == 'top' then
ptRef = DGD.PmaxTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A6-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A6-nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A6)), ptRef:getY()+(nRadBaseBox*sin(DGD.A6)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A6+nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A6+nAngleBaseUpDw)) , DGD.dT)
nSideApplied = 2
elseif DGD.SIDE == 'bottom' then
ptRef = DGD.PmaxBot
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A1+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A1+nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A1)), ptRef:getY()+(nRadBaseBox*sin(DGD.A1)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A1-nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A1-nAngleBaseUpDw)) , DGD.dT)
nSideApplied = 4
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
else
if not DGD.SIDE or DGD.SIDE == 'lock_top' then
ptPos = Point3d( ( DGD.dW - dPosX - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tLock.position) , dZedPos)
ptPosBox = Point3d( ( DGD.dW - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tLock.position) , dZedPos)
ptPosUpGeom = Point3d( ( DGD.dW - dPosXUpDw - tLock.back_set - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tLock.position) , DGD.dT)
ptFromExt = Point3d( ( DGD.dW - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tLock.position) , DGD.dT)
elseif DGD.SIDE == 'lock_bottom' then
ptPos = Point3d( ( DGD.dW - dPosX - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), tLock.position , dZedPos)
ptPosBox = Point3d( ( DGD.dW - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), tLock.position , dZedPos)
ptPosUpGeom = Point3d( ( DGD.dW - dPosXUpDw - tLock.back_set - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), tLock.position , DGD.dT)
ptFromExt = Point3d( ( DGD.dW - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), tLock.position , DGD.dT)
elseif DGD.SIDE == 'top' then
ptPos = Point3d( ( DGD.dW - tLock.position), DGD.dH, dZedPos)
ptPosBox = Point3d( ( DGD.dW - tLock.position), DGD.dH, dZedPos)
ptPosUpGeom = Point3d( ( DGD.dW - tLock.position), ( DGD.dH - tLock.back_set) , DGD.dT)
ptFromExt = Point3d( ( DGD.dW - tLock.position), DGD.dH , DGD.dT)
nSideApplied = 2
elseif DGD.SIDE == 'bottom' then
ptPos = Point3d( ( DGD.dW - tLock.position), 0, dZedPos)
ptPosBox = Point3d( ( DGD.dW - tLock.position), 0, dZedPos)
ptPosUpGeom = Point3d( ( DGD.dW - tLock.position), tLock.back_set , DGD.dT)
ptFromExt = Point3d( ( DGD.dW - tLock.position), 0 , DGD.dT)
nSideApplied = 4
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
end
end
MoveGeometryLck( 'lock', tLock.geom, sSideLk, bPushDr, ptPos, ptPosUpGeom, ptPosDwGeom, nil, ptPosBox)
InsertProbeGeom( tLock.geom, ptPosUpGeom, ptFromExt, 3, nSideApplied)
end
-----------------------------------------------------------------
local function MoveFlushBolt( tFlushB, sSideLk, bPushDr)
local ptPos
local ptPosBox
local ptRef
local ptPosHead
local ptPosHeadExt
local ptPosUpGeom
local ptPosDwGeom
local ptDummy = Point3d{0,0,0}
local dPosY
local dPosYBox
local dPosYUpDw
local dPosYHead
local dPosYHeadExt
local dPosYProbe
local dPosX
local dPosXUpDw
local dPosXHead
local dPosXProbe
local dPosZ
local dXFromExt
local dYFromExt
local dDeltaX
local dZedPos = 0
local nAngleBase
local nRadBase
local nRadBaseBox
local nAngleBaseUpDw
local nRadBaseUpDw
if DGD.OFFSET and DGD.OFFSET > 0 then
dDeltaX = DGD.OFFSET * TAN3
dPosZ = DGD.OFFSET
else
dDeltaX = (DGD.dT/2) * TAN3
dPosZ = (DGD.dT/2)
end
if DGD.tProfs.lockedge.trimming == 'BU' or DGD.tProfs.lockedge.trimming == 'BD' or
DGD.tProfs.lockedge.trimming == 'BDEB' or DGD.tProfs.lockedge.trimming == 'BUEB' then -- se profilo bevel
dPosX = dDeltaX
dPosXUpDw = dDeltaX
else
dPosX = 0
dPosXUpDw = 0
end
-- by DGC.Bwd setting set to 0 the dPosXUpDw and dPosX parameters
if DGC.Bwd and DGC.Bwd >= 1 then
dPosXUpDw = 0
if DGC.Bwd == 2 then
dPosX = 0
end
end
if DGD.sFrame then
sSideLk = EgtIf( sSideLk == 'L', 'R', 'L')
end
if not tFlushB.position then
tFlushB.position = 100
end
if not tFlushB.back_set then
tFlushB.back_set = 0
end
if bRemake then
nAngleBase = atan(dPosX,tFlushB.position)
nRadBase = sqrt((dPosX*dPosX)+(tFlushB.position*tFlushB.position))
nRadBaseBox = tFlushB.position
if tFlushB.back_set then
nAngleBaseUpDw = atan((dPosXUpDw+tFlushB.back_set)/tFlushB.position)
nRadBaseUpDw = sqrt(((dPosXUpDw+tFlushB.back_set)*(dPosXUpDw+tFlushB.back_set))+(tFlushB.position*tFlushB.position))
end
end
-- se è extension
if string.lower(tFlushB.type) == 'extension' then
if DGD.sFrame and ( DGD.nTypePz == 5 or DGD.nTypePz == 6) then
dPosY = 0 + DGD.dZedExtFrame
dPosYUpDw = dPosY
bPushDr = not bPushDr
else
if bRemake then
-- ricavo nota spostamento cava di testa
dPosXHead = EgtGetInfo( tFlushB.geom, 'DB_X', 'd') or 0
-- se applicato a lato top o bottom cambio la coordinata in Y
if string.lower(tFlushB.side) == 'top' then
ptRef = EgtIf( sSideLk == 'L', DGD.PminTop, DGD.PmaxTop)
if sSideLk == 'L' then -- se serratura a sinistra
dPosY = ptRef:getY()+(nRadBase*sin(DGD.A4+nAngleBase))
dPosYBox = ptRef:getY()+(nRadBaseBox*sin(DGD.A4))
dPosYUpDw = ptRef:getY()+(nRadBaseUpDw*sin(DGD.A4+nAngleBaseUpDw))
dPosYHeadExt = ptRef:getY()+(dPosXHead*sin(DGD.A5))
else
dPosY = ptRef:getY()+(nRadBase*sin(DGD.A7-nAngleBase))
dPosYBox = ptRef:getY()+(nRadBaseBox*sin(DGD.A7))
dPosYUpDw = ptRef:getY()+(nRadBaseUpDw*sin(DGD.A7-nAngleBaseUpDw))
dPosYHeadExt = ptRef:getY()+(dPosXHead*sin(DGD.A6))
end
else
ptRef = EgtIf( sSideLk == 'L', DGD.PminBot, DGD.PmaxBot)
if sSideLk == 'L' then -- se serratura a sinistra
dPosY = ptRef:getY()+(nRadBase*sin(DGD.A3-nAngleBase))
dPosYBox = ptRef:getY()+(nRadBaseBox*sin(DGD.A3))
dPosYUpDw = ptRef:getY()+(nRadBaseUpDw*sin(DGD.A3-nAngleBaseUpDw))
dPosYHeadExt = ptRef:getY()+(dPosXHead*sin(DGD.A2))
else
dPosY = ptRef:getY()+(nRadBase*sin(DGD.A8+nAngleBase))
dPosYBox = ptRef:getY()+(nRadBaseBox*sin(DGD.A8))
dPosYUpDw = ptRef:getY()+(nRadBaseUpDw*sin(DGD.A8+nAngleBaseUpDw))
dPosYHeadExt = ptRef:getY()+(dPosXHead*sin(DGD.A1))
end
end
dPosYHead = ptRef:getY()
else
-- se applicato a lato top o bottom cambio la coordinata in Y
if string.lower(tFlushB.side) == 'top' then
dPosY = DGD.dH - tFlushB.position
dPosYUpDw = DGD.dH - tFlushB.position
else
dPosY = tFlushB.position
dPosYUpDw = tFlushB.position
end
end
end
dPosYProbe = dPosY
dYFromExt = dPosY
else -- altrimenti tipo corner
if DGD.sFrame and ( DGD.nTypePz == 5 or DGD.nTypePz == 6) then
dPosY = 0 + DGD.dZedExtFrame
dPosYUpDw = dPosY
bPushDr = not bPushDr
else
if bRemake then
-- se applicato a lato top o bottom cambio la coordinata in Y
if string.lower(tFlushB.side) == 'top' then
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PminTop
dPosY = ptRef:getY()+(dPosX*cos(DGD.A4))
else
ptRef = DGD.PmaxTop
dPosY = ptRef:getY()+(dPosX*cos(DGD.A8))
end
dPosYProbe = dPosY - DGD.DPR
dYFromExt = dPosY - DGD.DPR
else
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PminBot
dPosY = ptRef:getY()+(dPosX*cos(DGD.A4))
else
ptRef = DGD.PmaxBot
dPosY = ptRef:getY()+(dPosX*cos(DGD.A8))
end
dPosYProbe = dPosY + DGD.DPR
dYFromExt = dPosY + DGD.DPR
end
dPosYHead = ptRef:getY()
else
-- se applicato a lato top o bottom cambio la coordinata in Y
if string.lower(tFlushB.side) == 'top' then
dPosY = DGD.dH
dPosYProbe = dPosY - DGD.DPR
dYFromExt = dPosY - DGD.DPR
else
dPosY = 0
dPosYProbe = DGD.DPR
dYFromExt = dPosY + DGD.DPR
end
end
end
dPosYUpDw = dPosY
end
if bPushDr then
dZedPos = dPosZ
else
dZedPos = (DGD.dT - dPosZ)
end
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
if string.lower(tFlushB.type) == 'extension' then
if string.lower(tFlushB.side) == 'top' then
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)), dPosY , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A4)), dPosYBox , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A4+nAngleBaseUpDw)),dPosYUpDw , DGD.dT)
ptPosHeadExt = Point3d( ptRef:getX()+(dPosXHead*cos(DGD.A5)), dPosYHeadExt , dZedPos)
else
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A3-nAngleBase)), dPosY , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A3)), dPosYBox , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A3-nAngleBaseUpDw)), dPosYUpDw , DGD.dT)
ptPosHeadExt = Point3d( ptRef:getX()+(dPosXHead*cos(DGD.A2)), dPosYHeadExt , dZedPos)
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
else
ptPos = Point3d( ptRef:getX()+(dPosX*sin(DGD.A3)), dPosY , dZedPos)
end
ptPosHead = Point3d( ptRef:getX(), dPosYHead , dZedPos)
dPosXProbe = ptPos:getX() + DGD.DPR
dXFromExt = ptPos:getX()
else
ptPos = Point3d( dPosX + EgtIf( DGD.sFrame, DGD.dSideExtFrame, 0), dPosY , dZedPos)
ptPosBox = Point3d( EgtIf( DGD.sFrame, DGD.dSideExtFrame, 0), dPosY , dZedPos)
dPosXProbe = dPosX + DGD.DPR
dXFromExt = 0
if tFlushB.back_set then
ptPosUpGeom = Point3d( ( dPosXUpDw + tFlushB.back_set + EgtIf( DGD.sFrame, DGD.dSideExtFrame, 0)), dPosYUpDw , DGD.dT)
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
end
end
else -- serratura a destra
if bRemake then
if string.lower(tFlushB.type) == 'extension' then
if string.lower(tFlushB.side) == 'top' then
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)), dPosY , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A7)), dPosYBox , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A7-nAngleBaseUpDw)), dPosYUpDw , DGD.dT)
ptPosHeadExt = Point3d( ptRef:getX()+(dPosXHead*cos(DGD.A6)), dPosYHeadExt , dZedPos)
else
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A8+nAngleBase)), dPosY , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A8)), dPosYBox , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A8+nAngleBaseUpDw)), dPosYUpDw , DGD.dT)
ptPosHeadExt = Point3d( ptRef:getX()+(dPosXHead*cos(DGD.A1)), dPosYHeadExt , dZedPos)
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
else
ptPos = Point3d( ptRef:getX()+(dPosX*sin(DGD.A7)), dPosY , dZedPos)
end
ptPosHead = Point3d( ptRef:getX(), dPosYHead , dZedPos)
dPosXProbe = ptPos:getX() - DGD.DPR
dXFromExt = ptPos:getX()
else
ptPos = Point3d( ( DGD.dW - dPosX - EgtIf( DGD.sFrame, DGD.dSideExtFrame, 0)), dPosY , dZedPos)
ptPosBox = Point3d( DGD.dW - EgtIf( DGD.sFrame, DGD.dSideExtFrame, 0), dPosY , dZedPos)
dPosXProbe = DGD.dW - dPosX - DGD.DPR
dXFromExt = DGD.dW
if tFlushB.back_set then
ptPosUpGeom = Point3d( ( DGD.dW - dPosXUpDw - tFlushB.back_set - EgtIf( DGD.sFrame, DGD.dSideExtFrame, 0)), dPosYUpDw , DGD.dT)
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
end
end
end
MoveGeometryLck( 'flushbolt', tFlushB.geom, sSideLk, bPushDr, ptPos, ptPosHead, ptPosHeadExt, dPosXHead, ptPosBox, ptPosUpGeom, ptPosDwGeom)
InsertProbeGeom( tFlushB.geom, Point3d(dPosXProbe,dPosYProbe,0), Point3d(dXFromExt,dYFromExt,0), 11, 3)
end
-----------------------------------------------------------------
local function MoveEdgePull( tEdgeP, sSideLk, bPushDr)
local dPosX
local dPosZ
local ptPos
local ptRef
local ptPosUpGeom
local ptPosDwGeom
local dPosXProbe
local dXFromExt
local dYFromExt
local dDeltaX
local dZedPos = 0
local nAngleBase
local nRadBase
local ptDummy = Point3d{0,0,0}
if DGD.OFFSET and DGD.OFFSET > 0 then
dDeltaX = DGD.OFFSET * TAN3
dPosZ = DGD.OFFSET
else
dDeltaX = (DGD.dT/2) * TAN3
dPosZ = (DGD.dT/2)
end
if DGD.tProfs.lockedge.trimming == 'BU' or DGD.tProfs.lockedge.trimming == 'BD' or
DGD.tProfs.lockedge.trimming == 'BDEB' or DGD.tProfs.lockedge.trimming == 'BUEB' then -- se profilo bevel
dPosX = dDeltaX
else
dPosX = 0
end
-- by DGC.Bwd setting set to 0 the dPosX parameter
if DGC.Bwd and DGC.Bwd == 2 then
dPosX = 0
end
if DGD.sFrame then
sSideLk = EgtIf( sSideLk == 'L', 'R', 'L')
end
if bRemake then
nAngleBase = atan(dPosX/tEdgeP.position)
nRadBase = sqrt((dPosX*dPosX)+(tEdgeP.position*tEdgeP.position))
end
if bPushDr then
dZedPos = dPosZ
else
dZedPos = (DGD.dT - dPosZ)
end
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
ptRef = DGD.PminTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A4+nAngleBase)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(tEdgeP.position*cos(DGD.A4)), ptRef:getY()+(tEdgeP.position*sin(DGD.A4)) , DGD.dT)
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
else
ptPos = Point3d( dPosX + EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tEdgeP.position) , dZedPos)
ptPosUpGeom = Point3d( EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tEdgeP.position) , DGD.dT)
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
end
dPosXProbe = dPosX + DGD.DPR
dXFromExt = 0
dYFromExt = ptPos:getY()
else -- serratura a destra
if bRemake then
ptRef = DGD.PmaxTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A7-nAngleBase)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(tEdgeP.position*cos(DGD.A7)), ptRef:getY()+(tEdgeP.position*sin(DGD.A7)) , DGD.dT)
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
else
ptPos = Point3d( ( DGD.dW - dPosX - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tEdgeP.position) , dZedPos)
ptPosUpGeom = Point3d( ( DGD.dW - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tEdgeP.position) , DGD.dT)
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
end
dPosXProbe = DGD.dW - dPosX - DGD.DPR
dXFromExt = DGD.dW
dYFromExt = ptPos:getY()
end
MoveGeometryLck( 'edgepull', tEdgeP.geom, sSideLk, bPushDr, ptPos, ptPosUpGeom, ptPosDwGeom)
InsertProbeGeom( tEdgeP.geom, Point3d(dPosXProbe,ptPos:getY(),0), Point3d(dXFromExt,dYFromExt,0), 10, 3)
end
-----------------------------------------------------------------
local function MoveStrike( tStrike, sSideLk, bPushDr)
local dPosX
local dPosXUpDw
local dPosZ
local ptPos
local ptPosBox
local ptRef
local ptFromExt
local ptPosUpGeom
local ptPosDwGeom
local dDeltaX
local dZedPos = 0
local nAngleBase
local nRadBase
local nAngleBaseUpDw
local nRadBaseUpDw
if DGD.OFFSET and DGD.OFFSET > 0 then
dDeltaX = DGD.OFFSET * TAN3
dPosZ = DGD.OFFSET
else
dDeltaX = (DGD.dT/2) * TAN3
dPosZ = (DGD.dT/2)
end
if DGD.tProfs.lockedge.trimming == 'BU' or DGD.tProfs.lockedge.trimming == 'BD' or
DGD.tProfs.lockedge.trimming == 'BDEB' or DGD.tProfs.lockedge.trimming == 'BUEB' then -- se profilo bevel
dPosX = dDeltaX
dPosXUpDw = dDeltaX
else
dPosX = 0
dPosXUpDw = 0
end
-- by DGC.Bwd setting set to 0 the dPosXUpDw and dPosX parameters
if DGC.Bwd and DGC.Bwd >= 1 then
dPosXUpDw = 0
if DGC.Bwd == 2 then
dPosX = 0
end
end
if DGD.sFrame then
sSideLk = EgtIf( sSideLk == 'L', 'R', 'L')
end
if bRemake then
nAngleBase = atan(dPosX/tStrike.position)
nRadBase = sqrt((dPosX*dPosX)+(tStrike.position*tStrike.position))
nRadBaseBox = tStrike.position
nAngleBaseUpDw = atan((dPosXUpDw+tStrike.back_set)/tStrike.position)
nRadBaseUpDw = sqrt(((dPosXUpDw+tStrike.back_set)*(dPosXUpDw+tStrike.back_set))+(tStrike.position*tStrike.position))
end
if bPushDr then
dZedPos = dPosZ
else
dZedPos = (DGD.dT - dPosZ)
end
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
ptRef = DGD.PminTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A4+nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A4)), ptRef:getY()+(nRadBaseBox*sin(DGD.A4)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A4+nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A4+nAngleBaseUpDw)) , DGD.dT)
ptPosDwGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A4+nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A4+nAngleBaseUpDw)) , 0)
ptFromExt = ptPosUpGeom
else
ptPos = Point3d( dPosX + EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tStrike.position) , dZedPos)
ptPosBox = Point3d( EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tStrike.position) , dZedPos)
ptPosUpGeom = Point3d( ( dPosXUpDw + tStrike.back_set + EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tStrike.position) , DGD.dT)
ptPosDwGeom = Point3d( ( dPosXUpDw + tStrike.back_set + EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tStrike.position) , 0)
ptFromExt = Point3d( EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tStrike.position) , DGD.dT)
end
else -- serratura a destra
if bRemake then
ptRef = DGD.PmaxTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A7-nAngleBase)) , dZedPos)
ptPosBox = Point3d( ptRef:getX()+(nRadBaseBox*cos(DGD.A7)), ptRef:getY()+(nRadBaseBox*sin(DGD.A7)) , dZedPos)
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A7-nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A7-nAngleBaseUpDw)) , DGD.dT)
ptPosDwGeom = Point3d( ptRef:getX()+(nRadBaseUpDw*cos(DGD.A7-nAngleBaseUpDw)), ptRef:getY()+(nRadBaseUpDw*sin(DGD.A7-nAngleBaseUpDw)) , 0)
ptFromExt = ptPosUpGeom
else
ptPos = Point3d( ( DGD.dW - dPosX - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tStrike.position) , dZedPos)
ptPosBox = Point3d( ( DGD.dW - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tStrike.position) , dZedPos)
ptPosUpGeom = Point3d( ( DGD.dW - dPosXUpDw - tStrike.back_set - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tStrike.position) , DGD.dT)
ptPosDwGeom = Point3d( ( DGD.dW - dPosXUpDw - tStrike.back_set - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tStrike.position) , 0)
ptFromExt = Point3d( ( DGD.dW - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tStrike.position) , DGD.dT)
end
end
MoveGeometryLck( 'strike', tStrike.geom, sSideLk, bPushDr, ptPos, ptPosUpGeom, ptPosDwGeom, nil, ptPosBox)
InsertProbeGeom( tStrike.geom, ptPosUpGeom, ptFromExt, 14, 3)
end
-----------------------------------------------------------------
-- *** Geometric processing : VIEWERS ***
-----------------------------------------------------------------
local function MoveSubGeomViewer( nSubViewerId, sSideDoor, sSideLk, ptPosUpGeom, ptPosDwGeom)
if ( sSideDoor == 'secure') then
EgtRotate( nSubViewerId, ORIG(), X_AX(), 180 ) -- ruoto su faccia inferiore
end
EgtRotate( nSubViewerId, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
if sSideLk == 'R' then -- se serratura a destra
EgtMirror( nSubViewerId, ORIG(), X_AX()) -- faccio il mirror su asse Y
end
if ( sSideDoor == 'secure') then
EgtMove( nSubViewerId, ptPosDwGeom - ORIG())
else
EgtMove( nSubViewerId, ptPosUpGeom - ORIG())
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nSubViewerId), nSubViewerId, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nSubViewerId), EgtGetParent(nSubViewerId))
end
-----------------------------------------------------------------
local function MoveGeomViewer( nViewerId, sSideLk, ptPosUpGeom, ptPosDwGeom)
if not nViewerId then return end
local nIdGeomViewer
local sSideDoorToMove
local sMessageErr = ''
-- devo ottenere tutte le geometrie dello spioncino
nIdGeomViewer = EgtGetFirstInGroup( nViewerId) -- ottengo la prima geometria
local nErr = 0
while nIdGeomViewer do
sSideDoorToMove = EgtGetInfo( nIdGeomViewer, 'SideDoor')
if sSideDoorToMove then
-- Controllo se la nota è corretta
local sSideDoor = string.lower(sSideDoorToMove)
-- keyway e secure: no rotazione angolo profilo;
if sSideDoor == 'keyway' or sSideDoor == 'secure' then
MoveSubGeomViewer( nIdGeomViewer, sSideDoor, sSideLk, ptPosUpGeom, ptPosDwGeom)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[418],nIdGeomViewer,nViewerId, sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1007
end
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[419],nIdGeomViewer,nViewerId, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1008
end
nIdGeomViewer = EgtGetNext(nIdGeomViewer)
end
-- assegno codice errore se ancora non fatto
if DGD.ERR == 0 then DGD.ERR = nErr end
end
-----------------------------------------------------------------
local function MoveViewer( tViewer, sSideLk, bPushDr)
local ptPosUpGeom
local ptPosDwGeom
local ptRef
local dZedPos = 0
local nAngleBase
local nRadBase
local dPosY
local dPosX
if bRemake then
dPosX = EgtIf( sSideLk == 'L', ( DGD.dW / 2) + tViewer.delta_center, ( DGD.dW / 2) - tViewer.delta_center)
nAngleBase = atan(dPosX,tViewer.bottom_rail)
nRadBase = sqrt((dPosX*dPosX)+(tViewer.bottom_rail*tViewer.bottom_rail))
end
local dPosY = EgtIf( tViewer.side and tViewer.side == 'top', ( DGD.dH - tViewer.bottom_rail), tViewer.bottom_rail)
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
if tViewer.side and tViewer.side == 'top' then
ptRef = DGD.PminTop
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A4+nAngleBase)) , DGD.dT)
else
ptRef = DGD.PminBot
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A3-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A3-nAngleBase)) , DGD.dT)
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
else
ptPosUpGeom = Point3d( ( ( DGD.dW / 2) + tViewer.delta_center), dPosY , DGD.dT)
ptPosDwGeom = Point3d( ( ( DGD.dW / 2) + tViewer.delta_center), dPosY , 0)
end
else -- serratura a destra
if bRemake then
if tViewer.side and tViewer.side == 'top' then
ptRef = DGD.PmaxTop
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A7-nAngleBase)) , DGD.dT)
else
ptRef = DGD.PmaxBot
ptPosUpGeom = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A8+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A8+nAngleBase)) , DGD.dT)
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
else
ptPosUpGeom = Point3d( ( ( DGD.dW / 2) - tViewer.delta_center), dPosY , DGD.dT)
ptPosDwGeom = Point3d( ( ( DGD.dW / 2) - tViewer.delta_center), dPosY , 0)
end
end
MoveGeomViewer( tViewer.geom, sSideLk, ptPosUpGeom, ptPosDwGeom)
if bRemake then
local dAngleLoc
dAngleLoc = (DGD.A3 + DGD.A8) / 2
EgtRotate( tViewer.geom, ptPosUpGeom, Z_AX(), ( dAngleLoc-90))
end
InsertProbeGeom( tViewer.geom, ptPosDwGeom)
end
-----------------------------------------------------------------
-- *** Geometric subgeom processing : ROLLERLATCHS ***
-----------------------------------------------------------------
local function ApplyDispRollerLatch( nIdGeomType, nExtraAngle, sSideLk, bPushDr, sSideDoor, ptPosUpGeom, ptPos)
EgtRotate( nIdGeomType, ORIG(), X_AX(), -( 90 + nExtraAngle)) -- ruoto su faccia dietro
if DGD.SIDE == 'lock' then
if sSideLk == 'L' then -- se serratura a destra
EgtRotate( nIdGeomType, ORIG(), Z_AX(), 90 ) -- ruoto su faccia sinistra
else
EgtRotate( nIdGeomType, ORIG(), Z_AX(), -90 ) -- ruoto su faccia destra
end
end
if bPushDr then -- se apertura a spingere
EgtMirror( nIdGeomType, ORIG(), Z_AX())
end
if DGD.sFrame then
if string.lower(DGD.SIDE) == 'bottom' then -- frame superiore ( ha il side opposto)
if DGD.OTHERD then
EgtMirror( nIdGeomType, ORIG(), Y_AX())
else
EgtMirror( nIdGeomType, ORIG(), X_AX())
EgtMirror( nIdGeomType, ORIG(), Y_AX())
end
elseif string.lower(DGD.SIDE) == 'top' then -- frame inferiore (ha il side opposto)
if not DGD.OTHERD then
EgtMirror( nIdGeomType, ORIG(), X_AX())
end
end
else
if string.lower(DGD.SIDE) == 'bottom' then
EgtMirror( nIdGeomType, ORIG(), Y_AX())
end
end
-- se geometria sul fianco
if sSideDoor == 'edge' then -- se spostamento sul bordo
EgtMove( nIdGeomType, ptPosUpGeom - ORIG())
elseif ( sSideDoor == 'center') then -- se posizionamento in centro spessore
EgtMove( nIdGeomType, ptPos - ORIG())
end
end
local function MoveSubGeomRollerLatch( nSubRollerLatchId, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUpGeom, nExtraAngle, ptPosDwGeom)
-- ciclo sulle geometrie singole invece di modificare il layer
local nIdGeomType
nIdGeomType = EgtGetFirstInGroup( nSubRollerLatchId) -- ottengo la prima geometria
while nIdGeomType do
local sSideDoorBox = EgtGetInfo( nIdGeomType, 'SideDoor')
local nUpperToDelete
-- rinomino eventuali geometrie che descrivono solo la sezione
if sSideDoorBox and sSideDoorBox == 'upper' then
if not DGD.Dws then
if bPushDr then
EgtSetInfo( nIdGeomType, 'SideDoor', 'keyway')
sSideDoorBox = 'keyway'
else
EgtSetInfo( nIdGeomType, 'SideDoor', 'secure')
sSideDoorBox = 'secure'
end
else
EgtSetInfo( nIdGeomType, 'SideDoor', 'keyway')
sSideDoorBox = 'keyway'
end
nUpperToDelete = nIdGeomType
end
if sSideDoorBox == 'keyway' or sSideDoorBox == 'secure' then
if not DGD.Dws then -- se disposizione frame su lato narrow o porta
EgtRotate( nIdGeomType, ORIG(), X_AX(), 180)
if DGD.SIDE == 'lock' then
if sSideLk == 'L' then -- se serratura a destra
EgtRotate( nIdGeomType, ORIG(), Z_AX(), 90 ) -- ruoto su faccia sinistra
else
EgtRotate( nIdGeomType, ORIG(), Z_AX(), -90 ) -- ruoto su faccia destra
end
end
if bPushDr then -- se apertura a spingere
EgtMirror( nIdGeomType, ORIG(), Z_AX())
end
if DGD.sFrame then
if string.lower(DGD.SIDE) == 'bottom' then -- frame superiore ( ha il side opposto)
if DGD.OTHERD then
EgtMirror( nIdGeomType, ORIG(), Y_AX())
else
EgtMirror( nIdGeomType, ORIG(), X_AX())
EgtMirror( nIdGeomType, ORIG(), Y_AX())
end
elseif string.lower(DGD.SIDE) == 'top' then -- frame inferiore (ha il side opposto)
if not DGD.OTHERD then
EgtMirror( nIdGeomType, ORIG(), X_AX())
end
end
else
if string.lower(DGD.SIDE) == 'bottom' then
EgtMirror( nIdGeomType, ORIG(), Y_AX())
end
end
EgtMove( nIdGeomType, ptPosDwGeom - ORIG())
else
ApplyDispRollerLatch( nIdGeomType, nExtraAngle, sSideLk, bPushDr, sSideDoor, ptPosUpGeom, ptPos)
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nIdGeomType), nIdGeomType, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nIdGeomType), EgtGetParent(nIdGeomType))
else
if sSideDoorBox and string.lower(sSideDoorBox) == 'locklh' then
nExtraAngle = 0
end
ApplyDispRollerLatch( nIdGeomType, nExtraAngle, sSideLk, bPushDr, sSideDoor, ptPosUpGeom, ptPos)
end
nIdGeomType = EgtGetNext(nIdGeomType)
-- cancello il percorso 'upper'
if nUpperToDelete then
EgtErase( nUpperToDelete)
end
end
end
-----------------------------------------------------------------
-- *** Geometric subgeom processing : PIVOTS ***
-----------------------------------------------------------------
local function ApplyDispPivot( nIdGeomType, nLocAngle, bPushDr, sSideLk, sSideDoor, ptPosUpGeom, ptPos)
EgtRotate( nIdGeomType, ORIG(), X_AX(), ( 90 + nLocAngle), GDB_RT.GLOB) -- ruoto su faccia frontale per RHR e LHR
EgtRotate( nIdGeomType, ORIG(), Z_AX(), 90, GDB_RT.GLOB) -- ruoto su faccia destra RHR e LHR
if bPushDr then -- se apertura a spingere RH LH
EgtMirror( nIdGeomType, ORIG(), Z_AX(), GDB_RT.GLOB)
end
if sSideLk == 'R' then -- se serratura a destra LH LHR
EgtMirror( nIdGeomType, ORIG(), X_AX(), GDB_RT.GLOB)
end
if sSideDoor == 'edge' then -- se spostamento sul bordo
EgtMove( nIdGeomType, ptPosUpGeom - ORIG(), GDB_RT.GLOB)
elseif ( sSideDoor == 'center') then -- se posizionamento in centro spessore
EgtMove( nIdGeomType, ptPos - ORIG(), GDB_RT.GLOB)
end
end
local function MoveSubGeomPivot( nSubPivotId, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUpGeom, nExtraAngle, ptPosDwGeom)
if string.lower(DGD.TYPE) ~= 'offsetintermediate' then
EgtRotate( nSubPivotId, ORIG(), X_AX(), -90) -- ruoto su faccia dietro
if DGD.sFrame then
if DGD.nTypePz == 5 then
-- se serratura a destra: LH, LHR, ... e non è sulla seconda anta
if ( sSideLk == 'R' and not DGD.OTHERD) or
( sSideLk == 'L' and DGD.OTHERD) then
EgtMirror( nSubPivotId, ORIG(), X_AX())
end
elseif DGD.nTypePz == 6 then
-- se serratura a destra: LH, LHR, ... e non è sulla seconda anta
if ( sSideLk == 'R' and DGD.OTHERD) or
( sSideLk == 'L' and not DGD.OTHERD) then
EgtMirror( nSubPivotId, ORIG(), X_AX())
end
end
if not bPushDr then -- se apertura a tirare
EgtMirror( nSubPivotId, ORIG(), Z_AX())
end
else
if sSideLk == 'R' then -- se serratura a destra: LH, LHR, ...
EgtMirror( nSubPivotId, ORIG(), X_AX())
end
if not bPushDr then -- se apertura a tirare
EgtMirror( nSubPivotId, ORIG(), Z_AX())
end
end
if ( string.lower(DGD.SIDE) == 'bottom') then
EgtMirror( nSubPivotId, ORIG(), Y_AX())
elseif DGD.sFrame and ( string.lower(DGD.SIDE) == 'top') then
EgtMirror( nSubPivotId, ORIG(), X_AX())
end
if sSideDoor == 'edge' then -- se spostamento sul bordo
EgtMove( nSubPivotId, ptPosUpGeom - ORIG())
elseif ( sSideDoor == 'center') then -- se posizionamento in centro spessore
EgtMove( nSubPivotId, ptPos - ORIG())
end
-- gestione percorsi upper
local nIdGeomType = EgtGetFirstInGroup( nSubPivotId) -- ottengo la prima geometria
local sSideDoorBox
while nIdGeomType do
sSideDoorBox = EgtGetInfo( nIdGeomType, 'SideDoor')
local nUpperToDelete
-- rinomino eventuali geometrie che descrivono solo la sezione
if sSideDoorBox and sSideDoorBox == 'upper' then
if not DGD.Dws then
if bPushDr then
EgtSetInfo( nIdGeomType, 'SideDoor', 'secure')
sSideDoorBox = 'secure'
else
EgtSetInfo( nIdGeomType, 'SideDoor', 'keyway')
sSideDoorBox = 'keyway'
end
else
EgtSetInfo( nIdGeomType, 'SideDoor', 'keyway')
sSideDoorBox = 'keyway'
end
nUpperToDelete = nIdGeomType
end
if sSideDoorBox == 'keyway' or sSideDoorBox == 'secure' then
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nIdGeomType), nIdGeomType, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nIdGeomType), EgtGetParent(nIdGeomType))
end
nIdGeomType = EgtGetNext(nIdGeomType)
-- cancello il percorso 'upper'
if nUpperToDelete then
EgtErase( nUpperToDelete)
end
end
else -- altimrnti è offset intermediate
local nLocAngle = nExtraAngle
local sSideDoorBox
local nIdGeomType = EgtGetFirstInGroup( nSubPivotId) -- ottengo la prima geometria
while nIdGeomType do
sSideDoorBox = EgtGetInfo( nIdGeomType, 'SideDoor')
local nUpperToDelete
if sSideDoorBox and string.lower(sSideDoorBox) == 'locklh' then
nLocAngle = 0
end
-- rinomino eventuali geometrie che descrivono solo la sezione
if sSideDoorBox and sSideDoorBox == 'upper' then
if not DGD.Dws then
if bPushDr then
EgtSetInfo( nIdGeomType, 'SideDoor', 'secure')
sSideDoorBox = 'secure'
else
EgtSetInfo( nIdGeomType, 'SideDoor', 'keyway')
sSideDoorBox = 'keyway'
end
else
EgtSetInfo( nIdGeomType, 'SideDoor', 'keyway')
sSideDoorBox = 'keyway'
end
nUpperToDelete = nIdGeomType
end
if sSideDoorBox == 'keyway' or sSideDoorBox == 'secure' then
if not DGD.Dws then -- se disposizione frame su lato narrow o porta
-- if DGD.SIDE == 'hinge' then
-- if sSideLk == 'L' then -- se serratura a sinistra
-- EgtRotate( nIdGeomType, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
-- else
-- EgtRotate( nIdGeomType, ORIG(), Z_AX(), -90 ) -- ruoto su faccia sinistra
-- end
-- end
EgtRotate( nIdGeomType, ORIG(), Z_AX(), 90 ) -- ruoto su faccia destra
if bPushDr then -- se apertura a spingere
EgtMirror( nIdGeomType, ORIG(), Z_AX())
end
if sSideLk == 'R' then -- se serratura a destra LH LHR
EgtMirror( nIdGeomType, ORIG(), X_AX(), GDB_RT.GLOB)
end
if DGD.sFrame then
if string.lower(DGD.SIDE) == 'bottom' then -- frame superiore ( ha il side opposto)
if DGD.OTHERD then
EgtMirror( nIdGeomType, ORIG(), Y_AX())
else
EgtMirror( nIdGeomType, ORIG(), X_AX())
EgtMirror( nIdGeomType, ORIG(), Y_AX())
end
elseif string.lower(DGD.SIDE) == 'top' then -- frame inferiore (ha il side opposto)
if not DGD.OTHERD then
EgtMirror( nIdGeomType, ORIG(), X_AX())
end
end
else
-- if string.lower(DGD.SIDE) == 'bottom' then
-- EgtMirror( nIdGeomType, ORIG(), Y_AX())
-- end
end
EgtMove( nIdGeomType, ptPosDwGeom - ORIG())
else
ApplyDispPivot( nIdGeomType, nLocAngle, bPushDr, sSideLk, sSideDoor, ptPosUpGeom, ptPos)
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nIdGeomType), nIdGeomType, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nIdGeomType), EgtGetParent(nIdGeomType))
else
ApplyDispPivot( nIdGeomType, nLocAngle, bPushDr, sSideLk, sSideDoor, ptPosUpGeom, ptPos)
end
nIdGeomType = EgtGetNext(nIdGeomType)
-- cancello il percorso 'upper'
if nUpperToDelete then
EgtErase( nUpperToDelete)
end
end
end
end
-----------------------------------------------------------------
-- *** Geometric subgeom processing : STOPSANDCLOSERS ***
-----------------------------------------------------------------
local function MoveSubGeomStopAndCloser( nSubtStopAndCloserId, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUp, nBoxGeom, ptPosUpGeom, ptPosDwGeom)
local dDeltaPos = 0
local sDeltaPos
local psDelta
-- ciclo sulle geometrie singole invece di modificare il layer
local nIdGeomType
-- se devo muovere le singole geometrie dell' OverHead o il layer dello stop&closer e la geometria di ingombro presente nello Stop&Closer
if not nBoxGeom or nBoxGeom == 0 then
nIdGeomType = nSubtStopAndCloserId
-- se geometria sul fianco
if sSideDoor == 'edge' then -- se spostamento sul bordo
sDeltaPos = EgtGetInfo( nIdGeomType, 'DeltaPos')
if sDeltaPos then
dDeltaPos = tonumber( sDeltaPos)
end
EgtRotate( nIdGeomType, ORIG(), X_AX(), -90 ) -- ruoto su faccia dietro
if DGD.SIDE and string.lower(DGD.SIDE) == 'bottom' then
EgtMirror( nIdGeomType, ORIG(), Y_AX())
end
if bPushDr then -- se apertura a spingere
EgtMirror( nIdGeomType, ORIG(), Z_AX()) -- faccio il mirror su asse Z per ribaltare l'uscita in alto
EgtMirror( nIdGeomType, ORIG(), X_AX()) -- faccio il mirror su asse X per risistemare la direzione percorso
EgtMove( nIdGeomType, Point3d( -dDeltaPos, 0, 0) - ORIG()) -- riposiziono per il ribaltamento del mirror in X
end
if DGD.sFrame then
if ( sSideLk == 'R' and DGD.OTHERD) or
( sSideLk == 'L' and not DGD.OTHERD) then
dDeltaPos = 0
end
else
if sSideLk == 'L' then -- se serratura a sinistra
dDeltaPos = 0
end
end
if bRemake then
if DGD.SIDE and string.lower(DGD.SIDE) == 'bottom' then
psDelta = Point3d( ( dDeltaPos * cos(DGD.A2)), ( dDeltaPos * sin(DGD.A2)), 0)
else
psDelta = Point3d( ( dDeltaPos * cos(DGD.A5)), ( dDeltaPos * sin(DGD.A5)), 0)
end
else
psDelta = Point3d( dDeltaPos, 0, 0)
end
EgtMove( nIdGeomType, ( ptPosUp + psDelta) - ORIG())
if bRemake then
if DGD.SIDE and string.lower(DGD.SIDE) == 'bottom' then
EgtRotate( nIdGeomType, ( ptPosUp + psDelta), Z_AX(), DGD.A2)
else
EgtRotate( nIdGeomType, ( ptPosUp + psDelta), Z_AX(), DGD.A5)
end
end
elseif ( sSideDoor == 'center') then -- se posizionamento in centro spessore
sDeltaPos = EgtGetInfo( nIdGeomType, 'DeltaPos')
if sDeltaPos then
dDeltaPos = tonumber( sDeltaPos)
end
EgtRotate( nIdGeomType, ORIG(), X_AX(), -90, GDB_RT.GLOB) -- ruoto su faccia dietro su coordinate globali
if DGD.SIDE and string.lower(DGD.SIDE) == 'bottom' then
EgtMirror( nIdGeomType, ORIG(), Y_AX())
end
if DGD.sFrame then
if ( sSideLk == 'R' and DGD.OTHERD) or
( sSideLk == 'L' and not DGD.OTHERD) then
dDeltaPos = 0
end
else
if sSideLk == 'L' then -- se serratura a sinistra
dDeltaPos = 0
end
end
if bRemake then
if DGD.SIDE and string.lower(DGD.SIDE) == 'bottom' then
psDelta = Point3d( ( dDeltaPos * cos(DGD.A2)), ( dDeltaPos * sin(DGD.A2)), 0)
else
psDelta = Point3d( ( dDeltaPos * cos(DGD.A5)), ( dDeltaPos * sin(DGD.A5)), 0)
end
else
psDelta = Point3d( dDeltaPos, 0, 0)
end
EgtMove( nIdGeomType, ( ptPos + psDelta) - ORIG())
if bRemake then
if DGD.SIDE and string.lower(DGD.SIDE) == 'bottom' then
EgtRotate( nIdGeomType, ( ptPos + psDelta), Z_AX(), DGD.A2)
else
EgtRotate( nIdGeomType, ( ptPos + psDelta), Z_AX(), DGD.A5)
end
end
end
-- cerco nel layer la geometria di ingombro presente nello Stop&Closer
if nBoxGeom then
nIdGeomType = EgtGetFirstInGroup( nSubtStopAndCloserId) -- ottengo la prima geometria
while nIdGeomType do
local sSideDoorBox = EgtGetInfo( nIdGeomType, 'SideDoor')
local nUpperToDelete
-- rinomino eventuali geometrie che descrivono solo la sezione
if sSideDoorBox and sSideDoorBox == 'upper' then
if not DGD.Dws then
if bPushDr then
EgtSetInfo( nIdGeomType, 'SideDoor', 'keyway')
sSideDoorBox = 'keyway'
else
EgtSetInfo( nIdGeomType, 'SideDoor', 'secure')
sSideDoorBox = 'secure'
end
else
EgtSetInfo( nIdGeomType, 'SideDoor', 'keyway')
sSideDoorBox = 'keyway'
end
nUpperToDelete = nIdGeomType
end
if sSideDoorBox == 'keyway' or sSideDoorBox == 'secure' then
if not DGD.Dws then -- se disposizione frame su lato narrow o porta
EgtRotate( nIdGeomType, ORIG(), X_AX(), -90 ) -- ruoto su faccia dietro
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nIdGeomType), nIdGeomType, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nIdGeomType), EgtGetParent(nIdGeomType))
elseif sSideDoorBox == 'Keyway' then -- geometria originale
if not DGD.Dws then
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nIdGeomType), nIdGeomType, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nIdGeomType), EgtGetParent(nIdGeomType))
end
elseif sSideDoorBox == 'Secure' then -- geometria originale
if not DGD.Dws then
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nIdGeomType), nIdGeomType, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nIdGeomType), EgtGetParent(nIdGeomType))
end
end
nIdGeomType = EgtGetNext(nIdGeomType)
-- cancello il percorso 'upper'
if nUpperToDelete then
EgtErase( nUpperToDelete)
end
end
end
elseif nBoxGeom == 1 then -- se singolo persorso di ingombro dell'OverHead
nIdGeomType = nSubtStopAndCloserId
if bPushDr then
EgtSetInfo( nIdGeomType, 'SideDoor', 'keyway')
sSideDoorBox = 'keyway'
else
EgtSetInfo( nIdGeomType, 'SideDoor', 'secure')
sSideDoorBox = 'secure'
end
-- le geometrie di ingombro sono posizionate sempre sul bordo, quindi tipo 'edge'
sDeltaPos = EgtGetInfo( nIdGeomType, 'DeltaPos')
if sDeltaPos then
dDeltaPos = tonumber( sDeltaPos)
end
EgtRotate( nIdGeomType, ORIG(), X_AX(), 180 ) -- ruoto su faccia dietro
if DGD.SIDE and string.lower(DGD.SIDE) == 'bottom' then
EgtMirror( nIdGeomType, ORIG(), Y_AX())
end
if bPushDr then -- se apertura a spingere
EgtMirror( nIdGeomType, ORIG(), Z_AX()) -- faccio il mirror su asse Z per ribaltare l'uscita in alto
EgtMirror( nIdGeomType, ORIG(), X_AX()) -- faccio il mirror su asse X per risistemare la direzione percorso
EgtMove( nIdGeomType, Point3d( -dDeltaPos, 0, 0) - ORIG()) -- riposiziono per il ribaltamento del mirror in X
end
if DGD.sFrame then
-- se serratura a destra: LH, LHR, ... e non è sulla seconda anta
if ( sSideLk == 'R' and not DGD.OTHERD) or
( sSideLk == 'L' and DGD.OTHERD) then
EgtMirror( nSubPivotId, ORIG(), X_AX())
end
if sSideLk == 'L' then -- se serratura a sinistra
dDeltaPos = 0
end
else
if sSideLk == 'L' then -- se serratura a sinistra
dDeltaPos = 0
end
end
if bRemake then
if DGD.SIDE and string.lower(DGD.SIDE) == 'bottom' then
psDelta = Point3d( ( dDeltaPos * cos(DGD.A2)), ( dDeltaPos * sin(DGD.A2)), 0)
else
psDelta = Point3d( ( dDeltaPos * cos(DGD.A5)), ( dDeltaPos * sin(DGD.A5)), 0)
end
else
psDelta = Point3d( dDeltaPos, 0, 0)
end
EgtMove( nIdGeomType, ( ptPosUp + psDelta) - ORIG())
if bRemake then
if DGD.SIDE and string.lower(DGD.SIDE) == 'bottom' then
EgtRotate( nIdGeomType, ( ptPosUp + psDelta), Z_AX(), DGD.A2)
else
EgtRotate( nIdGeomType, ( ptPosUp + psDelta), Z_AX(), DGD.A5)
end
end
-- creo estrusi e superfici piane delle geometrie passanti
AddSurfTmByExtrusion( EgtGetParent(nIdGeomType), nIdGeomType, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( EgtGetParent(nIdGeomType), EgtGetParent(nIdGeomType))
-- cancello il percorso 'upper'
EgtErase( nUpperToDelete)
end
end
-----------------------------------------------------------------------------------------
-- *** Geometric processing : common functions for rollerlatch, pivot, stopandcloser ***
-----------------------------------------------------------------------------------------
local function MoveGeometryTopDwHSide( sTypeGeom, nGeomId, sSideLk, bPushDr, ptPos, ptPosUp, nExtraAngle, ptPosDw, ptPosUpGeom, ptPosDwGeom)
if not nGeomId then return end
local sSideDoorToMove
local sMessageErr = ''
sSideDoorToMove = EgtGetInfo( nGeomId, 'InserPoint')
local nErr = 0
if DGD.sFrame and DGD.nTypePz == 5 then
DGD.SIDE = 'bottom'
elseif DGD.sFrame and DGD.nTypePz == 6 then
DGD.SIDE = 'top'
end
if sSideDoorToMove then
-- Controllo se la nota è corretta
local sSideDoor = string.lower(sSideDoorToMove)
if sTypeGeom == 'rollerlatch' then
-- Edge: sullo spigolo della porta; Centre: in centro allo spessore
if sSideDoor == 'edge' or sSideDoor == 'center' then
MoveSubGeomRollerLatch( nGeomId, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUp, nExtraAngle, ptPosDw)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[415],nGeomId,'RollerLatch',sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1009
end
elseif sTypeGeom == 'pivot' then
-- Edge: sullo spigolo della porta; Centre: in centro allo spessore
if sSideDoor == 'edge' or sSideDoor == 'center' then
MoveSubGeomPivot( nGeomId, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUp, nExtraAngle, ptPosDw)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[415],nGeomId,'Pivot',sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1011
end
elseif sTypeGeom == 'stopandcloser' then
-- Edge: sullo spigolo della porta; Centre: in centro allo spessore
if sSideDoor == 'edge' or sSideDoor == 'center' then
local nBoxGeom = 0
MoveSubGeomStopAndCloser( nGeomId, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUp, nBoxGeom, ptPosUpGeom, ptPosDwGeom)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[415],nGeomId,'StopAndCloser',sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1013
end
end
else
-- messaggio di errore in base al tipo di pezzo
if sTypeGeom == 'rollerlatch' then
sMessageErr = string.format( EgtDoorsMsg[416],nGeomId,'RollerLatch', DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1010
elseif sTypeGeom == 'pivot' then
sMessageErr = string.format( EgtDoorsMsg[416],nPivotId,'Pivot', DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1012
elseif sTypeGeom == 'stopandcloser' then
sMessageErr = string.format( EgtDoorsMsg[416],nStopAndCloserId,'StopAndCloser', DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1014
end
end
-- assegno codice errore se ancora non fatto
if DGD.ERR == 0 then DGD.ERR = nErr end
end
----------------------------------------------------------------------
-- *** Geometric processing : ROLLERLATCH, PIVOTS, STOPSANDCLOSERS ***
----------------------------------------------------------------------
local function MoveRollerLatch( tRollerLatch, sSideLk, bPushDr)
local ptPos
local ptPosBox
local ptRef
local ptPosUpGeom
local ptPosDwGeom
local dPosX
local dPosY
local dPosXProbe
local dPosYProbe
local dPosZ
local dPosZup
local dXFromExt
local dYFromExt
local dDeltaX
local nAngleBase
local nRadBase
local nExtraAngle = 0
local nSideApplied = 2
if DGD.sFrame and DGD.nTypePz == 5 then
tRollerLatch.side = 'bottom'
bPushDr = not bPushDr
elseif DGD.sFrame and DGD.nTypePz == 6 then
tRollerLatch.side = 'top'
bPushDr = not bPushDr
end
if DGD.OFFSET and DGD.OFFSET > 0 then
dDeltaX = DGD.OFFSET * TAN3
dPosZ = DGD.OFFSET
else
dDeltaX = (DGD.dT/2) * TAN3
dPosZ = (DGD.dT/2)
end
-- se latch face ricalcolo il delta
if DGD.LSREF then
dDeltaX = DGD.dT * TAN3
end
if bPushDr then
dPosZup = DGD.dT
else
dPosZ = (DGD.dT - dPosZ)
dPosZup = 0
end
-- se applicato a lato top o bottom cambio la coordinata in Y
if string.lower(tRollerLatch.side) == 'bottom' then
if bRemake then
local dLocAngle
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PminBot
dLocAngle = DGD.A2
else
ptRef = DGD.PmaxBot
dLocAngle = DGD.A1
end
dPosY = ptRef:getY()+((tRollerLatch.position)*sin(dLocAngle))
else
dPosY = EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)
end
dPosYProbe = dPosY + DGD.DPR
dYFromExt = dPosY
nSideApplied = 4
elseif string.lower(tRollerLatch.side) == 'lock' then
if DGD.tProfs.lockedge.trimming == 'BU' or DGD.tProfs.lockedge.trimming == 'BD' or
DGD.tProfs.lockedge.trimming == 'BDEB' or DGD.tProfs.lockedge.trimming == 'BUEB' then -- se profilo bevel su lato lock
dPosX = dDeltaX
-- se non è presente il blocco rotazione su bevel
if not DGD.NOBVROT then
nExtraAngle = 3
end
else
dPosX = 0
end
-- by DGC.Bwd setting set to 0 the dPosX parameter
if DGC.Bwd and DGC.Bwd == 2 then
dPosX = 0
end
if bRemake then
nAngleBase = atan(dPosX/tRollerLatch.position)
nRadBase = sqrt((dPosX*dPosX)+(tRollerLatch.position*tRollerLatch.position))
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PminTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A4+nAngleBase)) , dPosZ)
ptPosBox = Point3d( ptRef:getX()+(tRollerLatch.position*cos(DGD.A4)), ptRef:getY()+(tRollerLatch.position*sin(DGD.A4)) , dPosZ)
dPosXProbe = ptRef:getX() + DGD.DPR
dXFromExt = ptRef:getX()
dPosYProbe = ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase)) + DGD.DPR -- setto la X invece della Y
dYFromExt = dPosYProbe
else
ptRef = DGD.PmaxTop
ptPos = Point3d( ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)), ptRef:getY()+(nRadBase*sin(DGD.A7-nAngleBase)) , dPosZ)
ptPosBox = Point3d( ptRef:getX()+(tRollerLatch.position*cos(DGD.A7)), ptRef:getY()+(tRollerLatch.position*sin(DGD.A7)) , dPosZ)
dPosXProbe = ptRef:getX() - DGD.DPR
dXFromExt = ptRef:getX()
dPosYProbe = ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase)) - DGD.DPR -- setto la X invece della Y
dYFromExt = dPosYProbe
end
else
if sSideLk == 'L' then -- se serratura a sinistra
ptPos = Point3d( dPosX + EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tRollerLatch.position) , dPosZ)
ptPosBox = Point3d( EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0), ( DGD.dH - tRollerLatch.position) , dPosZ)
dPosXProbe = ptPos:getX() + DGD.DPR
dXFromExt = EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)
else
ptPos = Point3d( ( DGD.dW - dPosX - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tRollerLatch.position) , dPosZ)
ptPosBox = Point3d( ( DGD.dW - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)), ( DGD.dH - tRollerLatch.position) , dPosZ)
dPosXProbe = ptPos:getX() - DGD.DPR
dXFromExt = DGD.dW - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)
end
dPosYProbe = DGD.dH - tRollerLatch.position
dYFromExt = dPosYProbe
end
ptPosUpGeom = Point3d( ptPos:getX(), ptPos:getY(), dPosZup)
ptPosDwGeom = Point3d( ptPosBox:getX(), ptPosBox:getY(), dPosZup)
nSideApplied = 3
else
if bRemake then
local dLocAngle
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PminTop
dLocAngle = DGD.A5
else
ptRef = DGD.PmaxTop
dLocAngle = DGD.A6
end
dPosY = ptRef:getY()+((tRollerLatch.position)*sin(dLocAngle))
else
dPosY = DGD.dH - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)
end
dPosYProbe = dPosY - DGD.DPR
dYFromExt = dPosY
end
if string.lower(tRollerLatch.side) ~= 'lock' then
if sSideLk == 'R' then -- se serratura a destra
if bRemake then
if string.lower(tRollerLatch.side) == 'top' then
dPosX = ptRef:getX()+(tRollerLatch.position*cos(DGD.A6))
else
dPosX = ptRef:getX()+(tRollerLatch.position*cos(DGD.A1))
end
else
dPosX = DGD.dW - tRollerLatch.position
end
dPosXProbe = dPosX
dXFromExt = dPosX
else -- serratura a sinistra
if bRemake then
if string.lower(tRollerLatch.side) == 'top' then
dPosX = ptRef:getX()+(tRollerLatch.position*cos(DGD.A5))
else
dPosX = ptRef:getX()+(tRollerLatch.position*cos(DGD.A2))
end
else
dPosX = tRollerLatch.position
end
dPosXProbe = dPosX
dXFromExt = dPosX
end
ptPos = Point3d( dPosX, dPosY, dPosZ)
ptPosUpGeom = Point3d( dPosX, dPosY, dPosZup)
ptPosDwGeom = ptPosUpGeom
end
MoveGeometryTopDwHSide( 'rollerlatch', tRollerLatch.geom, sSideLk, bPushDr, ptPos, ptPosUpGeom, nExtraAngle, ptPosDwGeom)
if bRemake then
if string.lower(tRollerLatch.side) == 'top' then
EgtRotate( tRollerLatch.geom, ptPos, Z_AX(), DGD.A5)
elseif string.lower(tRollerLatch.side) == 'bottom' then
EgtRotate( tRollerLatch.geom, ptPos, Z_AX(), DGD.A2)
else
EgtRotate( tRollerLatch.geom, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
end
InsertProbeGeom( tRollerLatch.geom, Point3d(dPosXProbe,dPosYProbe,0), Point3d(dXFromExt,dYFromExt,0), 9, nSideApplied)
end
-----------------------------------------------------------------
local function MovePivot( tPivot, sSideLk, bPushDr)
local ptPos
local ptPosProbe
local ptPosUpGeom
local ptPosDwGeom
local ptRef
local ptFromExt
local dPosX
local dPosXProbe
local dPosY
local dPosYProbe
local dPosZ = (DGD.dT/2)
local dPosZup
local dPosZReg
local dXFromExt
local dYFromExt
local dDeltaPos = 0
local sDeltaPos
local nDeltaX = 0
local nExtraAngle = 0
local nAngleBase
local nRadBase
local nErr = 0
local nHardwareType = 12
local nSideApplied = 1
-- se non è offsetintermediate ( quindi offset o centerhung)
if string.lower(tPivot.type) ~= 'offsetintermediate' then
if string.lower(tPivot.side) == 'hinge' then
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[594], tPivot.type..' Pivot', tPivot.side)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1021
end
if DGD.sFrame and DGD.nTypePz == 5 then
tPivot.side = 'bottom'
elseif DGD.sFrame and DGD.nTypePz == 6 then
tPivot.side = 'top'
end
if string.lower(tPivot.type) == 'offset' then
sDeltaPos = EgtGetInfo( tPivot.geom, 'DeltaPos')
if sDeltaPos then
dDeltaPos = tonumber( sDeltaPos)
end
end
-- se applicato a lato top o bottom cambio la coordinata in Y
if string.lower(tPivot.side) == 'top' then
if bRemake then
local dLocAngle
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PmaxTop
dLocAngle = DGD.A6
else
ptRef = DGD.PminTop
dLocAngle = DGD.A5
end
dPosY = ptRef:getY()+((tPivot.position+dDeltaPos)*sin(dLocAngle))
else
dPosY = DGD.dH - EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)
end
dPosYProbe = dPosY - DGD.DPR
dYFromExt = dPosY
nSideApplied = 2
else
if bRemake then
local dLocAngle
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PmaxBot
dLocAngle = DGD.A1
else
ptRef = DGD.PminBot
dLocAngle = DGD.A2
end
dPosY = ptRef:getY()+((tPivot.position+dDeltaPos)*sin(dLocAngle))
else
dPosY = EgtIf( DGD.sFrame, DGD.dZedExtFrame, 0)
end
dPosYProbe = dPosY + DGD.DPR
dYFromExt = dPosY
nSideApplied = 4
end
if DGD.OFFSET and DGD.OFFSET > 0 then
dPosZ = DGD.OFFSET
else
dPosZ = (DGD.dT/2)
end
if sSideLk == 'L' then -- se serratura a sinistra: RH, RHR, ...
if bRemake then
if string.lower(tPivot.side) == 'top' then
dPosX = ptRef:getX()+((tPivot.position+dDeltaPos)*cos(DGD.A6))
else
dPosX = ptRef:getX()+((tPivot.position+dDeltaPos)*cos(DGD.A1))
end
else
dPosX = DGD.dW - tPivot.position - dDeltaPos
end
else -- serratura a destra
if bRemake then
if string.lower(tPivot.side) == 'top' then
dPosX = ptRef:getX()+((tPivot.position+dDeltaPos)*cos(DGD.A5))
else
dPosX = ptRef:getX()+((tPivot.position+dDeltaPos)*cos(DGD.A2))
end
else
dPosX = tPivot.position + dDeltaPos
end
end
dPosXProbe = dPosX
dXFromExt = dPosX
if bPushDr then
dPosZup = DGD.BACK_SET
dPosZReg = 0
else
dPosZ = (DGD.dT - dPosZ)
dPosZup = DGD.dT - DGD.BACK_SET
dPosZReg = DGD.dT
end
else -- altrimenti tipo offsetintermediate
if DGD.sFrame then
sSideLk = EgtIf( sSideLk == 'L', 'R', 'L')
end
if string.lower(tPivot.side) ~= 'hinge' then
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[593], tPivot.type..' Pivot', 'hinge')
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = -1022
end
-- incremento il contatore di cerniere e pivot ( disposti su lato hinges)
nNumHingePivot = nNumHingePivot + 1
if DGD.tProfs.hingeedge.trimming == 'BD' or DGD.tProfs.hingeedge.trimming == 'BU' or
DGD.tProfs.hingeedge.trimming == 'BDEB' or DGD.tProfs.hingeedge.trimming == 'BUEB' then
nExtraAngle = 3
nDeltaX = (tPivot.back_set * sin(nExtraAngle))
end
-- by DGC.Bwd setting set to 0 the nDeltaX parameter
if DGC.Bwd and DGC.Bwd == 2 then
nDeltaX = 0
end
sDeltaPos = EgtGetInfo( tPivot.geom, 'DeltaPos')
if sDeltaPos then
dDeltaPos = tonumber( sDeltaPos)
end
if bRemake then
local dLocAngle
nAngleBase = atan(nDeltaX/(tPivot.position+dDeltaPos))
nRadBase = sqrt((nDeltaX*nDeltaX)+((tPivot.position+dDeltaPos)*(tPivot.position+dDeltaPos)))
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PmaxTop
dLocAngle = DGD.A7
else
ptRef = DGD.PminTop
dLocAngle = DGD.A4
end
dPosY = ptRef:getY()+((tPivot.position+dDeltaPos)*sin(dLocAngle))
dPosYProbe = dPosY
dYFromExt = dPosY
else
dPosY = DGD.dH - tPivot.position - dDeltaPos
dPosYProbe = dPosY
dYFromExt = dPosY
end
if sSideLk == 'L' then -- se serratura a sinistra: RH, RHR, ...
if DGD.sFrame then
dPosX = DGD.dW - nDeltaX - DGD.dZedExtFrame
dXFromExt = DGD.dW - DGD.dZedExtFrame
else
if bRemake then
dPosX = ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase))
dXFromExt = dPosX
else
dPosX = DGD.dW - nDeltaX
dXFromExt = DGD.dW
end
end
dPosXProbe = dPosX - DGD.DPR
else -- serratura a destra
if DGD.sFrame then
dPosX = nDeltaX + DGD.dZedExtFrame
dXFromExt = DGD.dZedExtFrame
else
if bRemake then
dPosX = ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase))
dXFromExt = dPosX
else
dPosX = nDeltaX
dXFromExt = 0
end
end
dPosXProbe = dPosX + DGD.DPR
end
if bPushDr then
dPosZup = DGD.BACK_SET
dPosZReg = 0
else
dPosZup = DGD.dT - DGD.BACK_SET
dPosZReg = DGD.dT
end
-- assegno il tipo hardware come una hinge perchè viene applicato su quel lato
nHardwareType = 5
end
ptPos = Point3d( dPosX, dPosY, dPosZ)
ptPosUpGeom = Point3d( dPosX, dPosY, dPosZup)
ptPosDwGeom = Point3d( dPosX, dPosY, dPosZReg)
ptPosProbe = Point3d( dPosXProbe, dPosYProbe, 0)
ptFromExt = Point3d( dXFromExt, dYFromExt, 0)
MoveGeometryTopDwHSide( 'pivot', tPivot.geom, sSideLk, bPushDr, ptPos, ptPosUpGeom, nExtraAngle, ptPosDwGeom)
if bRemake then
if string.lower(tPivot.type) == 'offsetintermediate' then
EgtRotate( tPivot.geom, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A8, DGD.A3)-90))
else
EgtRotate( tPivot.geom, ptPos, Z_AX(), EgtIf( string.lower(tPivot.side) == 'top', DGD.A5, DGD.A2))
end
end
InsertProbeGeom( tPivot.geom, ptPosProbe, ptFromExt, nHardwareType, nSideApplied)
-- assegno codice errore se ancora non fatto
if DGD.ERR == 0 then DGD.ERR = nErr end
end
-----------------------------------------------------------------
local function MoveStopAndCloser( tStopAndCloser, sSideLk, bPushDr)
local ptPos
local ptPosUp
local ptPosUpGeom
local ptPosDwGeom
local ptRef
local dPosY
local dPosZ
local dPosZup
local dPosProbe
local ptFromExt
if DGD.sFrame and ( DGD.nTypePz == 5 or DGD.nTypePz == 6) then
dPosY = 0 + DGD.dZedExtFrame
bPushDr = not bPushDr
else
if bRemake then
local dLocAngle
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PmaxTop
dLocAngle = DGD.A6
else
ptRef = DGD.PminTop
dLocAngle = DGD.A5
end
dPosY = ptRef:getY()+((tStopAndCloser.position)*sin(dLocAngle))
else
dPosY = DGD.dH
end
end
if DGD.POCKET_OFFSET and DGD.POCKET_OFFSET > 0 then
dPosZ = EgtIf( bPushDr, DGD.POCKET_OFFSET, (DGD.dT - DGD.POCKET_OFFSET))
else
dPosZ = DGD.dT/2
end
dPosZup = EgtIf( bPushDr, DGD.dT, 0)
if sSideLk == 'R' then -- se serratura a destra
if bRemake then
ptPos = Point3d( ptRef:getX()+(tStopAndCloser.position*cos(DGD.A5)), dPosY, dPosZ)
ptPosUp = Point3d( ptRef:getX()+(tStopAndCloser.position*cos(DGD.A5)), dPosY, dPosZup)
dPosProbe = Point3d( ptRef:getX()+(EgtIf( abs(tStopAndCloser.position) < DGD.DPR, (DGD.dW/4), tStopAndCloser.position)*cos(DGD.A5)), dPosY, dPosZup)
ptPosUpGeom = Point3d( ptRef:getX()+(tStopAndCloser.position*cos(DGD.A5)), dPosY, DGD.dT)
else
ptPos = Point3d( tStopAndCloser.position, dPosY, dPosZ)
ptPosUp = Point3d( tStopAndCloser.position, dPosY, dPosZup)
dPosProbe = Point3d( EgtIf( abs(tStopAndCloser.position) < DGD.DPR, (DGD.dW/4), tStopAndCloser.position), dPosY, dPosZup)
ptPosUpGeom = Point3d( tStopAndCloser.position, dPosY, DGD.dT)
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
ptFromExt = dPosProbe
else -- serratura a sinistra
if bRemake then
ptPos = Point3d( ptRef:getX()+(tStopAndCloser.position*cos(DGD.A6)), dPosY, dPosZ)
ptPosUp = Point3d( ptRef:getX()+(tStopAndCloser.position*cos(DGD.A6)), dPosY, dPosZup)
dPosProbe = Point3d( ptRef:getX()+(EgtIf( abs(tStopAndCloser.position) < DGD.DPR, (DGD.dW/4), tStopAndCloser.position)*cos(DGD.A6)), dPosY, dPosZup)
ptPosUpGeom = Point3d( ptRef:getX()+(tStopAndCloser.position*cos(DGD.A6)), dPosY, DGD.dT)
else
ptPos = Point3d( ( DGD.dW - tStopAndCloser.position), dPosY, dPosZ)
ptPosUp = Point3d( ( DGD.dW - tStopAndCloser.position), dPosY, dPosZup)
dPosProbe = Point3d( ( DGD.dW - EgtIf( abs(tStopAndCloser.position) < DGD.DPR, (DGD.dW/4), tStopAndCloser.position)), dPosY, dPosZup)
ptPosUpGeom = Point3d( ( DGD.dW - tStopAndCloser.position), dPosY, DGD.dT)
end
ptPosDwGeom = Point3d( ptPosUpGeom:getX(), ptPosUpGeom:getY() , 0)
ptFromExt = dPosProbe
end
MoveGeometryTopDwHSide( 'stopandcloser', tStopAndCloser.geom, sSideLk, bPushDr, ptPos, ptPosUp, nil, nil, ptPosUpGeom, ptPosDwGeom)
InsertProbeGeom( tStopAndCloser.geom, Point3d(dPosProbe:getX(),dPosProbe:getY()-DGD.DPR,0), Point3d(ptFromExt:getX(),ptFromExt:getY(),0), 4, 2)
end
-----------------------------------------------------------------------------------------
-- *** Geometric processing : functions for overhead ***
-----------------------------------------------------------------------------------------
local function MoveGeometryOverHead( sTypeGeom, nGeomId, sSideLk, bPushDr, ptPos, ptPosUp)
if not nGeomId then return end
local nIdGeomType
local sSideDoorToMove
local sMessageErr = ''
local nBoxGeom = 1
-- devo ottenere tutte le geometrie del over head
nIdGeomType = EgtGetFirstInGroup( nGeomId) -- ottengo la prima geometria
local nErr = 0
while nIdGeomType do
local sSideDoorBox = EgtGetInfo( nIdGeomType, 'SideDoor')
-- se geometrie che descrivono la sezione
if sSideDoorBox and sSideDoorBox == 'upper' then
MoveSubGeomStopAndCloser( nIdGeomType, sSideDoorBox, sSideLk, bPushDr, ptPos, ptPosUp, nBoxGeom)
else
sSideDoorToMove = EgtGetInfo( nIdGeomType, 'InserPoint')
if sSideDoorToMove then
-- Controllo se la nota è corretta
local sSideDoor = string.lower(sSideDoorToMove)
if sTypeGeom == 'overhead' then
-- Edge: sullo spigolo della porta; Centre: in centro allo spessore
if sSideDoor == 'edge' or sSideDoor == 'center' then
MoveSubGeomStopAndCloser( nIdGeomType, sSideDoor, sSideLk, bPushDr, ptPos, ptPosUp)
else
-- messaggio di errore
sMessageErr = string.format( EgtDoorsMsg[415], nIdGeomType,'OverHead',sSideDoor, DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1015
end
end
else
-- messaggio di errore in base al tipo di pezzo
if sTypeGeom == 'overhead' then
sMessageErr = string.format( EgtDoorsMsg[416], nIdGeomType,'OverHead', DGD.FILE)
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
nErr = 1016
end
end
end
nIdGeomType = EgtGetNext(nIdGeomType)
end
-- assegno codice errore se ancora non fatto
if DGD.ERR == 0 then DGD.ERR = nErr end
end
-----------------------------------------------------------------
local function MoveOverHead( tOverHead, sSideLk, bPushDr)
local ptPos
local ptPosUpGeom
local ptFromExt
local ptRef
local dPosY
local dPosYUp
local dPosZ
local dPosZup
if DGD.sFrame and ( DGD.nTypePz == 5 or DGD.nTypePz == 6) then
dPosY = 0 + DGD.dZedExtFrame
DGD.SIDE = 'bottom'
bPushDr = not bPushDr
else
if bRemake then
local dLocAngle
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PmaxTop
dLocAngle = DGD.A6
else
ptRef = DGD.PminTop
dLocAngle = DGD.A5
end
dPosY = ptRef:getY()+((tOverHead.pockpos)*sin(dLocAngle))
dPosYUp = ptRef:getY()+((tOverHead.armpos)*sin(dLocAngle))
else
dPosY = DGD.dH
end
end
if DGD.POCKET_OFFSET and DGD.POCKET_OFFSET > 0 then
dPosZ = EgtIf( bPushDr, DGD.POCKET_OFFSET, (DGD.dT - DGD.POCKET_OFFSET))
else
dPosZ = DGD.dT/2
end
dPosZup = EgtIf( bPushDr, DGD.dT, 0)
if sSideLk == 'R' then -- se serratura a destra
if bRemake then
ptPos = Point3d( ptRef:getX()+(tOverHead.pockpos*cos(DGD.A5)), dPosY, dPosZ)
ptPosUpGeom = Point3d( ptRef:getX()+(tOverHead.armpos*cos(DGD.A5)), dPosYUp, dPosZup)
else
ptPos = Point3d( tOverHead.pockpos, dPosY, dPosZ)
ptPosUpGeom = Point3d( tOverHead.armpos, dPosY, dPosZup)
end
else -- serratura a sinistra
if bRemake then
ptPos = Point3d( ptRef:getX()+(tOverHead.pockpos*cos(DGD.A6)), dPosY, dPosZ)
ptPosUpGeom = Point3d( ptRef:getX()+(tOverHead.armpos*cos(DGD.A6)), dPosYUp, dPosZup)
else
ptPos = Point3d( ( DGD.dW - tOverHead.pockpos), dPosY, dPosZ)
ptPosUpGeom = Point3d( ( DGD.dW - tOverHead.armpos), dPosY, dPosZup)
end
end
ptFromExt = ptPosUpGeom
MoveGeometryOverHead( 'overhead', tOverHead.geom, sSideLk, bPushDr, ptPos, ptPosUpGeom)
InsertProbeGeom( tOverHead.geom, Point3d(ptPosUpGeom:getX(),ptPosUpGeom:getY()-DGD.DPR,0), Point3d(ptFromExt:getX(),ptFromExt:getY(),0), 13, 2)
end
-----------------------------------------------------------------------------------------
-- *** Geometric processing : functions for GROOVE ***
-----------------------------------------------------------------------------------------
local function MoveGeomGroove( nGrooveId, sSideLk, ptPos, sSide, bPushDr, dTopAngleDoor)
if sSide and ( sSide == 'top' or sSide == 'top_flat' or sSide == 'top_angle') then
if DGD.GRS then
EgtRotate( nGrooveId, ORIG(), X_AX(), 90 ) -- ruoto su faccia frontale ( faccia sotto della porta)
EgtMirror( nGrooveId, ORIG(), Y_AX()) -- faccio mirror in Y
else
EgtRotate( nGrooveId, ORIG(), X_AX(), -90 ) -- ruoto su faccia dietro ( faccia sopra della porta)
end
else
EgtRotate( nGrooveId, ORIG(), X_AX(), 90 ) -- ruoto su faccia frontale ( faccia sotto della porta)
end
if not sSide or ( sSide == 'top' or sSide == 'top_flat' or sSide == 'top_angle') or sSide == 'bottom' then
if sSideLk == 'R' and not DGD.GRS then -- se serratura a destra
EgtRotate( nGrooveId, ORIG(), Y_AX(), 180 ) -- ruoto per portare l'eventuale uscita dalla parte delle cerniere
end
if not bPushDr and DGD.GRS then -- se è una bevel dn
EgtRotate( nGrooveId, ORIG(), Y_AX(), 180 ) -- ruoto per portare lo scasso in basso sul lato narrow
end
if sSide == 'top_angle' and dTopAngleDoor and abs(dTopAngleDoor) > 0 then
EgtRotate( nGrooveId, ORIG(), Z_AX(), dTopAngleDoor) -- ruoto sull'angolo inclinato lato top
end
else -- se piazzamento sui fianchi
if not bPushDr and DGD.GRS then -- se è una bevel dn
EgtRotate( nGrooveId, ORIG(), Y_AX(), 180 ) -- ruoto per portare lo scasso in basso sul lato narrow
end
if sSide == 'hinge' then
if sSideLk == 'R' then
EgtRotate( nGrooveId, ORIG(), Z_AX(), -90 )
else
EgtRotate( nGrooveId, ORIG(), Z_AX(), 90 )
end
else
if sSideLk == 'R' then
EgtRotate( nGrooveId, ORIG(), Z_AX(), 90 )
else
EgtRotate( nGrooveId, ORIG(), Z_AX(), -90 )
end
end
end
EgtMove( nGrooveId, ptPos - ORIG())
end
-----------------------------------------------------------------
local function MoveGroove( tGroove, sSideLk, bPushDr)
local ptPos
local ptRef
local dPosX = DGD.dW / 2
local dPosY = 0
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_flat' or tGroove.side == 'top_angle') then
-- se è ad angoolo ricalcolo la posizione
if DGD.Tpa then
-- se è applicato su lato dritto piatto
if tGroove.side == 'top_flat' then
-- se lunghezza lato dritto esiste
if DGD.tProfs.top.xdeltapos > 0 then
-- se parte angolata sulla parte sinistra
if DGD.tProfs.top.angle > 0 then
dPosX = DGD.dW - ( DGD.tProfs.top.xdeltapos / 2)
-- altrimenti parte angolata sulla parte destra
else
dPosX = ( DGD.tProfs.top.xdeltapos / 2)
end
else
dPosX = DGD.dW / 2
end
-- altrimenti se applicato sul lato inclinato
elseif tGroove.side == 'top_angle' then
-- se lunghezza lato inclinato esiste
if ( DGD.dW - DGD.tProfs.top.xdeltapos) > 0 then
-- se parte angolata sulla parte sinistra
if DGD.tProfs.top.angle > 0 then
dPosX = ( DGD.dW - DGD.tProfs.top.xdeltapos) / 2
-- altrimenti parte angolata sulla parte destra
else
dPosX = DGD.dW - ( ( DGD.dW - DGD.tProfs.top.xdeltapos) / 2)
end
else
dPosX = DGD.dW / 2
end
else
dPosX = DGD.dW / 2
end
else
dPosX = DGD.dW / 2
end
-- se è ad angoolo e deve essere applicato sul lato inclinato
if DGD.Tpa and tGroove.side == 'top_angle' then
-- se lunghezza lato inclinato esiste
if ( DGD.dW - DGD.tProfs.top.xdeltapos) > 0 then
dPosY = DGD.dH - ( ( ( DGD.dW - DGD.tProfs.top.xdeltapos) / 2) * tan( abs( DGD.tProfs.top.angle)))
else
dPosY = DGD.dH
end
-- inserisco nota nella porta con id geometria se il groove è effettivamente applicato sul lato inclinato
if dPosY < DGD.dH then
-- verifico se la nota esiste già
local sAngGrooveNote = EgtGetInfo( DGD.PZ, 'GrooveOnAngle', 's')
-- se non è presente aggiungo
if not sAngGrooveNote then
sAngGrooveNote = EgtNumToString( tGroove.geom, 0)
else
sAngGrooveNote = sAngGrooveNote .. ',' .. EgtNumToString( tGroove.geom, 0)
end
EgtSetInfo( DGD.PZ, 'GrooveOnAngle', sAngGrooveNote)
end
else
dPosY = DGD.dH
end
elseif tGroove.side and tGroove.side == 'hinge' then
dPosY = DGD.dH/2
if sSideLk == 'R' then -- se serratura a destra
dPosX = 0
else
dPosX = DGD.dW
end
elseif tGroove.side and tGroove.side == 'lock' then
dPosY = DGD.dH/2
if sSideLk == 'R' then -- se serratura a destra
dPosX = DGD.dW
else
dPosX = 0
end
else
dPosX = DGD.dW / 2
dPosY = 0
end
if bPushDr then -- se è una bevel up
if tGroove.groove_offset then
if DGD.GRS then
if bRemake then
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_angle' or tGroove.side == 'top_flat') then
ptRef = EgtMP(nDoorTopTop)
elseif tGroove.side and tGroove.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorLeftTop)
else
ptRef = EgtMP(nDoorRightTop)
end
elseif tGroove.side and tGroove.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorRightTop)
else
ptRef = EgtMP(nDoorLeftTop)
end
else
ptRef = EgtMP(nDoorBotTop)
end
ptPos = ptRef
else
ptPos = Point3d( dPosX, dPosY , DGD.dT)
end
else
if bRemake then
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_flat' or tGroove.side == 'top_angle') then
ptRef = EgtMP(nDoorTopMid)
elseif tGroove.side and tGroove.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorLeftMid)
else
ptRef = EgtMP(nDoorRightMid)
end
elseif tGroove.side and tGroove.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorRightMid)
else
ptRef = EgtMP(nDoorLeftMid)
end
else
ptRef = EgtMP(nDoorBotMid)
end
ptPos = Point3d( EgtMP:getX(ptRef), EgtMP:getY(ptRef) , tGroove.groove_offset)
else
ptPos = Point3d( dPosX, dPosY , tGroove.groove_offset)
end
end
else
if DGD.GRS then
if bRemake then
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_flat' or tGroove.side == 'top_angle') then
ptRef = EgtMP(nDoorTopTop)
elseif tGroove.side and tGroove.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorLeftTop)
else
ptRef = EgtMP(nDoorRightTop)
end
elseif tGroove.side and tGroove.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorRightTop)
else
ptRef = EgtMP(nDoorLeftTop)
end
else
ptRef = EgtMP(nDoorBotTop)
end
ptPos = ptRef
else
ptPos = Point3d( dPosX, dPosY, DGD.dT)
end
else
if bRemake then
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_flat' or tGroove.side == 'top_angle') then
ptRef = EgtMP(nDoorTopMid)
elseif tGroove.side and tGroove.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorLeftMid)
else
ptRef = EgtMP(nDoorRightMid)
end
elseif tGroove.side and tGroove.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorRightMid)
else
ptRef = EgtMP(nDoorLeftMid)
end
else
ptRef = EgtMP(nDoorBotMid)
end
ptPos = ptRef
else
ptPos = Point3d( dPosX, dPosY , (DGD.dT/2))
end
end
end
else -- se è bevel dw
if tGroove.groove_offset then
if DGD.GRS then
if bRemake then
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_flat' or tGroove.side == 'top_angle') then
ptRef = EgtMP(nDoorTop)
elseif tGroove.side and tGroove.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorLeft)
else
ptRef = EgtMP(nDoorRight)
end
elseif tGroove.side and tGroove.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorRight)
else
ptRef = EgtMP(nDoorLeft)
end
else
ptRef = EgtMP(nDoorBot)
end
ptPos = ptRef
else
ptPos = Point3d( dPosX, dPosY , 0)
end
else
if bRemake then
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_flat' or tGroove.side == 'top_angle') then
ptRef = EgtMP(nDoorTopMid)
elseif tGroove.side and tGroove.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorLeftMid)
else
ptRef = EgtMP(nDoorRightMid)
end
elseif tGroove.side and tGroove.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorRightMid)
else
ptRef = EgtMP(nDoorLeftMid)
end
else
ptRef = EgtMP(nDoorBotMid)
end
ptPos = Point3d( EgtMP:getX(ptRef), EgtMP:getY(ptRef) , tGroove.groove_offset)
else
ptPos = Point3d( dPosX, dPosY , ( DGD.dT - tGroove.groove_offset))
end
end
else
if DGD.GRS then
if bRemake then
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_flat' or tGroove.side == 'top_angle') then
ptRef = EgtMP(nDoorTop)
elseif tGroove.side and tGroove.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorLeft)
else
ptRef = EgtMP(nDoorRight)
end
elseif tGroove.side and tGroove.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorRight)
else
ptRef = EgtMP(nDoorLeft)
end
else
ptRef = EgtMP(nDoorBot)
end
ptPos = ptRef
else
ptPos = Point3d( dPosX, dPosY , 0)
end
else
if bRemake then
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_flat' or tGroove.side == 'top_angle') then
ptRef = EgtMP(nDoorTopMid)
elseif tGroove.side and tGroove.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorLeftMid)
else
ptRef = EgtMP(nDoorRightMid)
end
elseif tGroove.side and tGroove.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
ptRef = EgtMP(nDoorRightMid)
else
ptRef = EgtMP(nDoorLeftMid)
end
else
ptRef = EgtMP(nDoorBotMid)
end
ptPos = ptRef
else
ptPos = Point3d( dPosX, dPosY , (DGD.dT/2))
end
end
end
end
MoveGeomGroove( tGroove.geom, sSideLk, ptPos, tGroove.side, bPushDr, DGD.tProfs.top.angle)
if bRemake then
if tGroove.side and ( tGroove.side == 'top' or tGroove.side == 'top_flat' or tGroove.side == 'top_angle') then
EgtRotate( tGroove.geom, ptPos, Z_AX(), DGD.A5)
elseif tGroove.side and tGroove.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
EgtRotate( tGroove.geom, ptPos, Z_AX(), (DGD.A3-90))
else
EgtRotate( tGroove.geom, ptPos, Z_AX(), (DGD.A8-90))
end
elseif tGroove.side and tGroove.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
EgtRotate( tGroove.geom, ptPos, Z_AX(), (DGD.A8-90))
else
EgtRotate( tGroove.geom, ptPos, Z_AX(), (DGD.A3-90))
end
else
EgtRotate( tGroove.geom, ptPos, Z_AX(), DGD.A2)
end
end
-- creo estrusi e superfici piane delle geometrie passanti
local nGId = EgtGetFirstNameInGroup( tGroove.geom, 'BOXGROOVE')
if nGId then
AddSurfTmByExtrusion( tGroove.geom, nGId, true, nil, true)
-- sposto gli estrusi e le superfici piane nel layer solid
AddFlatSurf( tGroove.geom, tGroove.geom)
EgtErase(nGId)
end
end
-----------------------------------------------------------------------------------------
-- *** Geometric processing : functions for RABBET ***
-----------------------------------------------------------------------------------------
local function MoveGeomRabbet( nRabbetId, sSideLk, bPushDr, ptPos)
local nRotX
local nRotY
local nRotZ
if DGD.sFrame then
-- se frame lock or frame hinge on left
if (( DGD.sFrame == 'L' or DGD.sFrame == 'LE') and sSideLk == 'L') or
(( DGD.sFrame == 'H' or DGD.sFrame == 'HE') and sSideLk == 'R') then
EgtRotate( nRabbetId, ORIG(), Y_AX(), 90 )
if DGD.SIDE == 'top' then
nRotX = 0
elseif DGD.SIDE == 'bottom' then
nRotX = 180
else
if bPushDr then
nRotX = -90
else
nRotX = 90
end
end
if nRotX ~= 0 then
EgtRotate( nRabbetId, ORIG(), X_AX(), nRotX)
end
-- se frame lock or frame hinge on right
elseif (( DGD.sFrame == 'L' or DGD.sFrame == 'LE') and sSideLk == 'R') or
(( DGD.sFrame == 'H' or DGD.sFrame == 'HE') and sSideLk == 'L') then
EgtRotate( nRabbetId, ORIG(), Y_AX(), -90 )
if DGD.SIDE == 'top' then
nRotX = 0
elseif DGD.SIDE == 'bottom' then
nRotX = 180
else
if bPushDr then
nRotX = -90
else
nRotX = 90
end
end
if nRotX ~= 0 then
EgtRotate( nRabbetId, ORIG(), X_AX(), nRotX)
end
-- se frame top
elseif DGD.nTypePz == 5 then
EgtRotate( nRabbetId, ORIG(), X_AX(), 90 )
if DGD.SIDE == 'top' then
nRotY = 90
elseif DGD.SIDE == 'bottom' then
nRotY = -90
else
if bPushDr then
nRotY = 180
else
nRotY = 0
end
end
if nRotY ~= 0 then
EgtRotate( nRabbetId, ORIG(), Y_AX(), nRotY)
end
-- frame bottom
else
EgtRotate( nRabbetId, ORIG(), X_AX(), -90 )
if DGD.SIDE == 'top' then
nRotY = -90
elseif DGD.SIDE == 'bottom' then
nRotY = 90
else
if bPushDr then
nRotY = 0
else
nRotY = 180
end
end
if nRotY ~= 0 then
EgtRotate( nRabbetId, ORIG(), Y_AX(), nRotY)
end
end
else
-- se porta a tirare il rabbet va sotto
if not bPushDr then
EgtRotate( nRabbetId, ORIG(), Y_AX(), 180 )
end
if DGD.SIDE == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
nRotZ = 90
else
nRotZ = -90
end
elseif DGD.SIDE == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
nRotZ = -90
else
nRotZ = 90
end
elseif DGD.SIDE == 'bottom' then
nRotZ = 180
elseif DGD.SIDE == 'top' then
nRotZ = 0
end
if nRotZ ~= 0 then
EgtRotate( nRabbetId, ORIG(), Z_AX(), nRotZ )
end
end
EgtMove( nRabbetId, ptPos - ORIG())
end
-----------------------------------------------------------------
local function CalcCommonFramePos( sSideLk, bPushDr)
local dPosX, dPosY, dPosZ
if DGD.sFrame == 'L' or DGD.sFrame == 'LE' then -- se frame lock
if sSideLk == 'L' then -- se lock a sx
dPosX = DGD.dW
else
dPosX = 0
end
dPosY = DGD.dH/2
elseif DGD.sFrame == 'H' or DGD.sFrame == 'HE' then -- se frame hinge
if sSideLk == 'L' then -- se lock a sx
dPosX = 0
else
dPosX = DGD.dW
end
dPosY = DGD.dH/2
else -- se frame top o bottom
dPosX = DGD.dW / 2
if DGD.nTypePz == 5 then -- se frame top
dPosY = 0
else
dPosY = DGD.dH
end
end
if bPushDr then
dPosZ = 0
else
dPosZ = DGD.dT
end
return dPosX, dPosY, dPosZ
end
-----------------------------------------------------------------
local function MoveRabbet( tRabbet, sSideLk, bPushDr)
local ptPos
local ptRef
local dPosX
local dPosY
local dPosZ
-- per i frame la posizione della rabbet sia su lato hinge che lock portano sempre allo spesso lato
if tRabbet.side == 'hinge' then
if DGD.sFrame then
dPosX,dPosY,dPosZ = CalcCommonFramePos( sSideLk, bPushDr)
else
if sSideLk == 'R' then -- se serratura a destra
dPosX = 0
else
dPosX = DGD.dW
end
dPosY = DGD.dH/2
end
elseif tRabbet.side == 'lock' then
if DGD.sFrame then
dPosX,dPosY,dPosZ = CalcCommonFramePos( sSideLk, bPushDr)
else
if sSideLk == 'R' then -- se serratura a destra
dPosX = DGD.dW
else
dPosX = 0
end
dPosY = DGD.dH/2
end
elseif tRabbet.side == 'top' then
if DGD.sFrame then
if DGD.sFrame == 'L' or DGD.sFrame == 'LE' then -- se frame lock
if sSideLk == 'L' then -- se lock a sx
dPosX = DGD.dW
else
dPosX = 0
end
dPosY = DGD.dH
elseif DGD.sFrame == 'H' or DGD.sFrame == 'HE' then -- se frame hinge
if sSideLk == 'L' then -- se lock a sx
dPosX = 0
else
dPosX = DGD.dW
end
dPosY = DGD.dH
elseif DGD.nTypePz == 5 then -- se frame top
dPosX = DGD.dW
dPosY = 0
else -- frame bottom
dPosX = DGD.dW
dPosY = DGD.dH
end
dPosZ = DGD.dT / 2
else
dPosX = DGD.dW/2
dPosY = DGD.dH
end
elseif tRabbet.side == 'bottom' then
if DGD.sFrame then
if DGD.sFrame == 'L' or DGD.sFrame == 'LE' then -- se frame lock
if sSideLk == 'L' then -- se lock a sx
dPosX = DGD.dW
else
dPosX = 0
end
dPosY = 0
elseif DGD.sFrame == 'H' or DGD.sFrame == 'HE' then -- se frame hinge
if sSideLk == 'L' then -- se lock a sx
dPosX = 0
else
dPosX = DGD.dW
end
dPosY = 0
elseif DGD.nTypePz == 5 then -- se frame top
dPosX = 0
dPosY = 0
else
dPosX = 0
dPosY = DGD.dH
end
dPosZ = DGD.dT / 2
else
dPosX = DGD.dW/2
dPosY = 0
end
end
if not DGD.sFrame then
if bPushDr then
if tRabbet.oppo and tRabbet.oppo == 1 then
dPosZ = 0
else
dPosZ = DGD.dT
end
else
if tRabbet.oppo and tRabbet.oppo == 1 then
dPosZ = DGD.dT
else
dPosZ = 0
end
end
end
if bRemake then
if bPushDr then -- se è una bevel up
if tRabbet.side and tRabbet.side == 'top' then
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorTop)
else
ptRef = EgtMP(nDoorTopTop)
end
elseif tRabbet.side and tRabbet.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorLeft)
else
ptRef = EgtMP(nDoorLeftTop)
end
else
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorRight)
else
ptRef = EgtMP(nDoorRightTop)
end
end
elseif tRabbet.side and tRabbet.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorRight)
else
ptRef = EgtMP(nDoorRightTop)
end
else
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorLeft)
else
ptRef = EgtMP(nDoorLeftTop)
end
end
else
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorBot)
else
ptRef = EgtMP(nDoorBotTop)
end
end
else -- se è bevel dw
if tRabbet.side and tRabbet.side == 'top' then
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorTopTop)
else
ptRef = EgtMP(nDoorTop)
end
elseif tRabbet.side and tRabbet.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorLeftTop)
else
ptRef = EgtMP(nDoorLeft)
end
else
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorRightTop)
else
ptRef = EgtMP(nDoorRight)
end
end
elseif tRabbet.side and tRabbet.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorRightTop)
else
ptRef = EgtMP(nDoorRight)
end
else
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorLeftTop)
else
ptRef = EgtMP(nDoorLeft)
end
end
else
if tRabbet.oppo and tRabbet.oppo == 1 then
ptRef = EgtMP(nDoorBotTop)
else
ptRef = EgtMP(nDoorBot)
end
end
end
ptPos = ptRef
else
ptPos = Point3d( dPosX, dPosY , dPosZ)
end
MoveGeomRabbet( tRabbet.geom, sSideLk, bPushDr, ptPos)
if bRemake then
if tRabbet.side and tRabbet.side == 'top' then
EgtRotate( tRabbet.geom, ptPos, Z_AX(), DGD.A5)
elseif tRabbet.side and tRabbet.side == 'hinge' then
if sSideLk == 'R' then -- se serratura a destra
EgtRotate( tRabbet.geom, ptPos, Z_AX(), (DGD.A3-90))
else
EgtRotate( tRabbet.geom, ptPos, Z_AX(), (DGD.A8-90))
end
elseif tRabbet.side and tRabbet.side == 'lock' then
if sSideLk == 'R' then -- se serratura a destra
EgtRotate( tRabbet.geom, ptPos, Z_AX(), (DGD.A8-90))
else
EgtRotate( tRabbet.geom, ptPos, Z_AX(), (DGD.A3-90))
end
else
EgtRotate( tRabbet.geom, ptPos, Z_AX(), DGD.A2)
end
end
end
-----------------------------------------------------------------
local function MoveEPT( tEPT, sSideLk, bPushDr)
local ptPos
local ptProbe
local ptFromExt
local ptRef
local dPosX
local dPosXProbe
local dXFromExt
local dPosY
local dPosZ = 0
local dDeltaPos = 0
local sDeltaPos
local nDeltaX = 0
local nExtraAngle = 0
local nAngleBase
local nRadBase
if DGD.sFrame then
sSideLk = EgtIf( sSideLk == 'L', 'R', 'L')
end
if DGD.tProfs.hingeedge.trimming == 'BD' or DGD.tProfs.hingeedge.trimming == 'BU' or
DGD.tProfs.hingeedge.trimming == 'BDEB' or DGD.tProfs.hingeedge.trimming == 'BUEB' then
nExtraAngle = 3
nDeltaX = tEPT.back_set * TAN3
end
-- by DGC.Bwd setting set to 0 the nDeltaX parameter
if DGC.Bwd and DGC.Bwd == 2 then
nDeltaX = 0
end
sDeltaPos = EgtGetInfo( tEPT.geom, 'DeltaPos')
if sDeltaPos then
dDeltaPos = tonumber( sDeltaPos)
end
if bRemake then
nAngleBase = atan(nDeltaX/(tEPT.position+dDeltaPos))
nRadBase = sqrt((nDeltaX*nDeltaX)+((tEPT.position+dDeltaPos)*(tEPT.position+dDeltaPos)))
if sSideLk == 'L' then -- se serratura a sinistra
ptRef = DGD.PmaxTop
dPosY = ptRef:getY()+((tEPT.position+dDeltaPos)*sin(DGD.A7))
else
ptRef = DGD.PminTop
dPosY = ptRef:getY()+((tEPT.position+dDeltaPos)*sin(DGD.A4))
end
else
dPosY = DGD.dH - tEPT.position - dDeltaPos
end
if sSideLk == 'L' then -- se serratura a sinistra: RH, RHR, ...
if DGD.sFrame then
dPosX = DGD.dW - nDeltaX - DGD.dZedExtFrame
dXFromExt = DGD.dW - DGD.dZedExtFrame
else
if bRemake then
dPosX = ptRef:getX()+(nRadBase*cos(DGD.A7-nAngleBase))
dXFromExt = dPosX
else
dPosX = DGD.dW - nDeltaX
dXFromExt = DGD.dW
end
end
dPosXProbe = dPosX - DGD.DPR
else -- serratura a destra
if DGD.sFrame then
dPosX = nDeltaX + DGD.dZedExtFrame
dXFromExt = DGD.dZedExtFrame
else
if bRemake then
dPosX = ptRef:getX()+(nRadBase*cos(DGD.A4+nAngleBase))
dXFromExt = dPosX
else
dPosX = nDeltaX
dXFromExt = 0
end
end
dPosXProbe = dPosX + DGD.DPR
end
if bPushDr then
dPosZ = tEPT.back_set
else
dPosZ = DGD.dT - tEPT.back_set
end
ptPos = Point3d( dPosX, dPosY, dPosZ)
ptProbe = Point3d( dPosXProbe, dPosY, 0)
ptFromExt = Point3d( dXFromExt, dPosY, 0)
MoveGeometryHng( 'ept', tEPT.geom, sSideLk, bPushDr, ptPos, nExtraAngle)
if bRemake then
EgtRotate( tEPT.geom, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A8, DGD.A3)-90))
end
InsertProbeGeom( tEPT.geom, ptProbe, ptFromExt, 17, 1)
end
-----------------------------------------------------------------------------------------
-- *** Geometric processing : functions for FACE DECORATION ***
-----------------------------------------------------------------------------------------
local function MoveGeomDecoration( nGeomId, sFace, sSideLk)
local ptPos
local ptRef
local dZedPos = 0
local bMirror = ( EgtGetInfo( nGeomId, 'Mirror', 'i') ~= 0)
local dRotToHinges = EgtGetInfo( nGeomId, 'Rotate', 'd') or 0
local b3Box = EgtGetBBox( nGeomId, GDB_BB.STANDARD)
-- sistemo per eventuale rotazione
if not bMirror and abs( dRotToHinges) > GEO.EPS_ANG_SMALL then
-- eseguo rotazione
local dAngRot = EgtIf( sSideLk == 'L', -dRotToHinges, dRotToHinges)
if string.lower( sFace) == 'secure' then dAngRot = -dAngRot end
local nNewEnt = EgtGetFirstInGroup( nGeomId)
while nNewEnt do
EgtRotate( nNewEnt, b3Box:getCenter(), Z_AX(), dAngRot)
nNewEnt = EgtGetNext( nNewEnt)
end
local b3NewBox = EgtGetBBox( nGeomId, GDB_BB.STANDARD)
-- riporto in posizione
local vtMove = b3Box:getMin() - b3NewBox:getMin()
nNewEnt = EgtGetFirstInGroup( nGeomId)
while nNewEnt do
EgtMove( nNewEnt, vtMove)
nNewEnt = EgtGetNext( nNewEnt)
end
-- aggiorno box
b3Box = EgtGetBBox( nGeomId, GDB_BB.STANDARD)
end
if string.lower( sFace) == 'keyway' then -- se specificato face su lato keyway (davanti)
dZedPos = DGD.dT
elseif string.lower( sFace) == 'secure' then -- se specificato face su lato secure (dietro)
-- faccio il mirror di tutte le geometrie rispetto al piano XY
local nNewEnt = EgtGetFirstInGroup( nGeomId)
while nNewEnt do
EgtMirror( nNewEnt, ORIG(), Z_AX())
nNewEnt = EgtGetNext( nNewEnt)
end
-- se non richiesto mirror, per annullarne l'effetto
if not bMirror then
local nNewEnt = EgtGetFirstInGroup( nGeomId)
while nNewEnt do
EgtMirror( nNewEnt, Point3d( b3Box:getCenter():getX(), 0, 0), X_AX())
nNewEnt = EgtGetNext( nNewEnt)
end
end
end
if sSideLk == 'L' then -- se serratura a sinistra
if bRemake then
ptRef = DGD.PminBot
ptPos = Point3d( ptRef:getX(), ptRef:getY(), dZedPos)
else
ptPos = Point3d( 0, 0, dZedPos)
end
else -- serratura a destra
if bRemake then
ptRef = DGD.PmaxBot
ptPos = Point3d( ptRef:getX(), ptRef:getY(), dZedPos)
else
ptPos = Point3d( DGD.dW, 0, dZedPos)
end
-- se ammesso, faccio il mirror di tutte le geometrie sul piano YZ
if bMirror then
local nNewEnt = EgtGetFirstInGroup( nGeomId)
while nNewEnt do
EgtMirror( nNewEnt, ORIG(), X_AX())
nNewEnt = EgtGetNext( nNewEnt)
end
else
local vtMove = Vector3d( - 2 * b3Box:getCenter():getX(), 0, 0)
local nNewEnt = EgtGetFirstInGroup( nGeomId)
while nNewEnt do
EgtMove( nNewEnt, vtMove)
nNewEnt = EgtGetNext( nNewEnt)
end
end
end
EgtMove( nGeomId, ptPos - ORIG())
if bRemake then
EgtRotate( nGeomId, ptPos, Z_AX(), ( EgtIf( sSideLk == 'L', DGD.A3, DGD.A8)-90))
end
end
-----------------------------------------------------------------
local function MoveCopyDecoration( tDecoration, sSideLk, bPushDr, bImport)
if not tDecoration then return end
if not tDecoration.geom then return end
local tCopyDec
if bImport then -- se importato
-- determino posizione della decorazione
local b3Box = EgtGetBBoxGlob( tDecoration.geom, GDB_BB.STANDARD)
local dX = 0
local dY = DGD.dH
if DGD.DFL then
dX = 0 + DGD.DFL
elseif DGD.DFH then
dX = DGD.dW - DGD.WIDTH - DGD.DFH
end
if DGD.DFT then
dY = DGD.dH - DGD.DFT
elseif DGD.DFB then
dY = 0 + DGD.LENGTH + DGD.DFB
end
local ptRef = Point3d( b3Box:getMin():getX(), b3Box:getMax():getY(), 0)
local ptPos = Point3d( dX, dY, 0)
-- muovo entità
local nNewEnt = EgtGetFirstInGroup( tDecoration.geom)
while nNewEnt do
EgtMove( nNewEnt, ptPos - ptRef)
-- sistemo lo spessore (negativo)
if tDecoration.depth then -- se ho spessore da ddf
EgtModifyCurveThickness( nNewEnt, -tDecoration.depth)
else -- non ho spessore
local dTh = EgtCurveThickness( nNewEnt) -- leggo spessore locale
if abs( dTh) > DGD.dT then -- se maggiore di spessore porta lo annullo
dTh = 0
end
EgtModifyCurveThickness( nNewEnt, -abs(dTh))
end
nNewEnt = EgtGetNext( nNewEnt)
end
-- eseguo trim con rettangolo porta aumentato di un poco (o con valori da disegno)
local dOffs, dOffL, dOffT, dOffH, dOffB = 20, 20, 20, 20, 20
local vOffs = EgtGetInfo( tDecoration.geom, 'TrimLTHB', 'vd')
if vOffs and #vOffs >= 4 then
dOffL = vOffs[1]
dOffT = vOffs[2]
dOffH = vOffs[3]
dOffB = vOffs[4]
end
local frRef = Frame3d( -dOffL, -dOffB, -dOffs)
local vtDiag = Vector3d( DGD.dW + dOffL + dOffH, DGD.dH + dOffB + dOffT, 2 * dOffs)
nNewEnt = EgtGetFirstInGroup( tDecoration.geom)
while nNewEnt do
local nNextEnt = EgtGetNext( nNewEnt)
local nCrvId, nCnt = EgtTrimFlatCurveWithBox( nNewEnt, frRef, vtDiag, true, true, GDB_RT.GLOB)
if nCnt > 1 then
for i = 2, nCnt do
local ptStart = EgtSP( nCrvId + i - 1, nCrvId)
EgtAddCurveCompoLine( nCrvId, ptStart, true, GDB_RT.LOC)
EgtAddCurveCompoCurve( nCrvId, nCrvId + i - 1, true, true)
end
end
EgtCloseCurveCompo( nCrvId)
nNewEnt = nNextEnt
end
end
if string.lower(DGD.FACE) == 'both' then -- se specificato su entrambe i lati faccio la copia
tCopyDec = EgtCopyGlob( tDecoration.geom, DGD.PZ)
MoveGeomDecoration( tDecoration.geom, 'secure', sSideLk)
if tCopyDec then
MoveGeomDecoration( tCopyDec, 'keyway', sSideLk)
end
else
MoveGeomDecoration( tDecoration.geom, DGD.FACE, sSideLk)
end
end
-----------------------------------------------------------------
-- *** General Geometric Processing ***
-----------------------------------------------------------------
local function InsertSize( nTypeGeom, sSideLock, ptMedArc, dPosXHead, dAggrXPos,
dAggrYPos, dAggrBackSet, dAggrOffset, bRefXFromDoor, bRefYFromDoor,
nNumGeom)
-- se si disegnano anche le geometrie di lavorazione esco
if DGD.MachEn > 0 then
return
end
local dXPos
local dXPosRef
local dYPos
local dYPosRef
local dDeltaXPos
local dExtraXPos
local dExtraYPos
local dDeltaXValue
local bRigth
local bTop
local bCenter
local dBack
local dPosition
local nUp
local nRigth
-- tipo door
if nTypeGeom == 0 then
local DoorLayerDim
if DGD.tProfs.top.radius then
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(DGD.dW,0,0), Point3d(DGD.dW,DGD.dH,0), DGD.dH, false, 0, 1, BLACK())
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(0,0,0), Point3d(DGD.dW,0,0), DGD.dW, true, 0, 0, BLACK())
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Dra), ptMedArc, DGD.tProfs.top.radius, false, 0, 0, BLACK(), true)
elseif DGD.tProfs.top.angle then
if DGD.tProfs.top.angle > 0 then
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(DGD.dW,0,0), Point3d(DGD.dW,DGD.dH,0), DGD.dH, false, 0, 1, BLACK())
if DGD.tProfs.top.xdeltapos > 0 then
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d((DGD.dW-DGD.tProfs.top.xdeltapos),DGD.dH,0), Point3d(DGD.dW,DGD.dH,0), DGD.tProfs.top.xdeltapos, true, 1, 0, BLACK())
end
-- quoto angolo
-- DGD.DIM_DOOR = true -- per abilitare le quote nell'EgtCam5
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d((DGD.dW-DGD.tProfs.top.xdeltapos),DGD.dH,0), 180, DGD.tProfs.top.angle, true, 0, 1, BLACK(), false, '°', true)
-- DGD.DIM_DOOR = nil -- per abilitare le quote nell'EgtCam5
else
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(0,0,0), Point3d(0,DGD.dH,0), DGD.dH, false, 0, 0, BLACK())
if DGD.tProfs.top.xdeltapos > 0 then
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(0,DGD.dH,0), Point3d(DGD.tProfs.top.xdeltapos,DGD.dH,0), DGD.tProfs.top.xdeltapos, true, 1, 0, BLACK())
end
-- quoto angolo
-- DGD.DIM_DOOR = true -- per abilitare le quote nell'EgtCam5
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(DGD.tProfs.top.xdeltapos,DGD.dH,0), 0, DGD.tProfs.top.angle, true, 0, 1, BLACK(), false, '°', true)
-- DGD.DIM_DOOR = nil -- per abilitare le quote nell'EgtCam5
end
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(0,0,0), Point3d(DGD.dW,0,0), DGD.dW, true, 0, 0, BLACK())
else
-- DGD.DIM_DOOR = true -- per abilitare le quote nell'EgtCam5
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(DGD.dW,0,0), Point3d(DGD.dW,DGD.dH,0), DGD.dH, false, 0, 1, BLACK())
DoorLayerDim = AssignSize( DGD.PZ, DoorLayerDim, nTypePiece, 0, Point3d(0,0,0), Point3d(DGD.dW,0,0), DGD.dW, true, 0, 0, BLACK())
-- DGD.DIM_DOOR = nil -- per abilitare le quote nell'EgtCam5
--debug
-- if nTypePiece == 5 then
-- EgtSaveFile( sNgeFile)
-- EgtMove(DGD.PZ, Point3d(0,0,nil) - ORIG())
-- end
end
-- tipo vision
elseif nTypeGeom == 1 then
dXPos = 0
dYPos = EgtIf( DGD.TOP_RAIL, DGD.TOP_RAIL, DGD.CENTER_FROM_TOP) or 0
dDeltaXPos = EgtIf( DGD.LOCK_STYLE, DGD.LOCK_STYLE, DGD.CENTER_FROM_LOCK) or 0
nRigth = 0
dBack = 1
bCenter = DGD.POINTAPP == 'center'
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dBack = -1
end
dXPosRef = dXPos
if bCenter then
dXPos = DGD.dW / 2
end
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPosRef,DGD.dH,0), Point3d((dXPos+(dDeltaXPos*dBack)),(DGD.dH-dYPos),0), dYPos, false, 0, nRigth, GREEN())
-- quota lock stile
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH,0), Point3d((dXPos+(dDeltaXPos*dBack)),(DGD.dH-dYPos),0), dDeltaXPos, true, 1, nRigth, GREEN())
elseif nTypeGeom == 2 then -- tipo louver
dXPos = 0
dYPos = DGD.BOTTOM_RAIL
dDeltaXPos = DGD.LOCK_STYLE
nRigth = 0
dBack = 1
bCenter = DGD.POINTAPP == 'center'
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dBack = -1
end
dXPosRef = dXPos
if bCenter then
dXPos = DGD.dW / 2
end
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPosRef,0,0), Point3d((dXPos+(dDeltaXPos*dBack)),dYPos,0), dYPos, false, 0, nRigth, GREEN())
-- quota lock stile
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,0,0), Point3d((dXPos+(dDeltaXPos*dBack)),dYPos,0), dDeltaXPos, true, 0, nRigth, GREEN())
elseif nTypeGeom == 3 then -- tipo lock
-- DGD.DIM_LOCK = true -- per abilitare le quote nell'EgtCam5
if not DGD.SIDE or DGD.SIDE == 'lock_top' or DGD.SIDE == 'lock_bottom' then
dXPos = 0
nUp = 1
nRigth = 0
dYPos = DGD.dH
dExtraYPos = dAggrYPos or 0
dBack = 1
dPosition = DGD.POSITION
dAggrXPos = dAggrXPos or 0
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dBack = -1
end
if DGD.SIDE == 'lock_bottom' then
nUp = 0
dYPos = 0
if bRefYFromDoor then
dPosition = 0
else
dPosition = -DGD.POSITION
end
elseif DGD.SIDE == 'lock_top' and bRefYFromDoor then
dExtraYPos = -dAggrYPos or 0
dPosition = 0
end
if not nNumGeom or nNumGeom == 1 then
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d(dXPos,dYPos-dPosition,0), DGD.POSITION, false, nUp, nRigth, RED())
end
-- quota backset
local dLocBackSet = DGD.BACK_SET
if dAggrBackSet then
dLocBackSet = dAggrBackSet
end
-- se offset Y presente
if abs(dExtraYPos) > 0 then
local dOffsPoint = 0
if abs(dAggrXPos) > 0 then
-- se riferimengo globale in X quoto
if bRefXFromDoor then
dOffsPoint = dAggrXPos * EgtIf( sSideLock ~= 'L', 1, -1)
else
dOffsPoint = (dAggrXPos + dLocBackSet) * EgtIf( sSideLock ~= 'L', 1, -1)
end
end
-- se riferito a lato top-bottom
if bRefYFromDoor then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d(dXPos-dOffsPoint,dYPos+dExtraYPos,0), abs(dExtraYPos), false, nUp, nRigth, Color3d(64,128,128))
else
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos-dPosition,0), Point3d(dXPos-dOffsPoint,dYPos-dPosition+dExtraYPos,0), abs(dExtraYPos), false, nUp, nRigth, Color3d(64,128,128))
end
end
-- se riferimengo globale in X quoto
if bRefXFromDoor then
-- se offset esistente
if abs(dAggrXPos) > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos-dPosition+dExtraYPos,0), Point3d((dXPos+(dAggrXPos*dBack)), dYPos-dPosition+dExtraYPos,0), abs(dAggrXPos), true, -1, nRigth, Color3d(64,128,128), nil, EgtIf( not DGC.Bwd or DGC.Bwd == 0, '*', nil))
end
else
if dLocBackSet and dLocBackSet > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos-dPosition+dExtraYPos,0), Point3d((dXPos+(dLocBackSet*dBack)), dYPos-dPosition+dExtraYPos,0), dLocBackSet, true, -1, nRigth, RED(), nil, EgtIf( not DGC.Bwd or DGC.Bwd == 0, '*', nil))
end
-- se offset esistente
if abs(dAggrXPos) > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d((dXPos+(dLocBackSet*dBack)),dYPos-dPosition+dExtraYPos,0), Point3d((dXPos+((dLocBackSet+dAggrXPos)*dBack)), dYPos-dPosition+dExtraYPos,0), abs(dAggrXPos), true, -1, nRigth, Color3d(64,128,128), nil, EgtIf( not dLocBackSet or dLocBackSet == 0, '*', nil))
end
end
elseif DGD.SIDE == 'top' then
dXPos = 0
nUp = 1
nRigth = 0
dYPos = DGD.dH
dExtraXPos = dAggrXPos
dPosition = DGD.POSITION
dBack = 1
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dPosition = -DGD.POSITION
dExtraXPos = -dAggrXPos
dBack = -1
end
if not nNumGeom or nNumGeom == 1 then
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d((dXPos+dPosition),dYPos,0), DGD.POSITION, true, nUp, false, RED())
end
-- quota backset
local dLocBackSet = DGD.BACK_SET
if dAggrBackSet then
dLocBackSet = dAggrBackSet
end
-- se offset X presente
if dExtraXPos and abs(dExtraXPos) > 0 then
local dOffsPoint = 0
if dAggrYPos and abs(dAggrYPos) > 0 then
-- se riferimengo globale in Y quoto
if bRefYFromDoor then
dOffsPoint = -dAggrYPos
else
dOffsPoint = -dLocBackSet+dAggrYPos
end
end
-- se riferito a lato lock
if bRefXFromDoor then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d((dXPos+dExtraXPos),dYPos+dOffsPoint,0), abs(dExtraXPos), true, nUp, false, Color3d(64,128,128), nil, EgtIf( not DGC.Bwd or DGC.Bwd == 0, '*', nil))
else
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+dPosition,dYPos,0), Point3d((dXPos+dPosition+dExtraXPos),dYPos+dOffsPoint,0), abs(dExtraXPos), true, nUp, false, Color3d(64,128,128))
end
end
-- riassegno la posizione in base al flag di riferimento posizione globale in X
if bRefXFromDoor then
dPosition = 0
else
dPosition = DGD.POSITION
end
-- se riferimengo globale in Y quoto
if bRefYFromDoor then
-- se offset esistente
if dExtraXPos and abs(dExtraXPos) > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos,0), Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos-dAggrYPos,0), abs(dAggrYPos), false, -1, -1, Color3d(64,128,128))
end
else
-- se quota backset maggiore di 0
if dLocBackSet and dLocBackSet > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos,0), Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos-dLocBackSet,0), dLocBackSet, false, -1, -1, RED())
end
-- se offset esistente
if dExtraXPos and abs(dExtraXPos) > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos-dLocBackSet,0), Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos-dLocBackSet+dAggrYPos,0), abs(dAggrYPos), false, -1, -1, Color3d(64,128,128))
end
end
-- quota offset (solo sui frame)
local dLocOffset = DGD.OFFSET
if dAggrOffset then
dLocOffset = dAggrOffset
end
if dLocOffset and dLocOffset > 0 and nTypePiece > 2 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+(DGD.POSITION*dBack), 0, -DGD.dH), Point3d(dXPos+(DGD.POSITION*dBack), dLocOffset, -DGD.dH), dLocOffset, false, -1, -1, RED(), nil, nil, nil, GDB_FR.FRONT)
end
elseif DGD.SIDE == 'bottom' then
dXPos = 0
nUp = 0
nRigth = 0
dYPos = 0
dExtraXPos = dAggrXPos
dPosition = DGD.POSITION
dBack = 1
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dPosition = -DGD.POSITION
dExtraXPos = -dAggrXPos
dBack = -1
end
if not nNumGeom or nNumGeom == 1 then
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d((dXPos+dPosition),dYPos,0), DGD.POSITION, true, nUp, false, RED())
end
-- quota backset
local dLocBackSet = DGD.BACK_SET
if dAggrBackSet then
dLocBackSet = dAggrBackSet
end
-- se offset X presente
if dExtraXPos and abs(dExtraXPos) > 0 then
local dOffsPoint = 0
if dAggrYPos and abs(dAggrYPos) > 0 then
-- se riferimengo globale in Y quoto
if bRefYFromDoor then
dOffsPoint = dAggrYPos
else
dOffsPoint = dLocBackSet+dAggrYPos
end
end
-- se riferito a lato lock
if bRefXFromDoor then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d((dXPos+dExtraXPos),dYPos+dOffsPoint,0), abs(dExtraXPos), true, nUp, false, Color3d(64,128,128), nil, EgtIf( not DGC.Bwd or DGC.Bwd == 0, '*', nil))
else
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+dPosition,dYPos,0), Point3d((dXPos+dPosition+dExtraXPos),dYPos+dOffsPoint,0), abs(dExtraXPos), true, nUp, false, Color3d(64,128,128))
end
end
-- riassegno la posizione in base al flag di riferimento posizione globale in X
if bRefXFromDoor then
dPosition = 0
else
dPosition = DGD.POSITION
end
-- se riferimengo globale in Y quoto
if bRefYFromDoor then
-- se offset esistente
if dExtraXPos and abs(dExtraXPos) > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos,0), Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos+dAggrYPos,0), abs(dAggrYPos), false, -1, -1, Color3d(64,128,128))
end
else
-- se quota backset maggiore di 0
if dLocBackSet and dLocBackSet > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos,0), Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos+dLocBackSet,0), dLocBackSet, false, -1, -1, RED())
end
-- se quota esistente
if dExtraXPos and abs(dExtraXPos) > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos+dLocBackSet,0), Point3d(dXPos+(dPosition*dBack)+dExtraXPos,dYPos+dLocBackSet+dAggrYPos,0), abs(dAggrYPos), false, -1, -1, Color3d(64,128,128))
end
end
-- quota offset (solo sui frame)
local dLocOffset = DGD.OFFSET
if dAggrOffset then
dLocOffset = dAggrOffset
end
if dLocOffset and dLocOffset > 0 and nTypePiece > 2 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos+(DGD.POSITION*dBack),dYPos,0), Point3d(dXPos+(DGD.POSITION*dBack),dYPos+dLocOffset,0), dLocOffset, false, -1, -1, RED(), nil, nil, nil, GDB_FR.FRONT)
end
end
-- DGD.DIM_LOCK = nil -- per abilitare le quote nell'EgtCam5
--debug
-- if nTypePiece == 5 then
-- EgtSaveFile( sNgeFile)
-- EgtMove(DGD.PZ, Point3d(0,0,nil) - ORIG())
-- end
elseif nTypeGeom == 5 then -- tipo hinge
dXPos = 0
nRigth = 0
if sSideLock == 'L' then
dXPos = DGD.dW
nRigth = 1
end
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH,0), Point3d(dXPos,DGD.dH-DGD.POSITION,0), DGD.POSITION, false, 0, nRigth, BLUE())
elseif nTypeGeom == 6 then -- tipo mail_slot
dXPos = DGD.dW
dYPos = DGD.BOTTOM_RAIL
dDeltaXPos = DGD.DELTA_CENTER
dDeltaXValue = DGD.DELTA_CENTER
nRigth = 1
dBack = 1
if sSideLock ~= 'L' then
dXPos = 0
dDeltaXPos = -DGD.DELTA_CENTER
nRigth = 0
dBack = -1
end
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,0,0), Point3d(((DGD.dW/2)+dDeltaXPos),dYPos,0), dYPos, false, 0, nRigth, GREEN())
-- quota delta_center
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d((DGD.dW/2),0,0), Point3d(((DGD.dW/2)+dDeltaXPos),dYPos,0), dDeltaXValue, true, 0, nRigth, GREEN())
elseif nTypeGeom == 7 then -- tipo flush_pull
dXPos = 0
nRigth = 0
dBack = 1
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dBack = -1
end
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH,0), Point3d(dXPos,DGD.dH-DGD.POSITION,0), DGD.POSITION, false, 0, nRigth, {221,0,0,100})
-- quota backset
if DGD.BACK_SET and DGD.BACK_SET > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH-DGD.POSITION,0), Point3d((dXPos+(DGD.BACK_SET*dBack)),DGD.dH-DGD.POSITION,0), DGD.BACK_SET, true, -1, bRigth, {221,0,0,100})
end
elseif nTypeGeom == 8 then -- tipo viewer
dXPos = DGD.dW
dYPos = DGD.BOTTOM_RAIL
dDeltaXPos = DGD.DELTA_CENTER
dDeltaXValue = DGD.DELTA_CENTER
nRigth = 1
bTop = DGD.SIDE and DGD.SIDE == 'top'
dBack = 1
if sSideLock ~= 'L' then
dXPos = 0
dDeltaXPos = -DGD.DELTA_CENTER
nRigth = 0
dBack = -1
end
if not bTop then
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,0,0), Point3d(((DGD.dW/2)+dDeltaXPos),dYPos,0), dYPos, false, 0, nRigth, GREEN())
-- quota delta_center
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d((DGD.dW/2),0,0), Point3d(((DGD.dW/2)+dDeltaXPos),dYPos,0), dDeltaXValue, true, 0, nRigth, GREEN())
else
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH,0), Point3d(((DGD.dW/2)+dDeltaXPos),(DGD.dH-dYPos),0), dYPos, false, 0, nRigth, GREEN())
-- quota delta_center
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d((DGD.dW/2),DGD.dH,0), Point3d(((DGD.dW/2)+dDeltaXPos),(DGD.dH-dYPos),0), dDeltaXValue, true, 1, nRigth, GREEN())
end
elseif nTypeGeom == 9 then -- tipo rollerlatch
if DGD.SIDE == 'lock' then
dXPos = 0
nUp = 0
nRigth = 0
dYPos = DGD.dH
dBack = 1
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dBack = -1
end
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d(dXPos,dYPos-DGD.POSITION,0), DGD.POSITION, false, nUp, nRigth, {17,255,17,100})
else
dXPos = 0
nUp = 1
dYPos = DGD.dH
dPosition = DGD.POSITION
if sSideLock ~= 'L' then
dXPos = DGD.dW
dPosition = -DGD.POSITION
end
if DGD.SIDE ~= 'top' then
dYPos = 0
nUp = 0
end
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d((dXPos+dPosition),dYPos,0), DGD.POSITION, true, nUp, false, {17,255,17,100})
end
elseif nTypeGeom == 10 then -- tipo edgepull
dXPos = 0
nRigth = 0
dBack = 1
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dBack = -1
end
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH,0), Point3d(dXPos,DGD.dH-DGD.POSITION,0), DGD.POSITION, false, 0, nRigth, {193,0,0,100})
-- quota backset
if DGD.BACK_SET and DGD.BACK_SET > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH-DGD.POSITION,0), Point3d((dXPos+(DGD.BACK_SET*dBack)),DGD.dH-DGD.POSITION,0), DGD.BACK_SET, true, -1, nRigth, RED(), nil, EgtIf( not DGC.Bwd or DGC.Bwd == 0, '*', nil))
end
elseif nTypeGeom == 11 then -- tipo flushbolt
-- quoto solo gli extension
if string.lower(DGD.TYPE) == 'extension' then
dXPos = 0
dYPos = DGD.dH
nRigth = 0
dBack = 1
nUp = 1
dPosition = DGD.POSITION
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dBack = -1
end
if DGD.SIDE ~= 'top' then
dYPos = 0
nUp = 0
dPosition = -DGD.POSITION
end
-- quota top/bottom position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d(dXPos,dYPos-dPosition,0), DGD.POSITION, false, 0, nRigth, {147,0,0,100})
-- se presente cava di testa
if abs(dPosXHead) > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d((dXPos+(dPosXHead*dBack)),dYPos,0), dPosXHead, true, nUp, nRigth, {147,0,0,100}, nil, EgtIf( not DGC.Bwd or DGC.Bwd == 0, '*', nil))
end
end
elseif nTypeGeom == 12 then -- tipo pivot
-- se tipo center hung o offset
if string.lower(DGD.TYPE) ~= 'offsetintermediate' then
dXPos = 0
dYPos = DGD.dH
nUp = 1
dPosition = DGD.POSITION
if sSideLock == 'L' then
dXPos = DGD.dW
dPosition = -DGD.POSITION
end
if DGD.SIDE ~= 'top' then
dYPos = 0
nUp = 0
end
-- quota top/bottom position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,dYPos,0), Point3d((dXPos+dPosition),dYPos,0), DGD.POSITION, true, nUp, false, {255,0,128,100})
else -- tipo offsetintermediate
dXPos = 0
nRigth = 0
if sSideLock == 'L' then
dXPos = DGD.dW
nRigth = 1
end
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH,0), Point3d(dXPos,DGD.dH-DGD.POSITION,0), DGD.POSITION, false, 0, nRigth, {255,0,128,100})
end
elseif nTypeGeom == 14 then -- tipo strike
dXPos = 0
nRigth = 0
dBack = 1
if sSideLock ~= 'L' then
dXPos = DGD.dW
nRigth = 1
dBack = -1
end
-- quota position
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH,0), Point3d(dXPos,DGD.dH-DGD.POSITION,0), DGD.POSITION, false, 0, nRigth, RED())
-- quota backset
if DGD.BACK_SET and DGD.BACK_SET > 0 then
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH-DGD.POSITION,0), Point3d((dXPos+(DGD.BACK_SET*dBack)),DGD.dH-DGD.POSITION,0), DGD.BACK_SET, true, -1, nRigth, RED(), nil, EgtIf( not DGC.Bwd or DGC.Bwd == 0, '*', nil))
end
elseif nTypeGeom == 17 then -- tipo ept
dXPos = 0
nRigth = 0
if sSideLock == 'L' then
dXPos = DGD.dW
nRigth = 1
end
DGD.tSizeLayer[nTypeGeom] = AssignSize( DGD.PZ, DGD.tSizeLayer[nTypeGeom], nTypePiece, nTypeGeom, Point3d(dXPos,DGD.dH,0), Point3d(dXPos,DGD.dH-DGD.TOPTOCL,0), DGD.TOPTOCL, false, 0, nRigth, {0,0,164,100})
end
end
-----------------------------------------------------------------
local function InsertGeom( tGeometries, sSideLock, bPushDoor, sTypeGeom)
local nCont = 1
local sFileExt
local sFileName
local sFilePath
local nErr, sErr
local bBox
local sPathLua
local sSubPath
local nTypeGeom
local bImport
local sImportType
local nGeomId
if not sTypeGeom then
return false
elseif string.lower(sTypeGeom) == 'vision' then
sSubPath = 'Compo\\VisionCutOuts\\'
nTypeGeom = 1
elseif string.lower(sTypeGeom) == 'louver' then
sSubPath = 'Compo\\LouverCutOuts\\'
nTypeGeom = 2
elseif string.lower(sTypeGeom) == 'lock' then
sSubPath = 'Compo\\Locks\\'
nTypeGeom = 3
elseif string.lower(sTypeGeom) == 'stopandcloser' then
sSubPath = 'Compo\\StopsAndClosers\\'
nTypeGeom = 4
elseif string.lower(sTypeGeom) == 'hinge' then
sSubPath = 'Compo\\Hinges\\'
nTypeGeom = 5
elseif string.lower(sTypeGeom) == 'mail' then
sSubPath = 'Compo\\MailSlots\\'
nTypeGeom = 6
elseif string.lower(sTypeGeom) == 'flush' then
sSubPath = 'Compo\\FlushPulls\\'
nTypeGeom = 7
elseif string.lower(sTypeGeom) == 'viewer' then
sSubPath = 'Compo\\Viewers\\'
nTypeGeom = 8
elseif string.lower(sTypeGeom) == 'rollerlatch' then
sSubPath = 'Compo\\RollerLatchs\\'
nTypeGeom = 9
elseif string.lower(sTypeGeom) == 'edgepull' then
sSubPath = 'Compo\\EdgePulls\\'
nTypeGeom = 10
elseif string.lower(sTypeGeom) == 'flushbolt' then
sSubPath = 'Compo\\FlushBolts\\'
nTypeGeom = 11
elseif string.lower(sTypeGeom) == 'pivot' then
sSubPath = 'Compo\\Pivots\\'
nTypeGeom = 12
elseif string.lower(sTypeGeom) == 'overhead' then
sSubPath = 'Compo\\OverHeads\\'
nTypeGeom = 13
elseif string.lower(sTypeGeom) == 'strike' then
sSubPath = 'Compo\\Strikes\\'
nTypeGeom = 14
elseif string.lower(sTypeGeom) == 'groove' then
sSubPath = 'Compo\\Groove\\'
nTypeGeom = 15
elseif string.lower(sTypeGeom) == 'rabbet' then
sSubPath = 'Compo\\Rabbets\\'
nTypeGeom = 16
elseif string.lower(sTypeGeom) == 'ept' then
sSubPath = 'Compo\\Epts\\'
nTypeGeom = 17
elseif string.lower(sTypeGeom) == 'facedecoration' then
sSubPath = 'Compo\\FaceDecoration\\'
nTypeGeom = 18
end
while nCont <= #tGeometries do
if nTypeGeom == 1 then -- se vision
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].shape
DGD.SPLIT = tGeometries[nCont].split
DGD.DIR = tGeometries[nCont].dir
if tGeometries[nCont].split or ( tGeometries[nCont].length and tGeometries[nCont].width) then
DGD.LENGTH = tGeometries[nCont].length
DGD.WIDTH = tGeometries[nCont].width
DGD.TOP_RAIL = tGeometries[nCont].top_rail
DGD.LOCK_STYLE = tGeometries[nCont].lock_stile
DGD.POINTAPP = tGeometries[nCont].door_center
DGD.RADIUS = tGeometries[nCont].radius
-- se split è assente
elseif tGeometries[nCont].split == nil then
-- setto anche variabili lunghezza e larghezza che sono a nil per evitare di mantenere precedenti settaggi delle stesse variabili
DGD.LENGTH = tGeometries[nCont].length
DGD.WIDTH = tGeometries[nCont].width
DGD.RADIUS = tGeometries[nCont].radius
DGD.CENTER_FROM_TOP = tGeometries[nCont].center_from_top
DGD.CENTER_FROM_LOCK = tGeometries[nCont].center_from_lock
DGD.POINTAPP = tGeometries[nCont].door_center
end
elseif nTypeGeom == 2 then -- se louver
if not tGeometries[nCont].shape then -- se non ho shape lancio il rect di default
sPathLua = sBaseDir .. sSubPath .. 'rect' -- con il louver c'è solo una forma rettangolare
else
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].shape
end
if tGeometries[nCont].length and tGeometries[nCont].width then
DGD.LENGTH = tGeometries[nCont].length
DGD.WIDTH = tGeometries[nCont].width
DGD.BOTTOM_RAIL = tGeometries[nCont].bottom_rail
DGD.LOCK_STYLE = tGeometries[nCont].lock_stile
DGD.POINTAPP = tGeometries[nCont].door_center
end
elseif nTypeGeom == 3 then -- se lock
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.BACK_SET = tGeometries[nCont].back_set
DGD.POSITION = tGeometries[nCont].position
DGD.OFFSET = tGeometries[nCont].offset
DGD.SIDE = tGeometries[nCont].side
DGD.OTHERD = tGeometries[nCont].other_door
elseif nTypeGeom == 4 then -- se stop_and_closer
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.POSITION = tGeometries[nCont].position
DGD.POCKET_OFFSET = tGeometries[nCont].pocket_offset
DGD.SIDE = tGeometries[nCont].side
DGD.OTHERD = tGeometries[nCont].other_door
elseif nTypeGeom == 5 then -- se hinge
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.BACK_SET = tGeometries[nCont].back_set
DGD.THICKNESS = tGeometries[nCont].thickness
DGD.POSITION = tGeometries[nCont].position
elseif nTypeGeom == 6 then -- se mail_slot
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.LENGTH = tGeometries[nCont].length
DGD.BOTTOM_RAIL = tGeometries[nCont].bottom_rail
DGD.DELTA_CENTER = tGeometries[nCont].delta_center
elseif nTypeGeom == 7 then -- se flush_pull
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.BACK_SET = tGeometries[nCont].back_set
DGD.POSITION = tGeometries[nCont].position
DGD.DEPTH = tGeometries[nCont].depth
DGD.FACE = tGeometries[nCont].face
elseif nTypeGeom == 8 then -- se viewer
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.BOTTOM_RAIL = tGeometries[nCont].bottom_rail
DGD.DELTA_CENTER = tGeometries[nCont].delta_center
DGD.SIDE = tGeometries[nCont].side
elseif nTypeGeom == 9 then -- se roller_latch
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.SIDE = tGeometries[nCont].side
DGD.POSITION = tGeometries[nCont].position
DGD.OFFSET = tGeometries[nCont].offset
DGD.OTHERD = tGeometries[nCont].other_door
elseif nTypeGeom == 10 then -- se edge_pull
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.POSITION = tGeometries[nCont].position
DGD.OFFSET = tGeometries[nCont].offset
elseif nTypeGeom == 11 then -- se flush_bolt
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.TYPE = tGeometries[nCont].type
DGD.SIDE = tGeometries[nCont].side
DGD.POSITION = tGeometries[nCont].position
DGD.OFFSET = tGeometries[nCont].offset
DGD.BACK_SET = tGeometries[nCont].back_set
DGD.OTHERD = tGeometries[nCont].other_door
elseif nTypeGeom == 12 then -- se pivot
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.TYPE = tGeometries[nCont].type
DGD.SIDE = tGeometries[nCont].side
DGD.RADIUS = tGeometries[nCont].radius
DGD.POSITION = tGeometries[nCont].position
DGD.BACK_SET = tGeometries[nCont].back_set
DGD.DEPTH_F = tGeometries[nCont].depth_f
DGD.OFFSET = tGeometries[nCont].offset
DGD.OTHERD = tGeometries[nCont].other_door
elseif nTypeGeom == 13 then -- se overhead
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.POCKPOS = tGeometries[nCont].pockpos
DGD.POCKLENGTH = tGeometries[nCont].pocklength
DGD.POCKET_OFFSET = tGeometries[nCont].pocket_offset
DGD.ARMPOS = tGeometries[nCont].armpos
DGD.ARMLENGTH = tGeometries[nCont].armlength
DGD.SIDE = tGeometries[nCont].side
DGD.OTHERD = tGeometries[nCont].other_door
elseif nTypeGeom == 14 then -- se strike
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.BACK_SET = tGeometries[nCont].back_set
DGD.POSITION = tGeometries[nCont].position
DGD.OFFSET = tGeometries[nCont].offset
DGD.OTHERD = tGeometries[nCont].other_door
elseif nTypeGeom == 15 then -- se groove
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.TYPE = tGeometries[nCont].type
DGD.SIDE = tGeometries[nCont].side
DGD.FST = tGeometries[nCont].fst
DGD.HST = tGeometries[nCont].hst
DGD.LST = tGeometries[nCont].lst
if DGD.SIDE == 'hinge' or DGD.SIDE == 'lock' then
if bRemake then
if DGD.SIDE == 'lock' then
DGD.LENGTH = EgtIf( sSideLock == 'L', max(DGD.L2Top,DGD.L2), max(DGD.L4Top,DGD.L4))
else
DGD.LENGTH = EgtIf( sSideLock == 'L', max(DGD.L4Top,DGD.L4), max(DGD.L2Top,DGD.L2))
end
else
DGD.LENGTH = DGD.dH -- setto come altezza porta
end
if DGD.HST and DGD.LST and DGD.TYPE == 'center' then
DGD.LENGTH = DGD.LENGTH - DGD.HST - DGD.LST
end
else
if bRemake then
if DGD.SIDE == 'top' or DGD.SIDE == 'top_angle' or DGD.SIDE == 'top_flat' then
DGD.LENGTH = max(DGD.L3Top,DGD.L3)
else
DGD.LENGTH = max(DGD.L1Top,DGD.L1)
end
else
-- se lato top ed è ad angoolo ricalcolo il lato
if ( DGD.SIDE == 'top_flat' or DGD.SIDE == 'top_angle') and DGD.Tpa then
-- se devo applicare il groove su lato diritto corto
if DGD.SIDE == 'top_flat' then
-- se lunghezza lato dritto esiste
if DGD.tProfs.top.xdeltapos > 0 then
DGD.LENGTH = DGD.tProfs.top.xdeltapos
else
DGD.LENGTH = DGD.dW -- setto di base come larghezza porta
end
-- altrimenti è da applicare su lato inclinato
else
if ( DGD.dW - DGD.tProfs.top.xdeltapos) > 0 then
DGD.LENGTH = ( DGD.dW - DGD.tProfs.top.xdeltapos) / cos(abs(DGD.tProfs.top.angle))
else
DGD.LENGTH = DGD.dW -- setto di base come larghezza porta
end
end
else
DGD.LENGTH = DGD.dW -- setto di base come larghezza porta
end
end
DGD.SIDELENGTH = DGD.LENGTH
if DGD.HST and DGD.LST then
-- se lato top ed è ad angoolo ed è presente lato piano ricalcolo il lato
-- if DGD.SIDE == 'top_flat' and DGD.Tpa and DGD.tProfs.top.xdeltapos > 0 then
-- -- se parte angolata sulla parte sinistra
-- if DGD.tProfs.top.angle > 0 then
-- -- se lato losk a sinsitra
-- if DGD.Lock == 'L' then
-- -- ricalcolo il lato
-- DGD.LENGTH = DGD.LENGTH - DGD.HST
-- DGD.LST = 0
-- else
-- -- ricalcolo il lato
-- DGD.LENGTH = DGD.LENGTH - DGD.LST
-- DGD.HST = 0
-- end
-- -- altrimenti parte angolata sulla parte destra
-- else
-- -- se lato losk a sinsitra
-- if DGD.Lock == 'L' then
-- -- ricalcolo il lato
-- DGD.LENGTH = DGD.LENGTH - DGD.LST
-- DGD.HST = 0
-- else
-- -- ricalcolo il lato
-- DGD.LENGTH = DGD.LENGTH - DGD.HST
-- DGD.LST = 0
-- end
-- end
-- elseif DGD.SIDE == 'top_angle' and DGD.Tpa and ( DGD.dW - DGD.tProfs.top.xdeltapos) > 0 then
-- -- se parte angolata sulla parte sinistra
-- if DGD.tProfs.top.angle > 0 then
-- -- se lato losk a sinsitra
-- if DGD.Lock == 'L' then
-- -- ricalcolo il lato
-- DGD.LENGTH = DGD.LENGTH - DGD.LST
-- DGD.HST = 0
-- else
-- -- ricalcolo il lato
-- DGD.LENGTH = DGD.LENGTH - DGD.HST
-- DGD.LST = 0
-- end
-- -- altrimenti parte angolata sulla parte destra
-- else
-- -- se lato losk a sinsitra
-- if DGD.Lock == 'L' then
-- -- ricalcolo il lato
-- DGD.LENGTH = DGD.LENGTH - DGD.HST
-- DGD.LST = 0
-- else
-- -- ricalcolo il lato
-- DGD.LENGTH = DGD.LENGTH - DGD.LST
-- DGD.HST = 0
-- end
-- end
-- else
DGD.LENGTH = DGD.LENGTH - DGD.HST - DGD.LST
-- end
end
-- se larghezza porta è large width setto flag
if DGD.Part and DGD.Part > 0 and DGD.dW > DGD.Part then
DGD.bPart = true
end
end
if DGD.FST then
tGeometries[nCont].width = DGD.dT - DGD.FST - DGD.FST
end
DGD.WIDTH = tGeometries[nCont].width
DGD.DEPTH = tGeometries[nCont].depth
DGD.GROOVE_OFFSET = tGeometries[nCont].groove_offset
elseif nTypeGeom == 16 then -- se rabbet
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.SIDE = tGeometries[nCont].side
if DGD.SIDE == 'hinge' or DGD.SIDE == 'lock' then
if bRemake then
if DGD.SIDE == 'lock' then
DGD.LENGTH = EgtIf( sSideLock == 'L', max(DGD.L2Top,DGD.L2), max(DGD.L4Top,DGD.L4))
else
DGD.LENGTH = EgtIf( sSideLock == 'L', max(DGD.L4Top,DGD.L4), max(DGD.L2Top,DGD.L2))
end
else
DGD.LENGTH = DGD.dH -- setto come altezza porta
end
else
if bRemake then
if DGD.SIDE == 'top' then
DGD.LENGTH = max(DGD.L3Top,DGD.L3)
else
DGD.LENGTH = max(DGD.L1Top,DGD.L1)
end
else
DGD.LENGTH = DGD.dW -- setto di base come larghezza porta
end
-- se larghezza porta è large width setto flag
if DGD.Part and DGD.Part > 0 and DGD.dW > DGD.Part then
DGD.bPart = true
end
end
DGD.WIDTH = tGeometries[nCont].width
DGD.DEPTH = tGeometries[nCont].depth
DGD.ANGLE = tGeometries[nCont].angle
DGD.OPPO = tGeometries[nCont].oppo
elseif nTypeGeom == 17 then -- se ept
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.FACETOCL = tGeometries[nCont].back_set
DGD.TOPTOCL = tGeometries[nCont].position
elseif nTypeGeom == 18 then -- se facedecoration
sPathLua = sBaseDir .. sSubPath .. tGeometries[nCont].template
DGD.TYPE = tGeometries[nCont].type
DGD.DEPTH = tGeometries[nCont].depth
DGD.DFT = tGeometries[nCont].dft
DGD.DFB = tGeometries[nCont].dfb
DGD.DFL = tGeometries[nCont].dfl
DGD.DFH = tGeometries[nCont].dfh
DGD.FACE = tGeometries[nCont].face
end
-- Controllo se nel nome file è già presente l'estensione .nge
sFilePath,sFileName,sFileExt = EgtSplitPath( string.lower(sPathLua))
bImport = false
-- se trovata estensione .nge nel template
if sFileExt and sFileExt == '.nge' then
sImportType = 'nge'
else -- non contiene direttamente estensione nge
if EgtExistsFile( string.lower(sPathLua)..'.lua') then-- provo con lua
sImportType = 'lua'
elseif EgtExistsFile( string.lower(sPathLua)..'.nge') then -- provo con nge
sImportType = 'nge'
sFileExt = '.nge'
else -- altrimenti tipo non riconosciuto
sImportType = 'bad'
end
end
-- in base al tipo lancio l'import, o il componente lua o do errore
if sImportType == 'nge' then
local sPathNge = sBaseDir .. 'LuaLibs\\ImportNgeFile.lua'
-- compongo il parametro nomefile
sFileName = sFileName .. sFileExt
local MHgen = require('ImportNgeFile')
nErr, sErr, nGeomId = MHgen.Draw( sFilePath,sFileName)
if nErr == 0 and nGeomId then
-- in base al tipo ri-setto le dimensioni di ingombro della geometria importata
if nTypeGeom == 1 or nTypeGeom == 2 or nTypeGeom == 18 then -- se vision o louver o decoration
bBox = EgtGetBBox( nGeomId, 0)
tGeometries[nCont].length = bBox:getDimY(bBox)
tGeometries[nCont].width = bBox:getDimX(bBox)
DGD.LENGTH = tGeometries[nCont].length
DGD.WIDTH = tGeometries[nCont].width
elseif nTypeGeom == 6 then -- se mail slot
bBox = EgtGetBBox( nGeomId, 0)
tGeometries[nCont].length = bBox:getDimY(bBox)
DGD.LENGTH = tGeometries[nCont].length
end
bImport = true
end
elseif sImportType == 'lua' then -- componente lua
sPathLua = sPathLua .. '.lua'
nErr, sErr, nGeomId = dofile( sPathLua)
else
nErr = 1000
sErr = string.format(EgtDoorsMsg[411],sPathLua, DGD.FILE)
end
if nErr > 0 then
DoorOutLog( sErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sErr
if DGD.ERR <= 0 then DGD.ERR = nErr end
break
else
-- se presente messaggio di warning
if nErr < 0 then
DoorOutLog( sErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sErr
if DGD.ERR == 0 then DGD.ERR = nErr end
end
--debug
-- EgtSaveFile( sNgeFile)
-- EgtMove(DGD.PZ, Point3d(0,0,nil) - ORIG())
-- posizionamento geometria
-- tipo vision
if nTypeGeom == 1 then
if DGD.SPLIT then
if DGD.LENGTH and tGeometries[nCont].length and abs( DGD.LENGTH - tGeometries[nCont].length) > GEO.EPS_SMALL then
tGeometries[nCont].length = DGD.LENGTH
end
if DGD.WIDTH and tGeometries[nCont].width and abs( DGD.WIDTH - tGeometries[nCont].width) > GEO.EPS_SMALL then
tGeometries[nCont].width = DGD.WIDTH
end
end
tGeometries[nCont].geom = nGeomId
MoveCutOuts( tGeometries[nCont], sSideLock, bPushDoor, bImport, nTypeGeom)
-- vision sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 2 then -- tipo louver
tGeometries[nCont].geom = nGeomId
MoveCutOuts( tGeometries[nCont], sSideLock, bPushDoor, bImport, nTypeGeom)
-- louver sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 3 then -- tipo lock
-- verifico se è un aggregato
local sType = type(nGeomId)
if sType == 'table' then
if #nGeomId >= 1 then
for k = 1, #nGeomId do
tGeometries[nCont].geom = nGeomId[k][1]
tGeometries[nCont].back_set = nGeomId[k][2]
tGeometries[nCont].offset = nGeomId[k][3]
MoveLock( tGeometries[nCont], sSideLock, bPushDoor)
-- lock sizing
InsertSize( nTypeGeom, sSideLock, nil, nil, nGeomId[k][4],
nGeomId[k][5], nGeomId[k][2], nGeomId[k][3], nGeomId[k][6], nGeomId[k][7],
k)
end
end
else
tGeometries[nCont].geom = nGeomId
MoveLock( tGeometries[nCont], sSideLock, bPushDoor)
-- lock sizing
InsertSize( nTypeGeom, sSideLock, nil, nil, 0, 0)
end
elseif nTypeGeom == 4 then -- tipo stop_and_closer
-- verifico se è un aggregato
local sType = type(nGeomId)
if sType == 'table' then
if #nGeomId >= 1 then
for k = 1, #nGeomId do
tGeometries[nCont].geom = nGeomId[k]
MoveStopAndCloser( tGeometries[nCont], sSideLock, bPushDoor)
end
end
else
tGeometries[nCont].geom = nGeomId
MoveStopAndCloser( tGeometries[nCont], sSideLock, bPushDoor)
end
elseif nTypeGeom == 5 then -- tipo hinge
tGeometries[nCont].geom = nGeomId
MoveHinge( tGeometries[nCont], sSideLock, bPushDoor)
-- hinge sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 6 then -- tipo mail_slot
tGeometries[nCont].geom = nGeomId
MoveCutOuts( tGeometries[nCont], sSideLock, bPushDoor, bImport, nTypeGeom)
-- mail slot sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 7 then -- tipo flush_pull
tGeometries[nCont].geom = nGeomId
MoveFlushPull( tGeometries[nCont], sSideLock, bPushDoor, bImport)
-- flush_pull sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 8 then -- tipo viewer
tGeometries[nCont].geom = nGeomId
MoveViewer( tGeometries[nCont], sSideLock, bPushDoor)
-- viewer sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 9 then -- tipo rollerlatch
tGeometries[nCont].geom = nGeomId
MoveRollerLatch( tGeometries[nCont], sSideLock, bPushDoor)
-- roller latch sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 10 then -- tipo edgepull
tGeometries[nCont].geom = nGeomId
MoveEdgePull( tGeometries[nCont], sSideLock, bPushDoor)
-- EdgePull sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 11 then -- tipo flushbolt
tGeometries[nCont].geom = nGeomId
MoveFlushBolt( tGeometries[nCont], sSideLock, bPushDoor)
-- FlushBolt sizing
local dPosHead = 0
if string.lower(DGD.TYPE) == 'extension' then
-- ricavo nota spostamento cava di testa
dPosHead = EgtGetInfo( tGeometries[nCont].geom, 'DB_X', 'd') or 0
end
InsertSize( nTypeGeom, sSideLock, nil, dPosHead)
elseif nTypeGeom == 12 then -- tipo pivot
tGeometries[nCont].geom = nGeomId
MovePivot( tGeometries[nCont], sSideLock, bPushDoor)
-- Pivot sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 13 then -- tipo overhead
tGeometries[nCont].geom = nGeomId
MoveOverHead( tGeometries[nCont], sSideLock, bPushDoor)
elseif nTypeGeom == 14 then -- tipo strike
tGeometries[nCont].geom = nGeomId
MoveStrike( tGeometries[nCont], sSideLock, bPushDoor)
-- Strike sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 15 then -- tipo groove
tGeometries[nCont].geom = nGeomId
MoveGroove( tGeometries[nCont], sSideLock, bPushDoor)
elseif nTypeGeom == 16 then -- tipo rabbet
tGeometries[nCont].geom = nGeomId
MoveRabbet( tGeometries[nCont], sSideLock, bPushDoor)
elseif nTypeGeom == 17 then -- tipo ept
tGeometries[nCont].geom = nGeomId
MoveEPT( tGeometries[nCont], sSideLock, bPushDoor)
-- EPT sizing
InsertSize( nTypeGeom, sSideLock)
elseif nTypeGeom == 18 then -- tipo facedecoration
tGeometries[nCont].geom = nGeomId
MoveCopyDecoration( tGeometries[nCont], sSideLock, bPushDoor, bImport)
end
end
nCont = nCont + 1
end
end
-----------------------------------------------------------------
local function SubAndDeleteTempSurf( nIdLs)
-- ricerca delle superfici princiapli
local nIdSurfUp
local nIdSurfDw
local nIdSurf = EgtGetFirstInGroup( nIdLs)
while nIdSurf and ( not nIdSurfUp or not nIdSurfDw) do
-- nome della superficie
local sSurfName = EgtGetName( nIdSurf)
-- se trovata superfice up principale
if not nIdSurfUp and sSurfName and string.lower( sSurfName) == 'flat_up' then
nIdSurfUp = nIdSurf
end
-- se trovata superfice dw principale
if not nIdSurfDw and sSurfName and string.lower( sSurfName) == 'flat_dw' then
nIdSurfDw = nIdSurf
end
-- passo alla successiva
nIdSurf = EgtGetNext( nIdSurf)
end
-- creo superfici temporanee di inviluppo rettangolare delle principali
local nIdRectHullUp
if nIdSurfUp then
local b3SurfUp = EgtGetBBox( nIdSurfUp, GDB_BB.STANDARD)
nIdRectHullUp = EgtSurfFrRectangle( nIdLs, b3SurfUp:getMin(), b3SurfUp:getMax())
if nIdRectHullUp and EgtSurfFrNormVersor( nIdSurfUp) * EgtSurfFrNormVersor( nIdRectHullUp) < 0 then
EgtInvertSurf( nIdRectHullUp)
end
end
local nIdRectHullDw
if nIdSurfDw then
local b3SurfDw = EgtGetBBox( nIdSurfDw, GDB_BB.STANDARD)
nIdRectHullDw = EgtSurfFrRectangle( nIdLs, b3SurfDw:getMin(), b3SurfDw:getMax())
if nIdRectHullDw and EgtSurfFrNormVersor( nIdSurfDw) * EgtSurfFrNormVersor( nIdRectHullDw) < 0 then
EgtInvertSurf( nIdRectHullDw)
end
end
-- ciclo sulle superfici del gruppo
nIdSurf = EgtGetFirstInGroup( nIdLs)
while nIdSurf do
local sSurfName = EgtGetName( nIdSurf)
local nNextId = EgtGetNext( nIdSurf)
-- se superfice up temporanea la sottraggo alla principale e poi la elimino
if nIdSurfUp and sSurfName and string.lower( sSurfName) == 'flat_up_tmp' then
local nIdSurfTmpUp = nIdSurf
EgtSurfFrSubtract( nIdSurfUp, nIdSurfTmpUp)
EgtErase( nIdSurfTmpUp)
end
-- se superfice dw temporanea la sottraggo alla principale e poi la elimino
if nIdSurfDw and sSurfName and string.lower( sSurfName) == 'flat_dw_tmp' then
local nIdSurfTmpDw = nIdSurf
EgtSurfFrSubtract( nIdSurfDw, nIdSurfTmpDw)
EgtErase( nIdSurfTmpDw)
end
-- se superfice up temporanea speciale (da percorsi di hatching) la sommo alla principale e poi la elimino
if nIdSurfUp and nIdRectHullUp and sSurfName and string.lower( sSurfName) == 'flat_up_tmp_sp' then
local nIdSurfTmpUp = nIdSurf
EgtSurfFrIntersect( nIdSurfTmpUp, nIdRectHullUp)
if EgtExistsObj( nIdSurfTmpUp) then
EgtSurfFrAdd( nIdSurfUp, nIdSurfTmpUp)
EgtErase( nIdSurfTmpUp)
end
end
-- se superfice dw temporanea speciale (da percorsi di hatching) la sommo alla principale e poi la elimino
if nIdSurfUp and nIdRectHullDw and sSurfName and string.lower( sSurfName) == 'flat_dw_tmp_sp' then
local nIdSurfTmpDw = nIdSurf
EgtSurfFrIntersect( nIdSurfTmpDw, nIdRectHullDw)
if EgtExistsObj( nIdSurfTmpDw) then
EgtSurfFrAdd( nIdSurfDw, nIdSurfTmpDw)
EgtErase( nIdSurfTmpDw)
end
end
-- passo alla successiva
nIdSurf = nNextId
end
-- cancello le superfici di inviluppo temporanee
EgtErase( nIdRectHullUp)
EgtErase( nIdRectHullDw)
return true
end
-----------------------------------------------------------------
local function GetEdgeToMachine( sSide)
if DGD.Lock == sSide then
return DGD.tProfs.lockedge.machining
elseif sSide == 'L' or sSide == 'R' then
return DGD.tProfs.hingeedge.machining
elseif sSide == 'T' then
return DGD.tProfs.top.machining
elseif sSide == 'B' then
return DGD.tProfs.bottom.machining
end
end
-----------------------------------------------------------------
local function GetEdgeTrimming( sSide)
if DGD.Lock == sSide then
return DGD.tProfs.lockedge.trimming
elseif sSide == 'L' or sSide == 'R' then
return DGD.tProfs.hingeedge.trimming
elseif sSide == 'T' then
return DGD.tProfs.top.trimming
elseif sSide == 'B' then
return DGD.tProfs.bottom.trimming
end
end
-----------------------------------------------------------------
local function SetInvertEdgeTrimming( sProfile)
if sProfile == 'BD' then
sProfile = 'BU'
elseif sProfile == 'BU' then
sProfile = 'BD'
elseif sProfile == 'BDEB' then
sProfile = 'BUEB'
elseif sProfile == 'BUEB' then
sProfile = 'BDEB'
end
return sProfile
end
-----------------------------------------------------------------
local function GetRealEdgeTrimming( sSide)
local sTrim = GetEdgeTrimming( sSide)
if not DGD.sFrame then
if sTrim == 'BD' or sTrim == 'BU' then
if DGD.Push then
sTrim = 'BU'
else
sTrim = 'BD'
end
elseif sTrim == 'BDEB' or sTrim == 'BUEB' then
if DGD.Push then
sTrim = 'BUEB'
else
sTrim = 'BDEB'
end
end
end
return sTrim
end
-----------------------------------------------------------------
local function GetEdgeOffset( sSide)
if DGD.Lock == sSide then
return DGD.tProfs.lockedge.offset
else
return DGD.tProfs.hingeedge.offset
end
end
-----------------------------------------------------------------
local function SetFrameThickValues( bSideLeft)
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
if bSideLeft then
DGD.Lut = 0
DGD.Lub = 0
DGD.Rut = DGD.dW
DGD.Rub = DGD.dW
else
DGD.Ldt = 0
DGD.Ldb = 0
DGD.Rdt = DGD.dW
DGD.Rdb = DGD.dW
end
elseif nTypePiece == 4 then -- se frame DX
if bSideLeft then
DGD.Ldt = 0
DGD.Ldb = 0
DGD.Rdt = DGD.dW
DGD.Rdb = DGD.dW
else
DGD.Lut = 0
DGD.Lub = 0
DGD.Rut = DGD.dW
DGD.Rub = DGD.dW
end
elseif nTypePiece == 5 then -- se frame TOP
if bSideLeft then
DGD.Bul = 0
DGD.Bur = 0
DGD.Tul = DGD.dH
DGD.Tur = DGD.dH
else
DGD.Bdl = 0
DGD.Bdr = 0
DGD.Tdl = DGD.dH
DGD.Tdr = DGD.dH
end
elseif nTypePiece == 6 then -- se frame BOTTOM
if bSideLeft then
DGD.Bdl = 0
DGD.Bdr = 0
DGD.Tdl = DGD.dH
DGD.Tdr = DGD.dH
else
DGD.Bul = 0
DGD.Bur = 0
DGD.Tul = DGD.dH
DGD.Tur = DGD.dH
end
end
else
if bSideLeft then
DGD.Ult = DGD.dT
DGD.Ulb = DGD.dT
DGD.Dlb = 0
DGD.Dlt = 0
if DGD.PROBE == 2 then
DGD.Mlb = DGD.dT/2
DGD.Mlt = DGD.dT/2
end
else
DGD.Urt = DGD.dT
DGD.Urb = DGD.dT
DGD.Drb = 0
DGD.Drt = 0
if DGD.PROBE == 2 then
DGD.Mrb = DGD.dT/2
DGD.Mrt = DGD.dT/2
end
end
end
end
local function RemakeDoor( sLeftType, dRadProf, sRightType, dRadProfR)
local nLa = EgtGroup( DGD.PZ)
EgtSetName( nLa, 'REC')
EgtSetColor( nLa, BROWN())
local dDistToExtX = tProbeDoor.PX + (2*25.4) -- calcolo linea di estensione in X in base al settaggio nella macro + 2 Inch extra
local dDistToExtY = tProbeDoor.PY + (2*25.4) -- calcolo linea di estensione in Y in base al settaggio nella macro + 2 inch extra
-- dichiaro le variabili dei lati
local nBase
local nBaseMid
local nBaseTop
local nRight
local nRightMid
local nRightTop
local nTop
local nTopMid
local nTopTop
local nLeft
local nLeftMid
local nLeftTop
-- creo linee principali (in senso antiorario)
nBase = EgtLine( nLa, { tProbeDoor.P2x, tProbeDoor.P2y, 0}, { tProbeDoor.P3x, tProbeDoor.P3y, 0}, GDB_RT.LOC) -- p2 a p3
if not nBase then
return
end
if DGC.Pms == 0 then -- se ricostruzione completa porta
nRight = EgtLine( nLa, { tProbeDoor.P4x, tProbeDoor.P4y, 0}, { tProbeDoor.P5x, tProbeDoor.P5y, 0}, GDB_RT.LOC) -- p4 a p5
nTop = EgtLine( nLa, { tProbeDoor.P6x, tProbeDoor.P6y, 0}, { tProbeDoor.P7x, tProbeDoor.P7y, 0}, GDB_RT.LOC) -- p6 a p7
nLeft = EgtLine( nLa, { tProbeDoor.P8x, tProbeDoor.P8y, 0}, { tProbeDoor.P1x, tProbeDoor.P1y, 0}, GDB_RT.LOC) -- p8 a p1
else -- se modalità 1 (solo 4 punti probe, calcolo solo larghezza) o modalità 2 ( 5 punti probe, calcolo larghezza e lunghezza)
-- calcolo l'angolo di rotazione
local vDirEnt = EgtSV(nBase)
local dAngRotbase = atan(vDirEnt:getY(),vDirEnt:getX())
-- continuo la costruzione delle linee con un solo angolo calcolato
if tProbeDoor.DD == 0 then -- se porta disposta a destra
-- linea destra calcolata sul punto più vicino alla linea di base
nRight = EgtLinePDL( nLa, { tProbeDoor.P4x, tProbeDoor.P4y, 0}, dAngRotbase+90, ( DGD.dW - (2*tProbeDoor.PY)) ,GDB_RT.LOC) -- p4 con angolo e lunghezza
-- linea top calcolata sul punto opposto in Y a P3 cioè P6
nTop = EgtLinePDL( nLa, { tProbeDoor.P6x, tProbeDoor.P6y, 0}, dAngRotbase + 180, ( DGD.dH - (2*tProbeDoor.PX)), GDB_RT.LOC) -- p6 con angolo e lunghezza
-- se ho il punto anche in lunghezza
if DGC.Pms == 2 then
nLeft = EgtLinePDL( nLa, { tProbeDoor.P1x, tProbeDoor.P1y, 0}, dAngRotbase+90, ( DGD.dW - (2*tProbeDoor.PY)), GDB_RT.LOC) -- p1 con angolo e lunghezza
-- inverto la direzione
EgtInvertCurve(nLeft)
elseif DGC.Pms == 1 then
-- faccio l'offset della linea alla distanza pari all'altezza della porta
nLeft = EgtOffsetCurveAdv( nRight, -DGD.dH)
-- inverto la direzione
EgtInvertCurve(nLeft)
end
else -- altrimenti disposta a sinistra
-- linea sinistra calcolata sul punto più vicino alla linea di base
nLeft = EgtLinePDL( nLa, { tProbeDoor.P1x, tProbeDoor.P1y, 0}, dAngRotbase+90, ( DGD.dW - (2*tProbeDoor.PY)) ,GDB_RT.LOC) -- p4 con angolo e lunghezza
-- inverto la direzione
EgtInvertCurve(nLeft)
-- linea top calcolata sul punto opposto in Y a P2, cioè P7
nTop = EgtLinePDL( nLa, { tProbeDoor.P7x, tProbeDoor.P7y, 0}, dAngRotbase, ( DGD.dH - (2*tProbeDoor.PX)), GDB_RT.LOC) -- p6 con angolo e lunghezza
-- inverto la direzione
EgtInvertCurve(nTop)
-- se ho il punto anche in lunghezza
if DGC.Pms == 2 then
nRight = EgtLinePDL( nLa, { tProbeDoor.P4x, tProbeDoor.P4y, 0}, dAngRotbase+90, ( DGD.dW - (2*tProbeDoor.PY)), GDB_RT.LOC) -- p1 con angolo e lunghezza
elseif DGC.Pms == 1 then
-- faccio l'offset della linea alla distanza pari all'altezza della porta
nRight = EgtOffsetCurveAdv( nLeft, -DGD.dH)
-- inverto la direzione
EgtInvertCurve(nRight)
end
end
end
-- lati di riferimento della porta
local nParFlip = 1
if tProbeDoor.FD > 0.5 then -- se porta flippata
if tProbeDoor.TD > 0.5 then -- se top a destra
nDoorLeft = nBase
nDoorRight = nTop
nDoorTop = nRight
nDoorBot = nLeft
else
nDoorLeft = nTop
nDoorRight = nBase
nDoorTop = nLeft
nDoorBot = nRight
end
nParFlip = -1
else -- porta non flippata
if tProbeDoor.TD > 0.5 then -- se top a destra
nDoorLeft = nTop
nDoorRight = nBase
nDoorTop = nRight
nDoorBot = nLeft
else
nDoorLeft = nBase
nDoorRight = nTop
nDoorTop = nLeft
nDoorBot = nRight
end
end
if nBase then
if abs(tProbeDoor.DR) > 0 then -- se ho la linea probase faccio l'eventuale offset e la assegno alla variabile giusta
EgtOffsetCurve( nBase, tProbeDoor.DR)
end
-- se la base è il lato sinistro
if nDoorLeft == nBase then
nDoorLeftTop = EgtCopyGlob(nBase, nLa)
nBaseTop = nDoorLeftTop
nDoorLeftMid = EgtCopyGlob(nBase, nLa)
nBaseMid = nDoorLeftMid
if sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == 'FDWC' then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
elseif sLeftType == 'BU' or sLeftType == 'BUEB' then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nDoorLeftTop, -DGD.dT * TAN3)
EgtOffsetCurve( nDoorLeftMid, -DGD.dT/2 * TAN3)
elseif sLeftType == 'BD' or sLeftType == 'BDEB' then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nBase, -DGD.dT * TAN3)
EgtOffsetCurve( nDoorLeftMid, -DGD.dT/2 * TAN3)
elseif sLeftType == '1B' or sLeftType == '2B' or sLeftType == '3B' or sLeftType == '4B' or
sLeftType == '5B' or sLeftType == '6B' or sLeftType == '7B' or sLeftType == '8B'then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nBase, -(dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))))
EgtOffsetCurve( nDoorLeftTop, -(dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))))
elseif sLeftType == 'CV' then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nDoorLeftMid, -(dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))))
end
else
nDoorRightTop = EgtCopyGlob(nBase, nLa)
nBaseTop = nDoorRightTop
nDoorRightMid = EgtCopyGlob(nBase, nLa)
nBaseMid = nDoorRightMid
if sRightType == 'SQ' or sRightType == 'EB' or sRightType == 'FDWC' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
elseif sRightType == 'BU' or sRightType == 'BUEB' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nDoorRightTop, -DGD.dT * TAN3)
EgtOffsetCurve( nDoorRightMid, -DGD.dT/2 * TAN3)
elseif sRightType == 'BD' or sRightType == 'BDEB' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nBase, -DGD.dT * TAN3)
EgtOffsetCurve( nDoorRightMid, -DGD.dT/2 * TAN3)
elseif sRightType == '1B' or sRightType == '2B' or sRightType == '3B' or sRightType == '4B' or
sRightType == '5B' or sRightType == '6B' or sRightType == '7B' or sRightType == '8B' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nBase, -(dRadProfR - sqrt( ( dRadProfR * dRadProfR) - ((DGD.dT/2)*(DGD.dT/2)))))
EgtOffsetCurve( nDoorRightTop, -(dRadProfR - sqrt((dRadProfR * dRadProfR) - ((DGD.dT/2)*(DGD.dT/2)))))
elseif sRightType == 'CV' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nDoorRightMid, -(dRadProfR - sqrt((dRadProfR * dRadProfR) - ((DGD.dT/2)*(DGD.dT/2)))))
end
end
end
if nTop then
if abs(tProbeDoor.DO) > 0 then -- se ho la linea probase faccio l'eventuale offset e la assegno alla variabile giusta
EgtOffsetCurve( nTop, tProbeDoor.DO)
end
-- se il lato top è il lato sinistro
if nDoorLeft == nTop then
nDoorLeftTop = EgtCopyGlob(nTop, nLa)
nTopTop = nDoorLeftTop
nDoorLeftMid = EgtCopyGlob(nTop, nLa)
nTopMid = nDoorLeftMid
if sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == 'FDWC' then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
elseif sLeftType == 'BU' or sLeftType == 'BUEB' then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nDoorLeftTop, -DGD.dT * TAN3)
EgtOffsetCurve( nDoorLeftMid, -DGD.dT/2 * TAN3)
elseif sLeftType == 'BD' or sLeftType == 'BDEB' then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nTop, -DGD.dT * TAN3)
EgtOffsetCurve( nDoorLeftMid, -DGD.dT/2 * TAN3)
elseif sLeftType == '1B' or sLeftType == '2B' or sLeftType == '3B' or sLeftType == '4B' or
sLeftType == '5B' or sLeftType == '6B' or sLeftType == '7B' or sLeftType == '8B' then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nTop, -(dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))))
EgtOffsetCurve( nDoorLeftTop, -(dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))))
elseif sLeftType == 'CV' then
EgtMove( nDoorLeftTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorLeftMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nDoorLeftMid, -(dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))))
end
else
nDoorRightTop = EgtCopyGlob(nTop, nLa)
nTopTop = nDoorRightTop
nDoorRightMid = EgtCopyGlob(nTop, nLa)
nTopMid = nDoorRightMid
if sRightType == 'SQ' or sRightType == 'EB' or sRightType == 'FDWC' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
elseif sRightType == 'BU' or sRightType == 'BUEB' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nDoorRightTop, -DGD.dT * TAN3)
EgtOffsetCurve( nDoorRightMid, -DGD.dT/2 * TAN3)
elseif sRightType == 'BD' or sRightType == 'BDEB' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nTop, -DGD.dT * TAN3)
EgtOffsetCurve( nDoorRightMid, -DGD.dT/2 * TAN3)
elseif sRightType == '1B' or sRightType == '2B' or sRightType == '3B' or sRightType == '4B' or
sRightType == '5B' or sRightType == '6B' or sRightType == '7B' or sRightType == '8B' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nTop, -(dRadProfR - sqrt( ( dRadProfR * dRadProfR) - ((DGD.dT/2)*(DGD.dT/2)))))
EgtOffsetCurve( nDoorRightTop, -(dRadProfR - sqrt((dRadProfR * dRadProfR) - ((DGD.dT/2)*(DGD.dT/2)))))
elseif sRightType == 'CV' then
EgtMove( nDoorRightTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorRightMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
EgtOffsetCurve( nDoorRightMid, -(dRadProfR - sqrt((dRadProfR * dRadProfR) - ((DGD.dT/2)*(DGD.dT/2)))))
end
end
end
if nLeft then
-- se il lato sinistro è il top
if nDoorTop == nLeft then
nDoorTopTop = EgtCopyGlob(nLeft, nLa)
nLeftTop = nDoorTopTop
nDoorTopMid = EgtCopyGlob(nLeft, nLa)
nLeftMid = nDoorTopMid
EgtMove( nDoorTopTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorTopMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
else
nDoorBotTop = EgtCopyGlob(nLeft, nLa)
nLeftTop = nDoorBotTop
nDoorBotMid = EgtCopyGlob(nLeft, nLa)
nLeftMid = nDoorBotMid
EgtMove( nDoorBotTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorBotMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
end
end
if nRight then
-- se il lato sinistro è il bottom
if nDoorBot == nRight then
nDoorBotTop = EgtCopyGlob(nRight, nLa)
nRightTop = nDoorBotTop
nDoorBotMid = EgtCopyGlob(nRight, nLa)
nRightMid = nDoorBotMid
EgtMove( nDoorBotTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorBotMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
else
nDoorTopTop = EgtCopyGlob(nRight, nLa)
nRightTop = nDoorTopTop
nDoorTopMid = EgtCopyGlob(nRight, nLa)
nRightMid = nDoorTopMid
EgtMove( nDoorTopTop, ORIG() + Point3d(0,0,(nParFlip*DGD.dT)), GDB_RT.GRID)
EgtMove( nDoorTopMid, ORIG() + Point3d(0,0,(nParFlip*DGD.dT/2)), GDB_RT.GRID)
end
end
-- estendo le linee per creare i quadrilateri di base, medio e top
if nRight and nBase then -- base con destra
EgtTrimExtendCurveByLen( nBase,dDistToExtX,EgtEP(nBase))
EgtTrimExtendCurveByLen( nRight,dDistToExtY,EgtSP(nRight))
local nIdDel = EgtSplitCurveAtPoint( nBase, EgtIP(nBase,nRight,EgtEP(nBase)))
EgtErase(nIdDel)
nIdDel = nRight
nRight = EgtSplitCurveAtPoint( nRight, EgtEP(nBase))
EgtErase(nIdDel)
end
if nRightMid and nBaseMid then -- base con destra mid
EgtTrimExtendCurveByLen( nBaseMid,dDistToExtX,EgtEP(nBaseMid))
EgtTrimExtendCurveByLen( nRightMid,dDistToExtY,EgtSP(nRightMid))
local nIdDel = EgtSplitCurveAtPoint( nBaseMid, EgtIP(nBaseMid,nRightMid,EgtEP(nBaseMid)))
EgtErase(nIdDel)
nIdDel = nRightMid
nRightMid = EgtSplitCurveAtPoint( nRightMid, EgtEP(nBaseMid))
EgtErase(nIdDel)
end
if nRightTop and nBaseTop then -- base con destra top
EgtTrimExtendCurveByLen( nBaseTop,dDistToExtX,EgtEP(nBaseTop))
EgtTrimExtendCurveByLen( nRightTop,dDistToExtY,EgtSP(nRightTop))
local nIdDel = EgtSplitCurveAtPoint( nBaseTop, EgtIP(nBaseTop,nRightTop,EgtEP(nBaseTop)))
EgtErase(nIdDel)
nIdDel = nRightTop
nRightTop = EgtSplitCurveAtPoint( nRightTop, EgtEP(nBaseTop))
EgtErase(nIdDel)
end
if nLeft and nBase then -- base con sinistra
EgtTrimExtendCurveByLen( nBase,dDistToExtX,EgtSP(nBase))
EgtTrimExtendCurveByLen( nLeft,dDistToExtY, EgtEP(nLeft))
local nIdDel = nBase
nBase = EgtSplitCurveAtPoint( nBase, EgtIP(nBase,nLeft,EgtSP(nBase)))
EgtErase(nIdDel)
nIdDel = EgtSplitCurveAtPoint( nLeft, EgtSP(nBase))
EgtErase(nIdDel)
end
if nLeftMid and nBaseMid then -- base con sinistra mid
EgtTrimExtendCurveByLen( nBaseMid,dDistToExtX,EgtSP(nBaseMid))
EgtTrimExtendCurveByLen( nLeftMid,dDistToExtY, EgtEP(nLeftMid))
local nIdDel = nBaseMid
nBaseMid = EgtSplitCurveAtPoint( nBaseMid, EgtIP(nBaseMid,nLeftMid,EgtSP(nBaseMid)))
EgtErase(nIdDel)
nIdDel = EgtSplitCurveAtPoint( nLeftMid, EgtSP(nBaseMid))
EgtErase(nIdDel)
end
if nLeftTop and nBaseTop then -- base con sinistra top
EgtTrimExtendCurveByLen( nBaseTop,dDistToExtX,EgtSP(nBaseTop))
EgtTrimExtendCurveByLen( nLeftTop,dDistToExtY, EgtEP(nLeftTop))
local nIdDel = nBaseTop
nBaseTop = EgtSplitCurveAtPoint( nBaseTop, EgtIP(nBaseTop,nLeftTop,EgtSP(nBaseTop)))
EgtErase(nIdDel)
nIdDel = EgtSplitCurveAtPoint( nLeftTop, EgtSP(nBaseTop))
EgtErase(nIdDel)
end
if nRight and nTop then -- top con destra
EgtTrimExtendCurveByLen( nTop,dDistToExtX,EgtSP(nTop))
EgtTrimExtendCurveByLen( nRight,dDistToExtY, EgtEP(nRight))
local nIdDel = nTop
nTop = EgtSplitCurveAtPoint( nTop, EgtIP(nTop,nRight,EgtSP(nTop)))
EgtErase(nIdDel)
nIdDel = EgtSplitCurveAtPoint( nRight, EgtSP(nTop))
EgtErase(nIdDel)
end
if nRightMid and nTopMid then -- top con destra mid
EgtTrimExtendCurveByLen( nTopMid,dDistToExtX,EgtSP(nTopMid))
EgtTrimExtendCurveByLen( nRightMid,dDistToExtY, EgtEP(nRightMid))
local nIdDel = nTopMid
nTopMid = EgtSplitCurveAtPoint( nTopMid, EgtIP(nTopMid,nRightMid,EgtSP(nTopMid)))
EgtErase(nIdDel)
nIdDel = EgtSplitCurveAtPoint( nRightMid, EgtSP(nTopMid))
EgtErase(nIdDel)
end
if nRightTop and nTopTop then -- top con destra top
EgtTrimExtendCurveByLen( nTopTop,dDistToExtX,EgtSP(nTopTop))
EgtTrimExtendCurveByLen( nRightTop,dDistToExtY, EgtEP(nRightTop))
local nIdDel = nTopTop
nTopTop = EgtSplitCurveAtPoint( nTopTop, EgtIP(nTopTop,nRightTop,EgtSP(nTopTop)))
EgtErase(nIdDel)
nIdDel = EgtSplitCurveAtPoint( nRightTop, EgtSP(nTopTop))
EgtErase(nIdDel)
end
if nLeft and nTop then -- top con sinistra
EgtTrimExtendCurveByLen( nTop,dDistToExtX,EgtEP(nTop))
EgtTrimExtendCurveByLen( nLeft,dDistToExtY, EgtSP(nLeft))
local nIdDel = EgtSplitCurveAtPoint( nTop, EgtIP(nTop,nLeft,EgtEP(nTop)))
EgtErase(nIdDel)
nIdDel = nLeft
nLeft = EgtSplitCurveAtPoint( nLeft, EgtEP(nTop))
EgtErase(nIdDel)
end
if nLeftMid and nTopMid then -- top con sinistra mid
EgtTrimExtendCurveByLen( nTopMid,dDistToExtX,EgtEP(nTopMid))
EgtTrimExtendCurveByLen( nLeftMid,dDistToExtY, EgtSP(nLeftMid))
local nIdDel = EgtSplitCurveAtPoint( nTopMid, EgtIP(nTopMid,nLeftMid,EgtEP(nTopMid)))
EgtErase(nIdDel)
nIdDel = nLeftMid
nLeftMid = EgtSplitCurveAtPoint( nLeftMid, EgtEP(nTopMid))
EgtErase(nIdDel)
end
if nLeftTop and nTopTop then -- top con sinistra top
EgtTrimExtendCurveByLen( nTopTop,dDistToExtX,EgtEP(nTopTop))
EgtTrimExtendCurveByLen( nLeftTop,dDistToExtY, EgtSP(nLeftTop))
local nIdDel = EgtSplitCurveAtPoint( nTopTop, EgtIP(nTopTop,nLeftTop,EgtEP(nTopTop)))
EgtErase(nIdDel)
nIdDel = nLeftTop
nLeftTop = EgtSplitCurveAtPoint( nLeftTop, EgtEP(nTopTop))
EgtErase(nIdDel)
end
if tProbeDoor.FD > 0.5 then -- se porta flippata
-- dopo rotazione il giro è orario
EgtRotate( {nBase,nRight,nTop,nLeft} , ORIG(), X_AX(), 180 )
EgtRotate( {nBaseMid,nRightMid,nTopMid,nLeftMid} , ORIG(), X_AX(), 180 )
EgtRotate( {nBaseTop,nRightTop,nTopTop,nLeftTop} , ORIG(), X_AX(), 180 )
if tProbeDoor.TD > 0.5 then -- se top a destra
EgtRotate( {nBase,nRight,nTop,nLeft} , ORIG(), Z_AX(), 90 )
EgtRotate( {nBaseMid,nRightMid,nTopMid,nLeftMid} , ORIG(), Z_AX(), 90 )
EgtRotate( {nBaseTop,nRightTop,nTopTop,nLeftTop} , ORIG(), Z_AX(), 90 )
nDoorLeft = nBase
nDoorRight = nTop
nDoorTop = nRight
nDoorBot = nLeft
nDoorLeftMid = nBaseMid
nDoorRightMid = nTopMid
nDoorTopMid = nRightMid
nDoorBotMid = nLeftMid
nDoorLeftTop = nBaseTop
nDoorRightTop = nTopTop
nDoorTopTop = nRightTop
nDoorBotTop = nLeftTop
else
EgtRotate( {nBase,nRight,nTop,nLeft} , ORIG(), Z_AX(), -90 )
EgtRotate( {nBaseMid,nRightMid,nTopMid,nLeftMid} , ORIG(), Z_AX(), -90 )
EgtRotate( {nBaseTop,nRightTop,nTopTop,nLeftTop} , ORIG(), Z_AX(), -90 )
nDoorLeft = nTop
nDoorRight = nBase
nDoorTop = nLeft
nDoorBot = nRight
nDoorLeftMid = nTopMid
nDoorRightMid = nBaseMid
nDoorTopMid = nLeftMid
nDoorBotMid = nRightMid
nDoorLeftTop = nTopTop
nDoorRightTop = nBaseTop
nDoorTopTop = nLeftTop
nDoorBotTop = nRightTop
end
else -- porta non flippata
--inverto la direzione delle entità per avere giro orario
EgtInvertCurve({nBase,nRight,nTop,nLeft})
EgtInvertCurve({nBaseMid,nRightMid,nTopMid,nLeftMid})
EgtInvertCurve({nBaseTop,nRightTop,nTopTop,nLeftTop})
if tProbeDoor.TD > 0.5 then -- se top a destra
EgtRotate( {nBase,nRight,nTop,nLeft} , ORIG(), Z_AX(), 90 )
EgtRotate( {nBaseMid,nRightMid,nTopMid,nLeftMid} , ORIG(), Z_AX(), 90 )
EgtRotate( {nBaseTop,nRightTop,nTopTop,nLeftTop} , ORIG(), Z_AX(), 90 )
nDoorLeft = nTop
nDoorRight = nBase
nDoorTop = nRight
nDoorBot = nLeft
nDoorLeftMid = nTopMid
nDoorRightMid = nBaseMid
nDoorTopMid = nRightMid
nDoorBotMid = nLeftMid
nDoorLeftTop = nTopTop
nDoorRightTop = nBaseTop
nDoorTopTop = nRightTop
nDoorBotTop = nLeftTop
else
EgtRotate( {nBase,nRight,nTop,nLeft} , ORIG(), Z_AX(), -90 )
EgtRotate( {nBaseMid,nRightMid,nTopMid,nLeftMid} , ORIG(), Z_AX(), -90 )
EgtRotate( {nBaseTop,nRightTop,nTopTop,nLeftTop} , ORIG(), Z_AX(), -90 )
nDoorLeft = nBase
nDoorRight = nTop
nDoorTop = nLeft
nDoorBot = nRight
nDoorLeftMid = nBaseMid
nDoorRightMid = nTopMid
nDoorTopMid = nLeftMid
nDoorBotMid = nRightMid
nDoorLeftTop = nBaseTop
nDoorRightTop = nTopTop
nDoorTopTop = nLeftTop
nDoorBotTop = nRightTop
end
end
EgtSetName (nDoorLeft, 'Left')
EgtSetName (nDoorRight, 'Right')
EgtSetName (nDoorTop, 'Top')
EgtSetName (nDoorBot, 'Bottom')
EgtSetName (nDoorLeftMid, 'LeftMid')
EgtSetName (nDoorRightMid, 'RightMid')
EgtSetName (nDoorTopMid, 'TopMid')
EgtSetName (nDoorBotMid, 'BottomMid')
EgtSetName (nDoorLeftTop, 'LeftTop')
EgtSetName (nDoorRightTop, 'RightTop')
EgtSetName (nDoorTopTop, 'TopTop')
EgtSetName (nDoorBotTop, 'BottomTop')
-- Per ogni quadrilatero Prendo i 4 punti base e le direzioni relative che definiranno la porta
DGD.P1=EgtEP( nDoorBotTop, GDB_RT.GLOB)
DGD.P2=EgtEP( nDoorRightTop, GDB_RT.GLOB)
DGD.P3=EgtEP( nDoorRight, GDB_RT.GLOB)
DGD.P4=EgtEP( nDoorBot, GDB_RT.GLOB)
DGD.P5=EgtEP( nDoorBotMid, GDB_RT.GLOB)
DGD.P6=EgtEP( nDoorRightMid, GDB_RT.GLOB)
DGD.P7=EgtEP( nDoorLeftTop, GDB_RT.GLOB)
DGD.P8=EgtEP( nDoorTopTop, GDB_RT.GLOB)
DGD.P9=EgtEP( nDoorTop, GDB_RT.GLOB)
DGD.P10=EgtEP( nDoorLeft, GDB_RT.GLOB)
DGD.P11=EgtEP( nDoorLeftMid, GDB_RT.GLOB)
DGD.P12=EgtEP( nDoorTopMid, GDB_RT.GLOB)
if sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == '1B' or sLeftType == '2B' or sLeftType == '3B' or
sLeftType == '4B' or sLeftType == '5B' or sLeftType == '6B' or sLeftType == '7B' or sLeftType == '8B' or
sLeftType == 'FDWC' then
DGD.PminBot = DGD.P5
DGD.PminTop = DGD.P11
elseif sLeftType == 'BU' or sLeftType == 'BUEB' or sLeftType == 'CV' then
DGD.PminBot = DGD.P4
DGD.PminTop = DGD.P10
elseif sLeftType == 'BD' or sLeftType == 'BDEB' then
DGD.PminBot = DGD.P1
DGD.PminTop = DGD.P7
end
if sRightType == 'SQ' or sRightType == 'EB' or sRightType == '1B' or sRightType == '2B' or sRightType == '3B' or
sRightType == '4B' or sRightType == '5B' or sRightType == '6B' or sRightType == '7B' or sRightType == '8B' or
sRightType == 'FDWC' then
DGD.PmaxBot = DGD.P6
DGD.PmaxTop = DGD.P12
elseif sRightType == 'BU' or sRightType == 'BUEB' or sRightType == 'CV' then
DGD.PmaxBot = DGD.P3
DGD.PmaxTop = DGD.P9
elseif sRightType == 'BD' or sRightType == 'BDEB' then
DGD.PmaxBot = DGD.P2
DGD.PmaxTop = DGD.P8
end
local vDirEnt = EgtSV(nDoorBot)
DGD.A1=atan(vDirEnt:getY(),vDirEnt:getX())
DGD.A2=DGD.A1+180
DGD.L1=EgtCurveLength( nDoorBot)
DGD.L1Top=EgtCurveLength( nDoorBotTop)
vDirEnt = EgtSV(nDoorLeft)
DGD.A3=atan(vDirEnt:getY(),vDirEnt:getX())
DGD.A4=DGD.A3+180
DGD.L2=EgtCurveLength( nDoorLeft)
DGD.L2Top=EgtCurveLength( nDoorLeftTop)
vDirEnt = EgtSV(nDoorTop)
DGD.A5=atan(vDirEnt:getY(),vDirEnt:getX())
DGD.A6=DGD.A5+180
DGD.L3=EgtCurveLength( nDoorTop)
DGD.L3Top=EgtCurveLength( nDoorTopTop)
vDirEnt = EgtSV(nDoorRight)
DGD.A7=atan(vDirEnt:getY(),vDirEnt:getX())
DGD.A8=DGD.A7+180
DGD.L4=EgtCurveLength( nDoorRight)
DGD.L4Top=EgtCurveLength( nDoorRightTop)
-- errato calcolo: prende le ipotenuse di maggior lunghezza e larghezza e non i box
-- calcolo le dimensioni della porta
-- local dLungMax = max ( sqrt( ( DGD.PmaxBot[1] - DGD.PmaxTop[1]) * ( DGD.PmaxBot[1] - DGD.PmaxTop[1]) +
-- ( DGD.PmaxBot[2] - DGD.PmaxTop[2]) * ( DGD.PmaxBot[2] - DGD.PmaxTop[2])),
-- sqrt( ( DGD.PminBot[1] - DGD.PminTop[1]) * ( DGD.PminBot[1] - DGD.PminTop[1]) +
-- ( DGD.PminBot[2] - DGD.PminTop[2]) * ( DGD.PminBot[2] - DGD.PminTop[2])))
--
-- local dLarghMax = max ( sqrt( ( DGD.PmaxBot[1] - DGD.PminBot[1]) * ( DGD.PmaxBot[1] - DGD.PminBot[1]) +
-- ( DGD.PmaxBot[2] - DGD.PminBot[2]) * ( DGD.PmaxBot[2] - DGD.PminBot[2])),
-- sqrt( ( DGD.PmaxTop[1] - DGD.PminTop[1]) * ( DGD.PmaxTop[1] - DGD.PminTop[1]) +
-- ( DGD.PmaxTop[2] - DGD.PminTop[2]) * ( DGD.PmaxTop[2] - DGD.PminTop[2])))
local dLungMax = max ( DGD.PmaxTop[2], DGD.PminTop[2]) - min( DGD.PmaxBot[2], DGD.PminBot[2])
local dLarghMax = max ( DGD.PmaxTop[1], DGD.PmaxBot[1]) - min( DGD.PminTop[1], DGD.PminBot[1])
-- Sposto tutte e 4 le geometrie nel primo quadrante
-- EgtMove( {nBase,nRight,nTop,nLeft}, ORIG() - EgtSP(nDoorLeft), GDB_RT.GRID)
-- allineo il lato sinistro con la Y
-- local vDirLeft = EgtSV( nDoorLeft)
-- EgtRotate( {nBase,nRight,nTop,nLeft} , ORIG(), Z_AX(), atan(vDirLeft:getX()/vDirLeft:getY()) )
-- ritorno le dimensioni calcolate
return dLungMax, dLarghMax
end
-----------------------------------------------------------------
local function MakeSurfProfiles( nParLay, sBotType, dRadProfB, sRghtType, dRadProfR,
sTopType, dRadProfT, sLftType, dRadProfL, sSideName,
dPlnProfB, dPlnProfR, dPlnProfT, dPlnProf)
-- setto variabili che indicano se i profili sono compatibili
local bJoinRgt = true
local bJoinLft = true
local bDelete = true
-- profilo superiore
local nTopPath, nToptSezPath, ptMedArc
-- creo curva superiore
if DGD.tProfs.top.radius then
-- se ci sono tangenze con profili diversi verifico se concatenare la swept superiore
if DGD.TPR then
if sTopType == 'BD' or sTopType == 'BDEB' or sTopType == 'BU' or sTopType == 'BUEB' then
if sRghtType == 'SQ' or sRghtType == 'EB' or sRightType == 'FDWC' then
bJoinRgt = false
elseif sRghtType == '1B' or sRghtType == '2B' or sRghtType == '3B' or sRghtType == '4B' or
sRghtType == '5B' or sRghtType == '6B' or sRghtType == '7B' or sRghtType == '8B' then
bJoinRgt = true
elseif sRghtType == 'CV' then
bJoinRgt = false
end
elseif sTopType == '1B' or sTopType == '2B' or sTopType == '3B' or sTopType == '4B' or
sTopType == '5B' or sTopType == '6B' or sTopType == '7B' or sTopType == '8B' then
if sRghtType == '1B' or sRghtType == '2B' or sRghtType == '3B' or sRghtType == '4B' or
sRghtType == '5B' or sRghtType == '6B' or sRghtType == '7B' or sRghtType == '8B' then
-- tolgo di mezzo il B e confronto i numeri
local sNumProfTop = sTopType:gsub( 'B', '')
local sNumProfSide = sRghtType:gsub( 'B', '')
local nNumProfTop = tonumber(sNumProfTop)
local nNumProfSide = tonumber(sNumProfSide)
if nNumProfTop < nNumProfSide then
bJoinRgt = false
end
elseif sRghtType == 'BD' or sRghtType == 'BDEB' or sRghtType == 'BU' or sRghtType == 'BUEB' then
bJoinRgt = false
elseif sRghtType == 'CV' or sRghtType == 'SQ' or sRghtType == 'EB' or sRightType == 'FDWC' then
bJoinRgt = false
end
elseif sTopType == 'CV' then
if sRghtType == 'BD' or sRghtType == 'BDEB' or sRghtType == 'BU' or sRghtType == 'BUEB' then
bJoinRgt = false
elseif sRghtType == '1B' or sRghtType == '2B' or sRghtType == '3B' or sRghtType == '4B' or
sRghtType == '5B' or sRghtType == '6B' or sRghtType == '7B' or sRghtType == '8B' then
bJoinRgt = false
end
end
end
if DGD.TPL then
if sTopType == 'BD' or sTopType == 'BDEB' or sTopType == 'BU' or sTopType == 'BUEB' then
if sLftType == 'SQ' or sLftType == 'EB' or sLftType == 'FDWC' then
bJoinLft = false
elseif sLftType == '1B' or sLftType == '2B' or sLftType == '3B' or sLftType == '4B' or
sLftType == '5B' or sLftType == '6B' or sLftType == '7B' or sLftType == '8B' then
bJoinLft = true
elseif sLftType == 'CV' then
bJoinLft = false
end
elseif sTopType == '1B' or sTopType == '2B' or sTopType == '3B' or sTopType == '4B' or
sTopType == '5B' or sTopType == '6B' or sTopType == '7B' or sTopType == '8B' then
if sLftType == '1B' or sLftType == '2B' or sLftType == '3B' or sLftType == '4B' or
sLftType == '5B' or sLftType == '6B' or sLftType == '7B' or sLftType == '8B' then
-- tolgo di mezzo il B e confronto i numeri
local sNumProfTop = sTopType:gsub( 'B', '')
local sNumProfSide = sLftType:gsub( 'B', '')
local nNumProfTop = tonumber(sNumProfTop)
local nNumProfSide = tonumber(sNumProfSide)
if nNumProfTop < nNumProfSide then
bJoinLft = false
end
elseif sLftType == 'BD' or sLftType == 'BDEB' or sLftType == 'BU' or sLftType == 'BUEB' then
bJoinLft = false
elseif sLftType == 'CV' or sLftType == 'SQ' or sLftType == 'EB' or sLftType == 'FDWC' then
bJoinLft = false
end
elseif sTopType == 'CV' then
if sLftType == 'BD' or sLftType == 'BDEB' or sLftType == 'BU' or sLftType == 'BUEB' then
bJoinLft = false
elseif sLftType == '1B' or sLftType == '2B' or sLftType == '3B' or sLftType == '4B' or
sLftType == '5B' or sLftType == '6B' or sLftType == '7B' or sLftType == '8B' then
bJoinLft = false
end
end
end
-- Arco top
nTopPath = EgtArcC2P( nParLay, {((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Dra},
{ DGD.RMa, DGD.AMr, DGD.Dra}, { DGD.LMa, DGD.AMl, DGD.Dla}, GDB_RT.GLOB) -- arco max
local vcIni = EgtSV(nTopPath)
EgtErase(nTopPath)
nTopPath = EgtArc2PV( nParLay, { DGD.RMa, DGD.AMr, DGD.Dra}, { DGD.LMa, DGD.AMl, DGD.Dla}, vcIni, GDB_RT.GLOB)
ptMedArc = EgtMP(nTopPath)
if not DGD.TPR then -- se non ho tangenza a destra allungo il percorso
local dDistY = abs((DGD.dH-DGD.tProfs.top.ydeltapos) - DGD.AMr)
if dDistY > 50.8 then
EgtTrimExtendCurveByLen( nTopPath, 50.8 , { DGD.RMa, DGD.AMr, DGD.Dra})
else
EgtTrimExtendCurveByLen( nTopPath, dDistY*1.1 , { DGD.RMa, DGD.AMr, DGD.Dra})
end
end
if not DGD.TPL then -- se non ho tangenza a sinistra allungo il percorso
local dDistY = abs((DGD.dH-DGD.tProfs.top.ydeltapos) - DGD.AMl)
if dDistY > 50.8 then
EgtTrimExtendCurveByLen( nTopPath, 50.8 , { DGD.LMa, DGD.AMl, DGD.Dla})
else
EgtTrimExtendCurveByLen( nTopPath, dDistY*1.1 , { DGD.LMa, DGD.AMl, DGD.Dla})
end
end
elseif DGD.Tpa then
if DGD.tProfs.top.xdeltapos > 0 then
local nE1 = EgtLine( nParLay, {DGD.Rua,DGD.Aur,DGD.Dra}, {DGD.Cmu,DGD.Aut,DGD.Dla}, GDB_RT.GLOB) -- p14 a p19
local nE2 = EgtLine( nParLay, {DGD.Cmu,DGD.Aut,DGD.Dla}, {DGD.Lua,DGD.Aul,DGD.Dla}, GDB_RT.GLOB) -- p19 a p13
nTopPath = EgtCurveCompo( nParLay, {nE1,nE2}, true)
else
nTopPath = EgtLine( nParLay, {DGD.Rua,DGD.Aur,DGD.Dra}, {DGD.Lua,DGD.Aul,DGD.Dla}, GDB_RT.GLOB) -- p14 a p13
end
EgtTrimExtendCurveByLen( nTopPath, DGD.dW/4, {DGD.Rua,DGD.Aur,DGD.Dra})
EgtTrimExtendCurveByLen( nTopPath, DGD.dW/4, {DGD.Lua,DGD.Aul,DGD.Dla})
else
nTopPath = EgtLine( nParLay, {DGD.Rut,DGD.Tur,DGD.Drt}, {DGD.Lut,DGD.Tul,DGD.Dlt}, GDB_RT.GLOB) -- p8 a p7
EgtTrimExtendCurveByLen( nTopPath, DGD.dW/4, {DGD.Rut,DGD.Tur,DGD.Drt})
EgtTrimExtendCurveByLen( nTopPath, DGD.dW/4, {DGD.Lut,DGD.Tul,DGD.Dlt})
end
-- prendo il versore iniziale
local vIni = EgtSV( nTopPath, GDB_RT.GLOB)
local pIni = EgtSP( nTopPath, GDB_RT.GLOB)
-- griglia locale
EgtSetGridFrame( Frame3d( pIni, vIni))
if sTopType == 'BD' or sTopType == 'BDEB' then
-- profilo sezione
nToptSezPath = EgtLine ( nParLay, {(DGD.dT*TAN3),0,0}, {0,DGD.dT,0}, GDB_RT.GRID)
elseif sTopType == 'BU' or sTopType == 'BUEB' then
if DGD.tProfs.top.radius then
-- profilo sezione
nToptSezPath = EgtLine ( nParLay, {0,0,0}, {(DGD.dT*TAN3),DGD.dT,0}, GDB_RT.GRID)
else
-- profilo sezione
nToptSezPath = EgtLine ( nParLay, {-(DGD.dT*TAN3),0,0}, {0,DGD.dT,0}, GDB_RT.GRID)
end
elseif sTopType == '1B' or sTopType == '2B' or sTopType == '3B' or sTopType == '4B' or
sTopType == '5B' or sTopType == '6B' or sTopType == '7B' or sTopType == '8B' then
local dDeltaPos = dRadProfT - sqrt( ( dRadProfT * dRadProfT) - ((DGD.dT/2)*(DGD.dT/2)))
if DGD.tProfs.top.radius then
-- profilo sezione
nToptSezPath = EgtArc3P( nParLay, {dDeltaPos,0,0}, {0,DGD.dT/2,0}, {dDeltaPos,DGD.dT,0}, GDB_RT.GRID)
else
-- profilo sezione
nToptSezPath = EgtArc3P( nParLay, {0,0,0}, {-dDeltaPos,DGD.dT/2,0}, {0,DGD.dT,0}, GDB_RT.GRID)
end
elseif sTopType == 'CV' then
local dDeltaPos = dRadProfT - sqrt( ( dRadProfT * dRadProfT) - (((DGD.dT/2)-dPlnProfT)*((DGD.dT/2)-dPlnProfT)))
-- profilo sezione
if dPlnProfT > 0 then
local nLine1, nLine2, nArc
nLine1 = EgtLine ( nParLay, {0,0,0}, {0,dPlnProfT,0}, GDB_RT.GRID)
nArc = EgtArc3P( nParLay, {0,dPlnProfT,0}, {dDeltaPos,DGD.dT/2,0}, {0,DGD.dT-dPlnProfT,0}, GDB_RT.GRID)
nLine2 = EgtLine ( nParLay, {0,DGD.dT-dPlnProfT,0}, {0,DGD.dT,0}, GDB_RT.GRID)
nToptSezPath = EgtCurveCompo( nParLay, {nLine1,nArc,nLine2}, true)
else
nToptSezPath = EgtArc3P( nParLay, {0,0,0}, {dDeltaPos,DGD.dT/2,0}, {0,DGD.dT,0}, GDB_RT.GRID)
end
else -- profilo SQ o FDWC
-- profilo sezione
nToptSezPath = EgtLine ( nParLay, {0,0,0}, {0,DGD.dT,0}, GDB_RT.GRID)
end
-- disegno le swept sopra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
local nSwT = EgtSurfTmSwept( nParLay, nToptSezPath, nTopPath,false, 0.05)
-------------------------------
-- semi-profili inferiori
-------------------------------
local nBotPath, nBotPath2, nBotPathL, nBotPathR, nBotSezPath
-- griglia a sinistra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.LEFT))
if sBotType == 'BD' or sBotType == 'BDEB' then
-- profilo sezione
nBotSezPath = EgtLine ( nParLay, {-(DGD.dT*TAN3),0,0}, {0,DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nBotPathL = EgtLine ( nParLay, {-(DGD.dW/4),(DGD.dT*TAN3),0}, {(DGD.dW/2),(DGD.dT*TAN3),0}, GDB_RT.GRID)
nBotPathR = EgtLine ( nParLay, {(DGD.dW/2),(DGD.dT*TAN3),0}, {(DGD.dW*1.25),(DGD.dT*TAN3),0}, GDB_RT.GRID)
elseif sBotType == 'BU' or sBotType == 'BUEB' then
-- profilo sezione
nBotSezPath = EgtLine ( nParLay, {0,0,0}, {-(DGD.dT*TAN3),DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nBotPathL = EgtLine ( nParLay, {-(DGD.dW/4),0,0}, {(DGD.dW/2),0,0}, GDB_RT.GRID)
nBotPathR = EgtLine ( nParLay, {(DGD.dW/2),0,0}, {(DGD.dW*1.25),0,0}, GDB_RT.GRID)
elseif sBotType == '1B' or sBotType == '2B' or sBotType == '3B' or sBotType == '4B' or
sBotType == '5B' or sBotType == '6B' or sBotType == '7B' or sBotType == '8B' then
local dDeltaPos = dRadProfB - sqrt( ( dRadProfB * dRadProfB) - ((DGD.dT/2)*(DGD.dT/2)))
-- profilo sezione
nBotSezPath = EgtArc3P( nParLay, {-dDeltaPos,0,0}, {0,DGD.dT/2,0}, {-dDeltaPos,DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nBotPathL = EgtLine ( nParLay, {-(DGD.dW/4),dDeltaPos,0}, {(DGD.dW/2),dDeltaPos,0}, GDB_RT.GRID)
nBotPathR = EgtLine ( nParLay, {(DGD.dW/2),dDeltaPos,0}, {(DGD.dW*1.25),dDeltaPos,0}, GDB_RT.GRID)
elseif sBotType == 'CV' then
local dDeltaPos = dRadProfB - sqrt( ( dRadProfB * dRadProfB) - (((DGD.dT/2)-dPlnProfB)*((DGD.dT/2)-dPlnProfB)))
-- profilo sezione
if dPlnProfB > 0 then
local nLine1, nLine2, nArc
nLine1 = EgtLine ( nParLay, {0,0,0}, {0,dPlnProfB,0}, GDB_RT.GRID)
nArc = EgtArc3P( nParLay, {0,dPlnProfB,0}, {-dDeltaPos,DGD.dT/2,0}, {0,DGD.dT-dPlnProfB,0}, GDB_RT.GRID)
nLine2 = EgtLine ( nParLay, {0,DGD.dT-dPlnProfB,0}, {0,DGD.dT,0}, GDB_RT.GRID)
nBotSezPath = EgtCurveCompo( nParLay, {nLine1,nArc,nLine2}, true)
else
nBotSezPath = EgtArc3P( nParLay, {0,0,0}, {-dDeltaPos,DGD.dT/2,0}, {0,DGD.dT,0}, GDB_RT.GRID)
end
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nBotPathL = EgtLine ( nParLay, {-(DGD.dW/4),0,0}, {(DGD.dW/2),0,0}, GDB_RT.GRID)
nBotPathR = EgtLine ( nParLay, {(DGD.dW/2),0,0}, {(DGD.dW*1.25),0,0}, GDB_RT.GRID)
else -- profilo SQ o FDWC
-- profilo sezione
nBotSezPath = EgtLine ( nParLay, {0,0,0}, {0,DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nBotPathL = EgtLine ( nParLay, {-(DGD.dW/4),0,0}, {(DGD.dW/2),0,0}, GDB_RT.GRID)
nBotPathR = EgtLine ( nParLay, {(DGD.dW/2),0,0}, {(DGD.dW*1.25),0,0}, GDB_RT.GRID)
end
-- disegno le swept inferiori
local nSwBL, nSwBR
nSwBL = EgtSurfTmSwept( nParLay, nBotSezPath, nBotPathL,false, 0.05)
nSwBR = EgtSurfTmSwept( nParLay, nBotSezPath, nBotPathR,false, 0.05)
-- profilo destro
local nRghtPath, nRghtSezPath
-- griglia in fronte
EgtSetGridFrame( Frame3d( DGD.dW,0,0, GDB_FR.FRONT))
if sRghtType == 'BD' or sRghtType == 'BDEB' then
-- profilo sezione
nRghtSezPath = EgtLine ( nParLay, {-(DGD.dT*TAN3),0,0}, {0,DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nRghtPath = EgtLine ( nParLay, {DGD.dW,-(DGD.dH*0.25),0}, {DGD.dW,(DGD.dH*1.25),0}, GDB_RT.GRID)
elseif sRghtType == 'BU' or sRghtType == 'BUEB' then
-- profilo sezione
nRghtSezPath = EgtLine ( nParLay, {0,0,0}, {-(DGD.dT*TAN3),DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nRghtPath = EgtLine ( nParLay, {DGD.dW-(DGD.dT*TAN3),-(DGD.dH*0.25),0}, {DGD.dW-(DGD.dT*TAN3),(DGD.dH*1.25),0}, GDB_RT.GRID)
elseif sRghtType == '1B' or sRghtType == '2B' or sRghtType == '3B' or sRghtType == '4B' or
sRghtType == '5B' or sRghtType == '6B' or sRghtType == '7B' or sRghtType == '8B' then
local dDeltaPos = dRadProfR - sqrt( ( dRadProfR * dRadProfR) - ((DGD.dT/2)*(DGD.dT/2)))
-- profilo sezione
nRghtSezPath = EgtArc3P( nParLay, {-dDeltaPos,0,0}, {0,DGD.dT/2,0}, {-dDeltaPos,DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nRghtPath = EgtLine ( nParLay, {DGD.dW-dDeltaPos,-(DGD.dH*0.25),0}, {DGD.dW-dDeltaPos,(DGD.dH*1.25),0}, GDB_RT.GRID)
elseif sRghtType == 'CV' then
local dDeltaPos = dRadProfR - sqrt( ( dRadProfR * dRadProfR) - (((DGD.dT/2)-dPlnProfR)*((DGD.dT/2)-dPlnProfR)))
-- profilo sezione
if dPlnProfR > 0 then
local nLine1, nLine2, nArc
nLine1 = EgtLine ( nParLay, {0,0,0}, {0,dPlnProfR,0}, GDB_RT.GRID)
nArc = EgtArc3P( nParLay, {0,dPlnProfR,0}, {-dDeltaPos,DGD.dT/2,0}, {0,DGD.dT-dPlnProfR,0}, GDB_RT.GRID)
nLine2 = EgtLine ( nParLay, {0,DGD.dT-dPlnProfR,0}, {0,DGD.dT,0}, GDB_RT.GRID)
nRghtSezPath = EgtCurveCompo( nParLay, {nLine1,nArc,nLine2}, true)
else
nRghtSezPath = EgtArc3P( nParLay, {0,0,0}, {-dDeltaPos,DGD.dT/2,0}, {0,DGD.dT,0}, GDB_RT.GRID)
end
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nRghtPath = EgtLine ( nParLay, {DGD.dW,-(DGD.dH*0.25),0}, {DGD.dW,(DGD.dH*1.25),0}, GDB_RT.GRID)
else -- profilo SQ o FDWC
-- profilo sezione
nRghtSezPath = EgtLine ( nParLay, {0,0,0}, {0,DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nRghtPath = EgtLine ( nParLay, {DGD.dW,-(DGD.dH*0.25),0}, {DGD.dW,(DGD.dH*1.25),0}, GDB_RT.GRID)
end
-- disegno la swept destra
local nSwR = EgtSurfTmSwept( nParLay, nRghtSezPath, nRghtPath,false, 0.05)
-- profilo sinistro
local nLftPath, nLftSezPath
-- griglia dietro
EgtSetGridFrame( Frame3d( 0,DGD.dH,0, GDB_FR.BACK))
if sLftType == 'BD' or sLftType == 'BDEB' then
-- profilo sezione
nLftSezPath = EgtLine ( nParLay, {-(DGD.dT*TAN3),0,0}, {0,DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nLftPath = EgtLine ( nParLay, {(DGD.dT*TAN3),(DGD.dH*1.25),0}, {(DGD.dT*TAN3),-(DGD.dH*0.25),0}, GDB_RT.GRID)
elseif sLftType == 'BU' or sLftType == 'BUEB' then
-- profilo sezione
nLftSezPath = EgtLine ( nParLay, {0,0,0}, {-(DGD.dT*TAN3),DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nLftPath = EgtLine ( nParLay, {0,(DGD.dH*1.25),0}, {0,-(DGD.dH*0.25),0}, GDB_RT.GRID)
elseif sLftType == '1B' or sLftType == '2B' or sLftType == '3B' or sLftType == '4B' or
sLftType == '5B' or sLftType == '6B' or sLftType == '7B' or sLftType == '8B' then
local dDeltaPos = dRadProfL - sqrt( ( dRadProfL * dRadProfL) - ((DGD.dT/2)*(DGD.dT/2)))
-- profilo sezione
nLftSezPath = EgtArc3P( nParLay, {-dDeltaPos,0,0}, {0,DGD.dT/2,0}, {-dDeltaPos,DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nLftPath = EgtLine ( nParLay, {dDeltaPos,(DGD.dH*1.25),0}, {dDeltaPos,-(DGD.dH*0.25),0}, GDB_RT.GRID)
elseif sLftType == 'CV' then
local dDeltaPos = dRadProfL - sqrt( ( dRadProfL * dRadProfL) - (((DGD.dT/2)-dPlnProf)*((DGD.dT/2)-dPlnProf)))
-- profilo sezione
if dPlnProf > 0 then
local nLine1, nLine2, nArc
nLine1 = EgtLine ( nParLay, {0,0,0}, {0,dPlnProf,0}, GDB_RT.GRID)
nArc = EgtArc3P( nParLay, {0,dPlnProf,0}, {-dDeltaPos,DGD.dT/2,0}, {0,DGD.dT-dPlnProf,0}, GDB_RT.GRID)
nLine2 = EgtLine ( nParLay, {0,DGD.dT-dPlnProf,0}, {0,DGD.dT,0}, GDB_RT.GRID)
nLftSezPath = EgtCurveCompo( nParLay, {nLine1,nArc,nLine2}, true)
else
nLftSezPath = EgtArc3P( nParLay, {0,0,0}, {-dDeltaPos,DGD.dT/2,0}, {0,DGD.dT,0}, GDB_RT.GRID)
end
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nLftPath = EgtLine ( nParLay, {0,(DGD.dH*1.25),0}, {0,-(DGD.dH*0.25),0}, GDB_RT.GRID)
else -- profilo SQ o FDWC
-- profilo sezione
nLftSezPath = EgtLine ( nParLay, {0,0,0}, {0,DGD.dT,0}, GDB_RT.GRID)
-- percorsi guida
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
nLftPath = EgtLine ( nParLay, {0,(DGD.dH*1.25),0}, {0,-(DGD.dH*0.25),0}, GDB_RT.GRID)
end
-- disegno la swept sinistra
local nSwL = EgtSurfTmSwept( nParLay, nLftSezPath, nLftPath,false, 0.05)
-- se ci sono tutte le swept procedo a rastremarle
if nSwT and nSwBL and nSwBR and nSwR and nSwL then
-- in base al profilo del top e se è in tangenza creo una superficie di appoggio
if DGD.TPL and sTopType ~= 'SQ' and sTopType ~= 'EB' and sTopType ~= 'FDWC' then
local nLine1, nLine2, nSwTmp
nLine1 = EgtLine( nParLay, {(DGD.dW/2),DGD.AMl,0}, {(DGD.dW/2),DGD.AMl,DGD.dT})
nLine2 = EgtLine( nParLay, {-100,DGD.AMl,0}, {-100,DGD.AMl,DGD.dT})
-- nLine1 = EgtLine( nParLay, {(DGD.Lda+DGD.dT),DGD.Adl+(DGD.dT*tan(60)),0}, {(DGD.Lua+DGD.dT),DGD.Aul+(DGD.dT*tan(60)),DGD.dT})
-- nLine2 = EgtLine( nParLay, {-10,DGD.Adl-((10+DGD.Lda)*tan(60)),0}, {-10,DGD.Aul-((10+DGD.Lua)*tan(60)),DGD.dT})
nSwTmp = EgtSurfTmRuled( nParLay, nLine2, nLine1, 0.05)
if bDelete then
EgtErase( nLine1)
EgtErase( nLine2)
end
-- somma tra le due superfici
EgtSurfTmAdd(nSwT,nSwTmp)
if nSwT then -- se ho una superficie sommata cancello la seconda
EgtErase( nSwTmp)
end
end
-- estrapolo il percorso intersezione
EgtSurfTmSurfTmInters(nSwL,nSwT,nParLay)
-- trimmo la swept sinistra con la superiore
EgtSurfTmIntersect(nSwL,nSwT)
if nSwL then -- se ho una superficie trimmata cancello la seconda
-- EgtOutBox( 'trim ok', 'Trim', 'Trim')
EgtErase( nSwT)
else
-- EgtOutBox( 'trim bad', 'Error Trim', 'Error Trim')
return false
end
-- in base al profilo del top e se è in tangenza creo una superficie di appoggio
if DGD.TPR and sTopType ~= 'SQ' and sTopType ~= 'EB' and sTopType ~= 'FDWC' then
local nLine1, nLine2, nSwTmp
nLine1 = EgtLine( nParLay, {DGD.dW+100,DGD.AMr,0}, {DGD.dW+100,DGD.AMr,DGD.dT})
nLine2 = EgtLine( nParLay, {(DGD.dW/2),DGD.AMr,0}, {(DGD.dW/2),DGD.AMr,DGD.dT})
-- nLine1 = EgtLine( nParLay, {DGD.dW+10,DGD.Adr-((DGD.dW-DGD.Rda+10)*tan(60)),0}, {DGD.dW+10,DGD.Aur-((DGD.dW-DGD.Rua+10)*tan(60)),DGD.dT})
-- nLine2 = EgtLine( nParLay, {(DGD.Rda-DGD.dT),DGD.Adr+(DGD.dT*tan(60)),0}, {(DGD.Rua-DGD.dT),DGD.Aur+(DGD.dT*tan(60)),DGD.dT})
nSwTmp = EgtSurfTmRuled( nParLay, nLine2, nLine1, 0.05)
if bDelete then
EgtErase( nLine1)
EgtErase( nLine2)
end
-- somma tra le due superfici
EgtSurfTmAdd(nSwL,nSwTmp)
if nSwL then -- se ho una superficie sommata cancello la seconda
EgtErase( nSwTmp)
end
end
--debug
-- EgtSaveFile( sNgeFile)
-- EgtMove(DGD.PZ, Point3d(0,0,nil) - ORIG())
-- estrapolo il percorso intersezione
EgtSurfTmSurfTmInters(nSwL,nSwR,nParLay)
-- trimmo la swept sinistra/superiore con la destra
EgtSurfTmIntersect(nSwL,nSwR)
if nSwL then -- se ho una superficie trimmata cancello la seconda
EgtErase( nSwR)
else
return false
end
-- estrapolo il percorso intersezione
EgtSurfTmSurfTmInters(nSwL,nSwBL,nParLay)
-- trimmo la swept sinistra/superiore/destra con la swept inferiore sinistra
EgtSurfTmIntersect(nSwL,nSwBL)
if nSwL then -- se ho una superficie trimmata cancello la seconda
EgtErase( nSwBL)
else
return false
end
-- estrapolo il percorso intersezione
EgtSurfTmSurfTmInters(nSwL,nSwBR,nParLay)
-- trimmo la swept inferiore destra con la restante swept
EgtSurfTmIntersect(nSwL,nSwBR)
if nSwL then -- se ho una superficie trimmata cancello la seconda
EgtErase( nSwBR)
else
return false
end
EgtSetName( nSwL, sSideName)
--debug
-- EgtSaveFile( sNgeFile)
-- EgtMove(DGD.PZ, Point3d(0,0,nil) - ORIG())
if bDelete then
-- cancello eventuali percorsi di costruzione
if nTopPath then
EgtErase(nTopPath)
end
if nToptSezPath then
EgtErase(nToptSezPath)
end
if nBotPathL then
EgtErase(nBotPathL)
end
if nBotPathR then
EgtErase(nBotPathR)
end
if nBotSezPath then
EgtErase(nBotSezPath)
end
if nRghtPath then
EgtErase(nRghtPath)
end
if nRghtSezPath then
EgtErase(nRghtSezPath)
end
if nLftPath then
EgtErase(nLftPath)
end
if nLftSezPath then
EgtErase(nLftSezPath)
end
end
return true, ptMedArc, bJoinRgt, bJoinLft
else
return false
end
end
-----------------------------------------------------------------
local function CreateDoor()
local bInactive
-- determinazione lato serratura
if DGD.sSwing == 'RH' or DGD.sSwing == 'RHR' or DGD.sSwing == 'RHA' or
DGD.sSwing == 'RHRI' or DGD.sSwing == 'RHI' or DGD.sSwing == 'RHRA' then
DGD.Lock = 'L'
else
DGD.Lock = 'R'
end
-- determinazione se apertura a spingere o tirare
if DGD.sSwing == 'RH' or DGD.sSwing == 'RHA' or DGD.sSwing == 'RHI' or
DGD.sSwing == 'LH' or DGD.sSwing == 'LHI' or DGD.sSwing == 'LHA' then
DGD.Push = true
else
DGD.Push = false
end
if DGD.sSwing == 'LHI' or DGD.sSwing == 'RHI' or
DGD.sSwing == 'RHRI' or DGD.sSwing == 'LHRI' then
bInactive = true
end
local sLocalLockPrf = DGD.tProfs.lockedge.trimming
local sLocalHingeProf = DGD.tProfs.hingeedge.trimming
if string.find( DGD.tProfs.lockedge.trimming, 'BU') then
sLocalLockPrf = 'BU'
elseif string.find( DGD.tProfs.lockedge.trimming, 'BD') then
sLocalLockPrf = 'BD'
end
if string.find( DGD.tProfs.hingeedge.trimming, 'BU') then
sLocalHingeProf = 'BU'
elseif string.find( DGD.tProfs.hingeedge.trimming, 'BD') then
sLocalHingeProf = 'BD'
end
-- Se porta inattiva
if bInactive then
-- Premessa: per definizione il profilo scritto indica la disposizione voluta, quindi se un profilo bevel è in opposizione
-- al parametro secure, allora indica il profilo opposto.
-- Se profilo serratura opposto al secure e diverso dal profilo hinge
if ( ( DGD.Push and DGD.sSecSide == 'UP' and sLocalLockPrf == 'BU' ) or
( DGD.Push and DGD.sSecSide == 'DN' and sLocalLockPrf == 'BD' ) or
( not DGD.Push and DGD.sSecSide == 'DN' and sLocalLockPrf == 'BU' ) or
( not DGD.Push and DGD.sSecSide == 'UP' and sLocalLockPrf == 'BD' ) ) and
sLocalHingeProf ~= sLocalLockPrf then
DGD.bBothOppoBevel = true
else
DGD.bBothOppoBevel = false
end
else
-- determino se ho entrambe profili bevel e diversi tra loro
DGD.bBothOppoBevel = ( sLocalLockPrf == 'BU' or sLocalLockPrf == 'BD') and
( sLocalHingeProf == 'BU' or sLocalHingeProf == 'BD') and
( sLocalHingeProf ~= sLocalLockPrf)
end
-- se porta non inactive e profilo hinge e lock con bevel discordanti emetto warning
if not bInactive and DGD.bBothOppoBevel then
-- Warning con outbox
DoorOutLog( string.format( EgtDoorsMsg[500], DGD.sSwing, DGD.tProfs.hingeedge.trimming, DGD.tProfs.lockedge.trimming), 0)
EgtOutBox( string.format(EgtDoorsMsg[500], DGD.sSwing, DGD.tProfs.hingeedge.trimming, DGD.tProfs.lockedge.trimming), EgtDoorsMsg[501], EgtDoorsMsg[502])
end
-- verifico congruenza tra presenza di profili bevel ed eventuale parametro 'secure'
local sBevelPrf
if sLocalHingeProf == 'BU' then sBevelPrf = 'BU' end
if not sBevelPrf and sLocalHingeProf == 'BD' then sBevelPrf = 'BD' end
if not sBevelPrf and sLocalLockPrf == 'BU' then sBevelPrf = 'BU' end
if not sBevelPrf and sLocalLockPrf == 'BD' then sBevelPrf = 'BD' end
-- casi di parametri incongruenti ( solo su porta, nei frame il secure è sempre DN)
if DGD.sSecSide and sBevelPrf then -- se profilo bevel e parametro secure esistenti
if not DGD.sFrame then
if ( DGD.Push and sBevelPrf == 'BU' and DGD.sSecSide == 'UP' and not DGD.bBothOppoBevel) or
( DGD.Push and sBevelPrf == 'BD' and DGD.sSecSide == 'DN' and not DGD.bBothOppoBevel) or
( not DGD.Push and sBevelPrf == 'BU' and DGD.sSecSide == 'DN' and not DGD.bBothOppoBevel) or
( not DGD.Push and sBevelPrf == 'BD' and DGD.sSecSide == 'UP' and not DGD.bBothOppoBevel) then
DoorOutLog( string.format( EgtDoorsMsg[544], DGD.sSwing, sBevelPrf, DGD.sSecSide), 0)
EgtOutBox( string.format( EgtDoorsMsg[544], DGD.sSwing, sBevelPrf, DGD.sSecSide), EgtDoorsMsg[476], EgtDoorsMsg[477])
return false, 0
end
end
-- se non c'è il profilo bevel e neppure il secure
elseif ( not DGD.sSecSide or #DGD.sSecSide == 0) and not sBevelPrf and DGD.MachEn > 0 then
DoorOutLog( EgtDoorsMsg[545], 0)
EgtOutBox( EgtDoorsMsg[545], EgtDoorsMsg[476], EgtDoorsMsg[477])
return false, 0
end
-- casi di incongruenza per frame: se posizione nel ddf non corrisponde con swing e tipo frame
if DGD.sFrame then
-- se frame sinistro
if nTypePiece == 3 then
-- se tipo hinge e lato serratura sinistro o tipo lock e lato serratura destro, incongruenza
if ( ( DGD.sFrame == 'H' or DGD.sFrame == 'HE') and DGD.Lock == 'L') or
( ( DGD.sFrame == 'L' or DGD.sFrame == 'LE') and DGD.Lock == 'R') then
DoorOutLog( string.format( EgtDoorsMsg[609],EgtDoorsMsg[605], DGD.sFrame, DGD.Lock), 0)
EgtOutBox( string.format( EgtDoorsMsg[609], EgtDoorsMsg[605], DGD.sFrame, DGD.Lock), EgtDoorsMsg[476], EgtDoorsMsg[477])
return false, 0
end
-- se frame destro
elseif nTypePiece == 4 then
-- se tipo hinge e lato serratura destro o tipo lock e lato serratura sinistro, incongruenza
if ( ( DGD.sFrame == 'H' or DGD.sFrame == 'HE') and DGD.Lock == 'R') or
( ( DGD.sFrame == 'L' or DGD.sFrame == 'LE') and DGD.Lock == 'L') then
DoorOutLog( string.format( EgtDoorsMsg[609],EgtDoorsMsg[606], DGD.sFrame, DGD.Lock), 0)
EgtOutBox( string.format( EgtDoorsMsg[609], EgtDoorsMsg[606], DGD.sFrame, DGD.Lock), EgtDoorsMsg[476], EgtDoorsMsg[477])
return false, 0
end
-- se frame top
elseif nTypePiece == 5 then
-- se tipo non top incongruenza
if DGD.nTypePz ~= 5 then
DoorOutLog( string.format( EgtDoorsMsg[609],EgtDoorsMsg[607], DGD.sFrame, '-'), 0)
EgtOutBox( string.format( EgtDoorsMsg[609], EgtDoorsMsg[607], DGD.sFrame, '-'), EgtDoorsMsg[476], EgtDoorsMsg[477])
return false, 0
end
-- se frame bottom
elseif nTypePiece == 6 then
-- se tipo non bottom incongruenza
if DGD.nTypePz ~= 6 then
DoorOutLog( string.format( EgtDoorsMsg[609],EgtDoorsMsg[608], DGD.sFrame, '-'), 0)
EgtOutBox( string.format( EgtDoorsMsg[609], EgtDoorsMsg[608], DGD.sFrame, '-'), EgtDoorsMsg[476], EgtDoorsMsg[477])
return false, 0
end
end
else
-- setto la variabile che indica che il top è effettivamente ad angolo e
-- il lato piatto è minore della larghezza porta - un delta
DGD.Tpa = DGD.tProfs.top.angle and abs(DGD.tProfs.top.angle) >= GEO.EPS_SMALL
DGD.Tpa = DGD.Tpa and DGD.tProfs.top.xdeltapos and DGD.tProfs.top.xdeltapos < ( DGD.dW - (2* DGD.dT * TAN3))
-- se porta ad arco o con angolo con probe attivato do errore
if ( DGD.tProfs.top.radius or DGD.Tpa) and ( DGD.PROBE > 0 and DGC.NPM == 0) then
DoorOutLog( EgtDoorsMsg[628], 0)
EgtOutBox( EgtDoorsMsg[628], EgtDoorsMsg[476], EgtDoorsMsg[477])
return false, 0
end
end
-- setto le variabili profili per edge break (EB)
local tEbThProf = {}
local sFoundProfEb = ''
local sProfName = ''
-- verifico (e correggo) se variabile globale per dimensione piano su profilo CV si avvicina alla metà spessore porta
if DGC.CVP and DGC.CVP >= ( DGD.dT*0.45) then DGC.CVP = 0 end
-- tipo profilo lato sinistro
local sLeftType = GetRealEdgeTrimming( 'L')
local dRadProf = 0
local dPlnProf = 0
-- se profilo tondo ottengo il raggio per il confronto con lo spessore porta
if sLeftType == '1B' then dRadProf = DGC.B1 end
if sLeftType == '2B' then dRadProf = DGC.B2 end
if sLeftType == '3B' then dRadProf = DGC.B3 end
if sLeftType == '4B' then dRadProf = DGC.B4 end
if sLeftType == '5B' then dRadProf = DGC.B5 end
if sLeftType == '6B' then dRadProf = DGC.B6 end
if sLeftType == '7B' then dRadProf = DGC.B7 end
if sLeftType == '8B' then dRadProf = DGC.B8 end
if sLeftType == 'CV' then dRadProf = DGC.CV end
if sLeftType == 'CV' then dPlnProf = DGC.CVP or 0 end
local dRadProfL = dRadProf
-- se profilo edge break ottengo la tabella con gli spessori dei profili con gli errori per ogni profilo
if sLeftType == 'EB' or sLeftType == 'BUEB' or sLeftType == 'BDEB' then
tEbThProf = DGC.EB
sFoundProfEb = EgtIf( DGD.Lock == 'L', EgtDoorsMsg[519], EgtDoorsMsg[518]) .. ',' .. sFoundProfEb
sProfName = sLeftType
end
if (sLeftType == 'BD' or sLeftType == 'BDEB' or sLeftType == 'BU' or sLeftType == 'BUEB') and not DGD.sFrame then
-- se lato sinistro con serratura e senza maniglia e abilitata la funzione
-- di inversione automatica bevel sul lato inactive o discordanza tra i due profili, inverto l'inclinazione
if DGD.Lock == 'L' and ( DGD.sSwing == 'RHI' or DGD.sSwing == 'RHRI') and
( ( DGD.RevInBv and DGD.RevInBv == 1) or DGD.bBothOppoBevel) then
-- inverto il profilo
sLeftType = SetInvertEdgeTrimming(sLeftType)
end
end
-- tipo profilo lato destro
local sRightType = GetRealEdgeTrimming( 'R')
local dRadProfR = 0
local dPlnProfR = 0
-- se profilo tondo ottengo il raggio per il confronto con lo spessore porta
if sRightType == '1B' then dRadProfR = DGC.B1 end
if sRightType == '2B' then dRadProfR = DGC.B2 end
if sRightType == '3B' then dRadProfR = DGC.B3 end
if sRightType == '4B' then dRadProfR = DGC.B4 end
if sRightType == '5B' then dRadProfR = DGC.B5 end
if sRightType == '6B' then dRadProfR = DGC.B6 end
if sRightType == '7B' then dRadProfR = DGC.B7 end
if sRightType == '8B' then dRadProfR = DGC.B8 end
if sRightType == 'CV' then dRadProfR = DGC.CV end
if sRightType == 'CV' then dPlnProfR = DGC.CVP or 0 end
-- se profilo edge break ottengo la tabella con gli spessori dei profili con gli errori per ogni profilo
if sRightType == 'EB' or sRightType == 'BUEB' or sRightType == 'BDEB' then
tEbThProf = DGC.EB
sFoundProfEb = EgtIf( DGD.Lock == 'L', EgtDoorsMsg[518], EgtDoorsMsg[519]) .. ',' .. sFoundProfEb
sProfName = sRightType
end
if ( sRightType == 'BD' or sRightType == 'BDEB' or sRightType == 'BU' or sRightType == 'BUEB') and not DGD.sFrame then
-- se lato destro con serratura e senza maniglia e abilitata la funzione
-- di inversione automatica bevel sul lato inactive o discordanza tra i due profili, inverto l'inclinazione
if DGD.Lock == 'R' and ( DGD.sSwing == 'LHI' or DGD.sSwing == 'LHRI') and
( ( DGD.RevInBv and DGD.RevInBv == 1) or DGD.bBothOppoBevel) then
-- inverto il profilo
sRightType = SetInvertEdgeTrimming(sRightType)
end
end
-- tipo profilo lato top
local sTopType = GetRealEdgeTrimming( 'T')
local dRadProfT = 0
local dPlnProfT = 0
-- se profilo tondo ottengo il raggio per il confronto con lo spessore porta
if sTopType == '1B' then dRadProfT = DGC.B1 end
if sTopType == '2B' then dRadProfT = DGC.B2 end
if sTopType == '3B' then dRadProfT = DGC.B3 end
if sTopType == '4B' then dRadProfT = DGC.B4 end
if sTopType == '5B' then dRadProfT = DGC.B5 end
if sTopType == '6B' then dRadProfT = DGC.B6 end
if sTopType == '7B' then dRadProfT = DGC.B7 end
if sTopType == '8B' then dRadProfT = DGC.B8 end
if sTopType == 'CV' then dRadProfT = DGC.CV end
if sTopType == 'CV' then dPlnProfT = DGC.CVP or 0 end
-- se profilo edge break ottengo la tabella con gli spessori dei profili con gli errori per ogni profilo
if sTopType == 'EB' or sTopType == 'BUEB' or sTopType == 'BDEB' then
tEbThProf = DGC.EB
sFoundProfEb = EgtDoorsMsg[607] .. ',' .. sFoundProfEb
sProfName = sTopType
end
-- tipo profilo lato bottom
local sBotType = GetRealEdgeTrimming( 'B')
local dRadProfB = 0
local dPlnProfB = 0
-- se profilo tondo ottengo il raggio per il confronto con lo spessore porta
if sBotType == '1B' then dRadProfB = DGC.B1 end
if sBotType == '2B' then dRadProfB = DGC.B2 end
if sBotType == '3B' then dRadProfB = DGC.B3 end
if sBotType == '4B' then dRadProfB = DGC.B4 end
if sBotType == '5B' then dRadProfB = DGC.B5 end
if sBotType == '6B' then dRadProfB = DGC.B6 end
if sBotType == '7B' then dRadProfB = DGC.B7 end
if sBotType == '8B' then dRadProfB = DGC.B8 end
if sBotType == 'CV' then dRadProfB = DGC.CV end
if sBotType == 'CV' then dPlnProfB = DGC.CVP or 0 end
-- se profilo edge break ottengo la tabella con gli spessori dei profili con gli errori per ogni profilo
if sBotType == 'EB' or sTopType == 'BUEB' or sTopType == 'BDEB' then
tEbThProf = DGC.EB
sFoundProfEb = EgtDoorsMsg[644] .. ',' .. sFoundProfEb
sProfName = sBotType
end
------------------------------------------------------------------------------
-- verifica se il profilo EB è stato configurato nel file CurrDoorsCustomData
------------------------------------------------------------------------------
if not tEbThProf and #sFoundProfEb > 0 then
local sErrMess = string.format( EgtDoorsMsg[667], sProfName, sFoundProfEb)
return false, 2, sErrMess
end
------------------------------------------------------------------------------
-- verifica del profilo EB nei lati destro, sinistro, sopra e sotto
-- in caso lo spessore è compatibile con uno dei profili, viene ridefinito anche
-- il valore della variabile di massimo errore ammesso sullo spessore tastato: DGC.Dt
------------------------------------------------------------------------------
-- se ho un profilo edge break (EB) verifico se gli spessori profili sono congruenti con lo spessore porta
if #tEbThProf > 0 then
local bMatchprofile
if #DGD.EBP > 0 then -- se ho già settato la compatibilità di profilo, evito di ricalcolarla
bMatchprofile = true
else
for i = 1, #tEbThProf do
-- se lo spessore porta è compreso tra lo spessore profilo + o - la tolleranza esco con match a true
if DGD.dT <= ( tEbThProf[i][1] + tEbThProf[i][2]) and DGD.dT >= ( tEbThProf[i][1] - tEbThProf[i][2]) then
bMatchprofile = true
DGD.EBP = string.format( '%s', i) -- setto la variabile globale con il numero profilo congruente
-- reinizializzo la variabile di errore massimo in tastatura dello spessore
if not DGD.sFrame and DGD.PROBE == 2 then
DGC.Dt = tEbThProf[i][2]
end
break
end
end
end
if not bMatchprofile then
local sListThProf = '('
for i = 1, #tEbThProf do
sListThProf = sListThProf .. string.format( EgtDoorsMsg[642], i, EgtToUiUnits(tEbThProf[i][1])) .. ','
end
sListThProf = sListThProf .. ')'
local sErrMess = string.format( EgtDoorsMsg[643], sProfName, sFoundProfEb, EgtToUiUnits(DGD.dT), sProfName, sListThProf)
return false, 2, sErrMess
end
end
-- se non è un frame e la tabella è completa, ricreo pezzo porta
if not DGD.sFrame and DGD.PROBE == 2 then
-- ricostruisco la geometria porta dai punti tastati
local dLungMax, dLarghMax = RemakeDoor( sLeftType, dRadProf, sRightType, dRadProfR, dPlnProf, dPlnProfR)
bRemake = true -- setto il flag per indicare che la funzione RemakeDoor è stata fatta
-- verifico se le dimensioni ricavate differiscono molto dalle dimensioni originarie
if ( abs( dLungMax - DGD.dH) > DGC.Dh) or ( abs( dLarghMax - DGD.dW) > DGC.Dw) or
( abs( tProbeDoor.PZ - DGD.dT) > DGC.Dt) then
DoorOutLog( string.format( EgtDoorsMsg[629],
EgtNumToString( EgtToUiUnits(dLungMax), 4), EgtNumToString( EgtToUiUnits(dLarghMax), 4), EgtNumToString( EgtToUiUnits(tProbeDoor.PZ), 4),
EgtToUiUnits(DGC.Dh), EgtToUiUnits(DGC.Dw), EgtToUiUnits(DGC.Dt),
EgtToUiUnits(DGD.dH), EgtToUiUnits(DGD.dW), EgtToUiUnits(DGD.dT)), 0)
EgtOutBox( string.format( EgtDoorsMsg[629],
EgtNumToString( EgtToUiUnits(dLungMax), 4), EgtNumToString( EgtToUiUnits(dLarghMax), 4), EgtNumToString( EgtToUiUnits(tProbeDoor.PZ), 4),
EgtToUiUnits(DGC.Dh), EgtToUiUnits(DGC.Dw), EgtToUiUnits(DGC.Dt),
EgtToUiUnits(DGD.dH), EgtToUiUnits(DGD.dW), EgtToUiUnits(DGD.dT)), EgtDoorsMsg[476], EgtDoorsMsg[477])
return false, 1
else -- altrimenti le dimensioni accettate, scrivo le note con le dimensioni calcolate
EgtSetInfo( DGD.PZ, 'ProbeDoorWidth', EgtToUiUnits(dLarghMax))
EgtSetInfo( DGD.PZ, 'ProbeDoorHeight', EgtToUiUnits(dLungMax))
EgtSetInfo( DGD.PZ, 'ProbeDoorThick', EgtToUiUnits(tProbeDoor.PZ))
end
end
-----------------
-- lato sinistro
-----------------
-- assegno a variabile globale
if DGD.Lock == 'R' then
DGD.RPH = dRadProf
DGD.PPH = dPlnProf
DGD.RPL = dRadProfR
DGD.PPL = dPlnProfR
end
-- verifico se lo spessore porta è congruente con il raggio profilo
if dRadProf > 0 then
if ( DGD.dT - (2*dPlnProf)) > (2*dRadProf) then
DoorOutLog( string.format( EgtDoorsMsg[433], ( DGD.dT - (2*dPlnProf)), sLeftType, dRadProf), 0)
return false, 0
end
end
if sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == 'FDWC' then
if DGD.sFrame then
if nTypePiece == 3 or nTypePiece == 5 then -- se frame SX o TOP
DGD.Ulb = DGD.dT
DGD.Urb = DGD.dT
DGD.Ult = DGD.dT
DGD.Urt = DGD.dT
elseif nTypePiece == 4 or nTypePiece == 6 then -- se frame DX o BOTTOM
DGD.Drb = 0
DGD.Dlb = 0
DGD.Drt = 0
DGD.Dlt = 0
end
else
if DGD.PROBE == 2 and bRemake then
DGD.Lut = DGD.P7:getX()
DGD.Lub = DGD.P1:getX()
DGD.Ldt = DGD.P10:getX()
DGD.Ldb = DGD.P4:getX()
else
DGD.Lut = 0
DGD.Lub = 0
DGD.Ldt = 0
DGD.Ldb = 0
end
end
elseif sLeftType == 'BD' or sLeftType == 'BU' or sLeftType == 'BDEB' or sLeftType == 'BUEB'then
if DGD.sFrame then
-- se frame left e BD
if ( nTypePiece == 3 and ( sLeftType == 'BD' or sLeftType == 'BDEB')) then
DGD.Ulb = DGD.dT - ( DGD.dW * TAN3)
DGD.Ult = DGD.Ulb
DGD.Urb = DGD.dT
DGD.Urt = DGD.dT
-- se frame left e BU
elseif ( nTypePiece == 3 and ( sLeftType == 'BU' or sLeftType == 'BUEB')) then
DGD.Urb = DGD.dT - ( DGD.dW * TAN3)
DGD.Urt = DGD.Urb
DGD.Ulb = DGD.dT
DGD.Ult = DGD.dT
-- se frame right e BD
elseif ( nTypePiece == 4 and ( sLeftType == 'BD' or sLeftType == 'BDEB')) then
DGD.Dlb = 0
DGD.Dlt = 0
DGD.Drb = ( DGD.dW * TAN3)
DGD.Drt = DGD.Drb
-- se frame right e BU
elseif ( nTypePiece == 4 and ( sLeftType == 'BU' or sLeftType == 'BUEB')) then
DGD.Drb = 0
DGD.Drt = 0
DGD.Dlb = ( DGD.dW * TAN3)
DGD.Dlt = DGD.Dlb
elseif nTypePiece == 5 then -- se frame top
if sLeftType == 'BD' or sLeftType == 'BDEB' then
DGD.Ulb = DGD.dT
DGD.Urb = DGD.dT
DGD.Ult = DGD.dT - ( DGD.dH * TAN3)
DGD.Urt = DGD.Ult
elseif sLeftType == 'BU' or sLeftType == 'BUEB' then
DGD.Ulb = DGD.dT - ( DGD.dH * TAN3)
DGD.Urb = DGD.Ulb
DGD.Ult = DGD.dT
DGD.Urt = DGD.dT
end
elseif nTypePiece == 6 then -- se frame bottom
if sLeftType == 'BD' or sLeftType == 'BDEB' then
DGD.Drb = ( DGD.dH * TAN3)
DGD.Dlb = DGD.Drb
DGD.Drt = 0
DGD.Dlt = 0
elseif sLeftType == 'BU' or sLeftType == 'BUEB' then
DGD.Drb = 0
DGD.Dlb = 0
DGD.Drt = ( DGD.dH * TAN3)
DGD.Dlt = DGD.Drt
end
end
else
if DGD.PROBE == 2 and bRemake then
DGD.Lut = DGD.P7:getX()
DGD.Lub = DGD.P1:getX()
DGD.Ldt = DGD.P10:getX()
DGD.Ldb = DGD.P4:getX()
else
-- se lato sinistro con serratura e senza maniglia e abilitata la funzione
-- di inversione automatica bevel sul lato inactive o discordanza tra i due profili, inverto l'inclinazione
if DGD.Lock == 'L' and ( DGD.sSwing == 'RHI' or DGD.sSwing == 'RHRI') and
( ( DGD.RevInBv and DGD.RevInBv == 1) or DGD.bBothOppoBevel) then
if DGD.Push then
DGD.Lut = 0
DGD.Lub = 0
DGD.Ldt = DGD.dT * TAN3
DGD.Ldb = DGD.Ldt
else
DGD.Lut = DGD.dT * TAN3
DGD.Lub = DGD.Lut
DGD.Ldt = 0
DGD.Ldb = 0
end
else -- altrimenti normale
if DGD.Push then
DGD.Lut = DGD.dT * TAN3
DGD.Lub = DGD.Lut
DGD.Ldt = 0
DGD.Ldb = 0
else
DGD.Lut = 0
DGD.Lub = 0
DGD.Ldt = DGD.dT * TAN3
DGD.Ldb = DGD.Ldt
end
end
end
end
elseif sLeftType == '1B' or sLeftType == '2B' or sLeftType == '3B' or sLeftType == '4B' or
sLeftType == '5B' or sLeftType == '6B' or sLeftType == '7B' or sLeftType == '8B' then
if DGD.PROBE == 2 and bRemake then
DGD.Lut = DGD.P7:getX()
DGD.Lub = DGD.P1:getX()
DGD.Ldt = DGD.P10:getX()
DGD.Ldb = DGD.P4:getX()
DGD.Lmb = DGD.P5:getX()
DGD.Lmt = DGD.P11:getX()
else
DGD.Lut = dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
DGD.Lub = DGD.Lut
DGD.Ldt = DGD.Lut
DGD.Ldb = DGD.Lut
DGD.Lm = 0
end
elseif sLeftType == 'CV' then
if DGD.PROBE == 2 and bRemake then
DGD.Lut = DGD.P7:getX()
DGD.Lub = DGD.P1:getX()
DGD.Ldt = DGD.P10:getX()
DGD.Ldb = DGD.P4:getX()
DGD.Lmb = DGD.P5:getX()
DGD.Lmt = DGD.P11:getX()
else
DGD.Lut = 0
DGD.Lub = 0
DGD.Ldt = 0
DGD.Ldb = 0
DGD.Lm = dRadProf - sqrt( ( dRadProf * dRadProf) - (((DGD.dT/2)-dPlnProf)*((DGD.dT/2)-dPlnProf)))
end
end
-- setto punti relativi allo spessore
SetFrameThickValues( true)
-----------------
-- lato destro
-----------------
-- assegno a variabile globale
if DGD.Lock == 'L' then
DGD.RPH = dRadProfR
DGD.PPH = dPlnProfR
DGD.RPL = dRadProf
DGD.PPL = dPlnProf
end
dRadProf = dRadProfR -- assegno il valore del raggio profilo
-- verifico se lo spessore porta è congruente con il raggio profilo
if dRadProf > 0 then
if ( DGD.dT - (2*dPlnProfR)) > (2*dRadProf) then
DoorOutLog( string.format( EgtDoorsMsg[433], ( DGD.dT - (2*dPlnProfR)), sRightType, dRadProf), 0)
return false, 0
end
end
if sRightType == 'SQ' or sRightType == 'EB' or sRightType == 'FDWC' then
if DGD.sFrame then
if nTypePiece == 3 or nTypePiece == 5 then -- se frame SX o TOP
DGD.Drb = 0
DGD.Dlb = 0
DGD.Drt = 0
DGD.Dlt = 0
elseif nTypePiece == 4 or nTypePiece == 6 then -- se frame DX o BOTTOM
DGD.Ulb = DGD.dT
DGD.Urb = DGD.dT
DGD.Ult = DGD.dT
DGD.Urt = DGD.dT
end
else
if DGD.PROBE == 2 and bRemake then
DGD.Rub = DGD.P2:getX()
DGD.Rut = DGD.P8:getX()
DGD.Rdb = DGD.P3:getX()
DGD.Rdt = DGD.P9:getX()
else
DGD.Rub = DGD.dW
DGD.Rut = DGD.dW
DGD.Rdb = DGD.dW
DGD.Rdt = DGD.dW
end
end
elseif sRightType == 'BD' or sRightType == 'BU' or sRightType == 'BDEB' or sRightType == 'BUEB' then
if DGD.sFrame then
-- se frame left e BD
if ( nTypePiece == 3 and ( sRightType == 'BD' or sRightType == 'BDEB')) then
DGD.Dlb = ( DGD.dW * TAN3)
DGD.Dlt = DGD.Dlb
DGD.Drb = 0
DGD.Drt = 0
-- se frame left e BU
elseif ( nTypePiece == 3 and ( sLeftType == 'BU' or sLeftType == 'BUEB')) then
DGD.Drb = ( DGD.dW * TAN3)
DGD.Drt = DGD.Drb
DGD.Dlb = 0
DGD.Dlt = 0
-- se frame right e BU
elseif ( nTypePiece == 4 and ( sRightType == 'BU' or sRightType == 'BUEB')) then
DGD.Ulb = DGD.dT - ( DGD.dW * TAN3)
DGD.Ult = DGD.Ulb
DGD.Urb = DGD.dT
DGD.Urt = DGD.dT
-- se frame right e BD
elseif ( nTypePiece == 4 and ( sRightType == 'BD' or sRightType == 'BDEB')) then
DGD.Urb = DGD.dT - ( DGD.dW * TAN3)
DGD.Urt = DGD.Urb
DGD.Ulb = DGD.dT
DGD.Ult = DGD.dT
elseif nTypePiece == 5 then -- se frame top
if sRightType == 'BD' or sRightType == 'BDEB' then
DGD.Dlb = 0
DGD.Drb = 0
DGD.Dlt = ( DGD.dH * TAN3)
DGD.Drt = DGD.Dlt
elseif sRightType == 'BU' or sRightType == 'BUEB'then
DGD.Dlb = ( DGD.dH * TAN3)
DGD.Drb = DGD.Dlb
DGD.Dlt = 0
DGD.Drt = 0
end
elseif nTypePiece == 6 then -- se frame bottom
if sRightType == 'BD' or sRightType == 'BDEB' then
DGD.Urb = DGD.dT - ( DGD.dH * TAN3)
DGD.Ulb = DGD.Urb
DGD.Urt = DGD.dT
DGD.Ult = DGD.dT
elseif sRightType == 'BU' or sRightType == 'BUEB' then
DGD.Urb = DGD.dT
DGD.Ulb = DGD.dT
DGD.Urt = DGD.dT - ( DGD.dH * TAN3)
DGD.Ult = DGD.Urt
end
end
else
if DGD.PROBE == 2 and bRemake then
DGD.Rub = DGD.P2:getX()
DGD.Rut = DGD.P8:getX()
DGD.Rdb = DGD.P3:getX()
DGD.Rdt = DGD.P9:getX()
else
-- se lato destro con serratura e senza maniglia e abilitata la funzione
-- di inversione automatica bevel sul lato inactive o discordanza tra i due profili, inverto l'inclinazione
if DGD.Lock == 'R' and ( DGD.sSwing == 'LHI' or DGD.sSwing == 'LHRI') and
( ( DGD.RevInBv and DGD.RevInBv == 1) or DGD.bBothOppoBevel) then
if DGD.Push then
DGD.Rut = DGD.dW
DGD.Rub = DGD.dW
DGD.Rdt = DGD.dW - ( DGD.dT * TAN3)
DGD.Rdb = DGD.Rdt
else
DGD.Rut = DGD.dW - ( DGD.dT * TAN3)
DGD.Rub = DGD.Rut
DGD.Rdt = DGD.dW
DGD.Rdb = DGD.dW
end
else -- altrimenti normale
if DGD.Push then
DGD.Rut = DGD.dW - ( DGD.dT * TAN3)
DGD.Rub = DGD.Rut
DGD.Rdt = DGD.dW
DGD.Rdb = DGD.dW
else
DGD.Rut = DGD.dW
DGD.Rub = DGD.dW
DGD.Rdt = DGD.dW - ( DGD.dT * TAN3)
DGD.Rdb = DGD.Rdt
end
end
end
end
elseif sRightType == '1B' or sRightType == '2B' or sRightType == '3B' or sRightType == '4B' or
sRightType == '5B' or sRightType == '6B' or sRightType == '7B' or sRightType == '8B' then
if DGD.PROBE == 2 and bRemake then
DGD.Rub = DGD.P2:getX()
DGD.Rut = DGD.P8:getX()
DGD.Rdb = DGD.P3:getX()
DGD.Rdt = DGD.P9:getX()
DGD.Rmb = DGD.P6:getX()
DGD.Rmt = DGD.P12:getX()
else
DGD.Rut = DGD.dW - dRadProf + sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
DGD.Rub = DGD.Rut
DGD.Rdt = DGD.Rut
DGD.Rdb = DGD.Rut
DGD.Rm = DGD.dW
end
elseif sRightType == 'CV' then
if DGD.PROBE == 2 and bRemake then
DGD.Rub = DGD.P2:getX()
DGD.Rut = DGD.P8:getX()
DGD.Rdb = DGD.P3:getX()
DGD.Rdt = DGD.P9:getX()
DGD.Rmb = DGD.P6:getX()
DGD.Rmt = DGD.P12:getX()
else
DGD.Rut = DGD.dW
DGD.Rub = DGD.dW
DGD.Rdt = DGD.dW
DGD.Rdb = DGD.dW
DGD.Rm = DGD.dW + sqrt( ( dRadProf * dRadProf) - (((DGD.dT/2)-dPlnProfR)*((DGD.dT/2)-dPlnProfR))) - dRadProf
end
end
-- setto punti relativi allo spessore
SetFrameThickValues()
-----------------
-- lato top
-----------------
dRadProf = dRadProfT -- setto il valore del raggio profilo
-- assegno a variabile globale
DGD.RPT = dRadProf
DGD.PPT = dPlnProfT
-- verifico se lo spessore porta è congruente con il raggio profilo
if dRadProf > 0 then
if ( DGD.dT - (2*dPlnProfT)) > (2*dRadProf) then
DoorOutLog( string.format( EgtDoorsMsg[433], ( DGD.dT - (2*dPlnProfT)), sRightType, dRadProf), 0)
return false, 0
end
end
-- Nei frame top e bottom sempre SQ o FDWC
if DGD.sFrame then
if nTypePiece == 3 or nTypePiece == 4 then -- se frame SX o DX
DGD.Bul = 0
DGD.Bur = 0
DGD.Bdl = 0
DGD.Bdr = 0
DGD.Tul = DGD.dH
DGD.Tur = DGD.dH
DGD.Tdl = DGD.dH
DGD.Tdr = DGD.dH
elseif nTypePiece == 5 or nTypePiece == 6 then -- se frame TOP o BOTTOM
DGD.Lut = 0
DGD.Lub = 0
DGD.Ldt = 0
DGD.Ldb = 0
DGD.Rut = DGD.dW
DGD.Rub = DGD.dW
DGD.Rdt = DGD.dW
DGD.Rdb = DGD.dW
end
else
if DGD.PROBE == 2 and bRemake then
DGD.Bul = DGD.P1:getY()
DGD.Bur = DGD.P2:getY()
DGD.Bdl = DGD.P4:getY()
DGD.Bdr = DGD.P3:getY()
DGD.Bml = DGD.P5:getY()
DGD.Bmr = DGD.P6:getY()
DGD.Tul = DGD.P7:getY()
DGD.Tur = DGD.P8:getY()
DGD.Tdl = DGD.P10:getY()
DGD.Tdr = DGD.P9:getY()
DGD.Tml = DGD.P11:getY()
DGD.Tmr = DGD.P12:getY()
else
if sTopType == 'SQ' or sTopType == 'EB' or sTopType == 'FDWC' then
DGD.Tul = DGD.dH
DGD.Tur = DGD.dH
DGD.Tdl = DGD.dH
DGD.Tdr = DGD.dH
DGD.Tml = DGD.dH
DGD.Tmr = DGD.dH
elseif sTopType == 'BD' or sTopType == 'BU' or sTopType == 'BDEB' or sTopType == 'BUEB' then
if DGD.Push then
DGD.Tul = DGD.dH - ( DGD.dT * TAN3)
DGD.Tur = DGD.Tul
DGD.Tdl = DGD.dH
DGD.Tdr = DGD.dH
DGD.Tml = DGD.dH - ( DGD.dT * TAN3)/2
DGD.Tmr = DGD.Tml
else
DGD.Tul = DGD.dH
DGD.Tur = DGD.dH
DGD.Tdl = DGD.dH - ( DGD.dT * TAN3)
DGD.Tdr = DGD.Tdl
DGD.Tml = DGD.dH - ( DGD.dT * TAN3)/2
DGD.Tmr = DGD.Tml
end
elseif sTopType == '1B' or sTopType == '2B' or sTopType == '3B' or sTopType == '4B' or
sTopType == '5B' or sTopType == '6B' or sTopType == '7B' or sTopType == '8B' then
DGD.Tul = DGD.dH - dRadProf + sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
DGD.Tur = DGD.Tul
DGD.Tdl = DGD.Tul
DGD.Tdr = DGD.Tul
DGD.Tml = DGD.dH
DGD.Tmr = DGD.dH
elseif sTopType == 'CV' then
DGD.Tul = DGD.dH
DGD.Tur = DGD.dH
DGD.Tdl = DGD.dH
DGD.Tdr = DGD.dH
DGD.Tml = DGD.dH - dRadProf + sqrt( ( dRadProf * dRadProf) - (((DGD.dT/2)-dPlnProfT)*((DGD.dT/2)-dPlnProfT)))
DGD.Tmr = DGD.Tml
end
-- se top è ad arco
if DGD.tProfs.top.radius then
if not DGD.tProfs.top.xdeltapos then
DGD.tProfs.top.xdeltapos = 0
end
-- calcolo il delta y dell'arco
-- se centro arco è compreso nella larghezza porta
if abs(DGD.tProfs.top.xdeltapos) <= (DGD.dW/2) then
DGD.tProfs.top.ydeltapos = DGD.tProfs.top.radius
else -- altrimenti è esterno
DGD.tProfs.top.ydeltapos = CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos)), nil, DGD.tProfs.top.radius)
end
-- verifico se ho una tangenza con l'arco
if abs( abs(DGD.tProfs.top.xdeltapos) + (DGD.dW/2) - DGD.tProfs.top.radius) <= GEO.EPS_SMALL then
if DGD.tProfs.top.xdeltapos < 0 then -- se centro arco verso X- la tangenza è a destra
DGD.TPR = DGD.dH-DGD.tProfs.top.ydeltapos
elseif DGD.tProfs.top.xdeltapos > 0 then -- se centro arco verso X+ la tangenza è a sinistra
DGD.TPL = DGD.dH-DGD.tProfs.top.ydeltapos
else -- entrambe le tangenze
DGD.TPR = DGD.dH-DGD.tProfs.top.ydeltapos
DGD.TPL = DGD.TPR
end
end
if sTopType == 'SQ' or sTopType == 'EB' or sTopType == 'FDWC' then -- se top con profilo diritto prendo i valori dai fianchi
DGD.Rua = DGD.Rut
DGD.Rda = DGD.Rdt
DGD.Rma = DGD.Rm
DGD.Lua = DGD.Lut
DGD.Lda = DGD.Ldt
DGD.Lma = DGD.Lm
elseif sTopType == 'BD' or sTopType == 'BDEB' then
-- se la quota X dell'arco è interna al fianco tengo quella dell'arco
if DGD.dW - DGD.Rut >= GEO.EPS_SMALL then
DGD.Rua = DGD.Rut
else
DGD.Rua = DGD.dW
end
if DGD.Rdt <= (DGD.dW - ( DGD.dT * TAN3)) then
DGD.Rda = DGD.Rdt
else
if not DGD.TPR then
if sRightType == 'CV' or sRightType == 'SQ' or sRightType == 'EB' or sRightType == 'FDWC' then
DGD.Rda = DGD.dW
else
DGD.Rda = DGD.dW - ( DGD.dT * TAN3)
end
else
DGD.Rda = DGD.dW - ( DGD.dT * TAN3)
end
end
if DGD.Lut >= GEO.EPS_SMALL then
DGD.Lua = DGD.Lut
else
DGD.Lua = 0
end
if DGD.Ldt >= ( DGD.dT * TAN3) then
DGD.Lda = DGD.Ldt
else
if not DGD.TPL then
if sLeftType == 'CV' or sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == 'FDWC' then
DGD.Lda = 0
else
DGD.Lda = ( DGD.dT * TAN3)
end
else
DGD.Lda = ( DGD.dT * TAN3)
end
end
elseif sTopType == 'BU' or sTopType == 'BUEB' then
if DGD.Rut <= (DGD.dW - ( DGD.dT * TAN3)) then
DGD.Rua = DGD.Rut
else
if not DGD.TPR then
if sRightType == 'CV' or sRightType == 'SQ' or sRightType == 'EB' or sRightType == 'FDWC' then
DGD.Rua = DGD.dW
else
DGD.Rua = DGD.dW - ( DGD.dT * TAN3)
end
else
DGD.Rua = DGD.dW - ( DGD.dT * TAN3)
end
end
if DGD.Rdt <= DGD.dW then
DGD.Rda = DGD.Rdt
else
DGD.Rda = DGD.dW
end
if DGD.Lut >= ( DGD.dT * TAN3) then
DGD.Lua = DGD.Lut
else
if not DGD.TPL then
if sLeftType == 'CV' or sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == 'FDWC' then
DGD.Lua = 0
else
DGD.Lua = ( DGD.dT * TAN3)
end
else
DGD.Lua = ( DGD.dT * TAN3)
end
end
if DGD.Ldt >= 0 then
DGD.Lda = DGD.Ldt
else
DGD.Lda = 0
end
elseif sTopType == '1B' or sTopType == '2B' or sTopType == '3B' or sTopType == '4B' or
sTopType == '5B' or sTopType == '6B' or sTopType == '7B' or sTopType == '8B' then
if DGD.Rut <= (DGD.dW - ( dRadProf + sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2))))) then
DGD.Rua = DGD.Rut
else
DGD.Rua = DGD.dW - dRadProf + sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
end
if DGD.Rdt <= (DGD.dW - ( dRadProf + sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2))))) then
DGD.Rda = DGD.Rdt
else
DGD.Rda = DGD.dW - dRadProf + sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
end
DGD.Rma = DGD.dW
if DGD.Lut >= ( dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))) then
DGD.Lua = DGD.Lut
else
DGD.Lua = dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
end
if DGD.Ldt >= ( dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))) then
DGD.Lda = DGD.Ldt
else
DGD.Lda = dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
end
DGD.Lma = 0
elseif sTopType == 'CV' then
if DGD.dW - DGD.Rut >= GEO.EPS_SMALL then
DGD.Rua = DGD.Rut
else
DGD.Rua = DGD.dW
end
if DGD.dW - DGD.Rdt >= GEO.EPS_SMALL then
DGD.Rda = DGD.Rdt
else
DGD.Rda = DGD.dW
end
DGD.Rma = DGD.dW - dRadProf + sqrt( ( dRadProf * dRadProf) - (((DGD.dT/2)-dPlnProfT)*((DGD.dT/2)-dPlnProfT)))
if DGD.Lut >= GEO.EPS_SMALL then
DGD.Lua = DGD.Lut
else
DGD.Lua = 0
end
if DGD.Ldt >= GEO.EPS_SMALL then
DGD.Lda = DGD.Ldt
else
DGD.Lda = 0
end
DGD.Lma = dRadProf - sqrt( ( dRadProf * dRadProf) - (((DGD.dT/2)-dPlnProfT)*((DGD.dT/2)-dPlnProfT)))
end
local dDistRad = 0
local dDistRadCv = 0
if sTopType == 'BD' or sTopType == 'BDEB' then -- se top bevel down
DGD.Adt = ( DGD.dT * TAN3)
DGD.Amt = DGD.Adt / 2
elseif sTopType == 'BU' or sTopType == 'BUEB' then
DGD.Aut = ( DGD.dT * TAN3)
DGD.Amt = DGD.Aut / 2
elseif sTopType == 'CV' then
dDistRadCv = dRadProf - sqrt( ( dRadProf * dRadProf) - (((DGD.dT/2)-dPlnProfT)*((DGD.dT/2)-dPlnProfT)))
elseif sTopType == '1B' or sTopType == '2B' or sTopType == '3B' or sTopType == '4B' or
sTopType == '5B' or sTopType == '6B' or sTopType == '7B' or sTopType == '8B' then
dDistRad = dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
end
-- valori x max arco
DGD.LMa = 0
DGD.RMa = DGD.dW
-- valori x min arco
DGD.lma = dDistRadCv + (DGD.Amt*2)
DGD.rma = DGD.dW - dDistRadCv - (DGD.Amt*2)
-- valori in Z arco
DGD.Ula = DGD.dT
DGD.Ura = DGD.dT
DGD.Dra = 0
DGD.Dla = 0
DGD.Mla = DGD.dT / 2
DGD.Mra = DGD.dT / 2
-- se centro arco è compreso nella larghezza porta
if abs(DGD.tProfs.top.xdeltapos) <= (DGD.dW/2) then
DGD.Aul = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) + DGD.tProfs.top.xdeltapos - DGD.Lua), nil, ( DGD.tProfs.top.radius - DGD.Aut-dDistRad))
DGD.Adl = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) + DGD.tProfs.top.xdeltapos - DGD.Lda), nil, ( DGD.tProfs.top.radius - DGD.Adt-dDistRad))
DGD.Aur = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) - DGD.tProfs.top.xdeltapos - (DGD.dW - DGD.Rua)), nil, ( DGD.tProfs.top.radius - DGD.Aut-dDistRad))
DGD.Adr = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) - DGD.tProfs.top.xdeltapos - (DGD.dW - DGD.Rda)), nil, ( DGD.tProfs.top.radius - DGD.Adt-dDistRad))
DGD.Aml = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) + DGD.tProfs.top.xdeltapos - DGD.Lma), nil, ( DGD.tProfs.top.radius - DGD.Amt-dDistRad))
DGD.Amr = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) - DGD.tProfs.top.xdeltapos - (DGD.dW - DGD.Rma)), nil, ( DGD.tProfs.top.radius - DGD.Amt-dDistRad))
-- punti con ingombro max
DGD.AMl = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) + DGD.tProfs.top.xdeltapos - DGD.LMa), nil, DGD.tProfs.top.radius)
DGD.AMr = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) - DGD.tProfs.top.xdeltapos - (DGD.dW - DGD.RMa)), nil, DGD.tProfs.top.radius)
-- punti con ingombro min per profilo CV
DGD.aml = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) + DGD.tProfs.top.xdeltapos - DGD.lma), nil, ( DGD.tProfs.top.radius - dDistRadCv - (DGD.Amt*2)))
DGD.amr = DGD.dH - DGD.tProfs.top.radius + CalcSideRectTringle( ((DGD.dW/2) - DGD.tProfs.top.xdeltapos - (DGD.dW - DGD.rma)), nil, ( DGD.tProfs.top.radius - dDistRadCv - (DGD.Amt*2)))
else -- altrimenti è esterno
if DGD.tProfs.top.xdeltapos > 0 then -- se centro arco è a destra
DGD.Aul = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - DGD.Lua), nil, ( DGD.tProfs.top.radius - DGD.Aut-dDistRad))
DGD.Adl = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - DGD.Lda), nil, ( DGD.tProfs.top.radius - DGD.Adt-dDistRad))
DGD.Aur = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.Rua)), nil, ( DGD.tProfs.top.radius - DGD.Aut-dDistRad))
DGD.Adr = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.Rda)), nil, ( DGD.tProfs.top.radius - DGD.Adt-dDistRad))
DGD.Aml = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - DGD.Lma), nil, ( DGD.tProfs.top.radius - DGD.Amt-dDistRad))
DGD.Amr = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.Rma)), nil, ( DGD.tProfs.top.radius - DGD.Amt-dDistRad))
-- punti con ingombro max
DGD.AMl = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - DGD.LMa), nil, DGD.tProfs.top.radius)
DGD.AMr = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.RMa)), nil, DGD.tProfs.top.radius)
-- punti con ingombro min per profilo CV
DGD.aml = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - DGD.lma), nil, ( DGD.tProfs.top.radius - dDistRadCv - (DGD.Amt*2)))
DGD.amr = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.rma)), nil, ( DGD.tProfs.top.radius - dDistRadCv - (DGD.Amt*2)))
else -- altrimenti centro arco è a sinistra
DGD.Aul = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - DGD.Lua), nil, ( DGD.tProfs.top.radius - DGD.Aut-dDistRad))
DGD.Adl = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - DGD.Lda), nil, ( DGD.tProfs.top.radius - DGD.Adt-dDistRad))
DGD.Aur = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.Rua)), nil, ( DGD.tProfs.top.radius - DGD.Aut-dDistRad))
DGD.Adr = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.Rda)), nil, ( DGD.tProfs.top.radius - DGD.Adt-dDistRad))
DGD.Aml = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - DGD.Lma), nil, ( DGD.tProfs.top.radius - DGD.Amt-dDistRad))
DGD.Amr = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.Rma)), nil, ( DGD.tProfs.top.radius - DGD.Amt-dDistRad))
-- punti con ingombro max
DGD.AMl = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - DGD.LMa), nil, DGD.tProfs.top.radius)
DGD.AMr = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.RMa)), nil, DGD.tProfs.top.radius)
-- punti con ingombro min per profilo CV
DGD.aml = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) - abs(DGD.tProfs.top.xdeltapos) - DGD.lma), nil, ( DGD.tProfs.top.radius - dDistRadCv - (DGD.Amt*2)))
DGD.amr = DGD.dH - DGD.tProfs.top.ydeltapos + CalcSideRectTringle( ((DGD.dW/2) + abs(DGD.tProfs.top.xdeltapos) - (DGD.dW - DGD.rma)), nil, ( DGD.tProfs.top.radius - dDistRadCv - (DGD.Amt*2)))
end
end
elseif DGD.Tpa then -- se top ad angolo
if not DGD.tProfs.top.xdeltapos then
DGD.tProfs.top.xdeltapos = 0
end
if DGD.tProfs.top.xdeltapos <= (2* DGD.dT * TAN3) and
( sLeftType == 'BD' or sLeftType == 'BU' or sLeftType == 'BDEB' or sLeftType == 'BUEB') and
( sRightType == 'BD' or sRightType == 'BU' or sRightType == 'BDEB' or sRightType == 'BUEB') then
DGD.tProfs.top.xdeltapos = 0
end
if sLeftType == 'BD' or sLeftType == 'BU' or sLeftType == 'BDEB' or sLeftType == 'BUEB' or sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == 'FDWC' then
DGD.Lua = DGD.Lut
DGD.Lda = DGD.Ldt
DGD.Lma = (DGD.Lut + DGD.Ldt) / 2
else
DGD.Lua = DGD.Lut
DGD.Lda = DGD.Lua
DGD.Lma = DGD.Lm
end
if sRightType == 'BD' or sRightType == 'BU' or sRightType == 'BDEB' or sRightType == 'BUEB' or sRightType == 'SQ' or sRightType == 'EB' or sRightType == 'FDWC' then
DGD.Rua = DGD.Rut
DGD.Rda = DGD.Rdt
DGD.Rma = (DGD.Rut + DGD.Rdt) / 2
else
DGD.Rua = DGD.Rut
DGD.Rda = DGD.Rua
DGD.Rma = DGD.Rm
end
if sTopType == 'BD' or sTopType == 'BDEB' then -- se top bevel down
DGD.Adt = ( DGD.dT * TAN3)
DGD.Amt = DGD.Adt / 2
DGD.Dpd = DGD.Adt / abs(cos(DGD.tProfs.top.angle))
elseif sTopType == 'BU' or sTopType == 'BUEB' then
DGD.Aut = ( DGD.dT * TAN3)
DGD.Amt = DGD.Aut / 2
DGD.Dpu = DGD.Aut / abs(cos(DGD.tProfs.top.angle))
elseif sTopType == '1B' or sTopType == '2B' or sTopType == '3B' or sTopType == '4B' or
sTopType == '5B' or sTopType == '6B' or sTopType == '7B' or sTopType == '8B' then
DGD.Adt = dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
DGD.Aut = DGD.Adt
DGD.Dpu = DGD.Adt / abs(cos(DGD.tProfs.top.angle))
DGD.Dpd = DGD.Dpu
elseif sTopType == 'CV' then
DGD.Amt = dRadProf - sqrt( ( dRadProf * dRadProf) - (((DGD.dT/2)-dPlnProfT)*((DGD.dT/2)-dPlnProfT)))
DGD.Dpm = DGD.Amt / abs(cos(DGD.tProfs.top.angle))
end
DGD.Ula = DGD.dT
DGD.Ura = DGD.dT
DGD.Dra = 0
DGD.Dla = 0
DGD.Mla = DGD.dT / 2
DGD.Mra = DGD.dT / 2
-- se angolo positivo
if DGD.tProfs.top.angle > 0 then
DGD.Aul = DGD.dH - (( DGD.dW - DGD.tProfs.top.xdeltapos - DGD.Lua) * tan( DGD.tProfs.top.angle)) - DGD.Dpu
DGD.Adl = DGD.dH - (( DGD.dW - DGD.tProfs.top.xdeltapos - DGD.Lda) * tan( DGD.tProfs.top.angle)) - DGD.Dpd
DGD.Aur = DGD.dH - EgtIf( DGD.tProfs.top.xdeltapos > 0, DGD.Aut, ((( DGD.dW - DGD.Rua) * tan( DGD.tProfs.top.angle)) + DGD.Dpu))
DGD.Adr = DGD.dH - EgtIf( DGD.tProfs.top.xdeltapos > 0, DGD.Adt, ((( DGD.dW - DGD.Rda) * tan( DGD.tProfs.top.angle)) + DGD.Dpd))
DGD.Aml = DGD.dH - (( DGD.dW - DGD.tProfs.top.xdeltapos - DGD.Lma) * tan( DGD.tProfs.top.angle)) - DGD.Amt
DGD.Amr = DGD.dH - EgtIf( DGD.tProfs.top.xdeltapos > 0, DGD.Amt, ((( DGD.dW - DGD.Rma) * tan( DGD.tProfs.top.angle)) + DGD.Dpm))
else
DGD.Aul = DGD.dH - EgtIf( DGD.tProfs.top.xdeltapos > 0, DGD.Aut, (( DGD.Lua * tan( abs(DGD.tProfs.top.angle))) + DGD.Dpu))
DGD.Adl = DGD.dH - EgtIf( DGD.tProfs.top.xdeltapos > 0, DGD.Adt, (( DGD.Lda * tan( abs(DGD.tProfs.top.angle))) + DGD.Dpd))
DGD.Aur = DGD.dH - (( DGD.Rua - DGD.tProfs.top.xdeltapos) * tan( abs(DGD.tProfs.top.angle))) - DGD.Dpu
DGD.Adr = DGD.dH - (( DGD.Rda - DGD.tProfs.top.xdeltapos) * tan( abs(DGD.tProfs.top.angle))) - DGD.Dpd
DGD.Aml = DGD.dH - EgtIf( DGD.tProfs.top.xdeltapos > 0, DGD.Amt, (( DGD.Lma * tan( abs(DGD.tProfs.top.angle))) + DGD.Dpm))
DGD.Amr = DGD.dH - (( DGD.Rma - DGD.tProfs.top.xdeltapos) * tan( abs(DGD.tProfs.top.angle))) - DGD.Amt
end
-- punti intersezione curva sopra
if DGD.tProfs.top.xdeltapos > 0 then
local dTempU = DGD.Aut
local dTempD = DGD.Adt
local dTempM = DGD.Amt
DGD.Aut = DGD.dH - DGD.Aut
DGD.Adt = DGD.dH - DGD.Adt
DGD.Amt = DGD.dH - DGD.Amt
-- se angolo positivo
if DGD.tProfs.top.angle > 0 then
DGD.Cmu = DGD.dW - DGD.tProfs.top.xdeltapos + ( dTempU * tan(DGD.tProfs.top.angle/2))
DGD.Cmd = DGD.dW - DGD.tProfs.top.xdeltapos + ( dTempD * tan(DGD.tProfs.top.angle/2))
DGD.Cmm = DGD.dW - DGD.tProfs.top.xdeltapos + ( dTempM * tan(DGD.tProfs.top.angle/2))
else
DGD.Cmu = DGD.tProfs.top.xdeltapos + ( dTempU * tan(DGD.tProfs.top.angle/2))
DGD.Cmd = DGD.tProfs.top.xdeltapos + ( dTempD * tan(DGD.tProfs.top.angle/2))
DGD.Cmm = DGD.tProfs.top.xdeltapos + ( dTempM * tan(DGD.tProfs.top.angle/2))
end
end
end
end
end
-----------------
-- lato bottom
-----------------
dRadProf = dRadProfB -- setto il valore del raggio profilo
-- assegno a variabile globale
DGD.RPB = dRadProf
DGD.PPB = dPlnProfB
-- verifico se lo spessore porta è congruente con il raggio profilo
if dRadProf > 0 then
if ( DGD.dT - (2*dPlnProfB)) > (2*dRadProf) then
DoorOutLog( string.format( EgtDoorsMsg[433], ( DGD.dT - (2*dPlnProfB)), sRightType, dRadProf), 0)
return false, 0
end
end
if not DGD.sFrame then
if not( DGD.PROBE == 2 and bRemake) then
DGD.Bul = 0
DGD.Bur = 0
DGD.Bdl = 0
DGD.Bdr = 0
if sBotType == 'BD' or sBotType == 'BU' or sBotType == 'BDEB' or sBotType == 'BUEB' then
if DGD.Push then
DGD.Bul = ( DGD.dT * TAN3)
DGD.Bur = ( DGD.dT * TAN3)
DGD.Bml = DGD.Bul / 2
DGD.Bmr = DGD.Bml
else
DGD.Bdl = ( DGD.dT * TAN3)
DGD.Bdr = ( DGD.dT * TAN3)
DGD.Bml = DGD.Bdl / 2
DGD.Bmr = DGD.Bml
end
elseif sBotType == '1B' or sBotType == '2B' or sBotType == '3B' or sBotType == '4B' or
sBotType == '5B' or sBotType == '6B' or sBotType == '7B' or sBotType == '8B' then
DGD.Bul = dRadProf - sqrt( ( dRadProf * dRadProf) - ((DGD.dT/2)*(DGD.dT/2)))
DGD.Bur = DGD.Bul
DGD.Bdl = DGD.Bul
DGD.Bdr = DGD.Bul
elseif sBotType == 'CV' then
DGD.Bml = dRadProf - sqrt( ( dRadProf * dRadProf) - (((DGD.dT/2)-dPlnProfB)*((DGD.dT/2)-dPlnProfB)))
DGD.Bmr = DGD.Bml
end
end
end
--------------------
-- creo pezzo porta
--------------------
--local nP = EgtGetFirstGroupInGroup( GDB_ID.ROOT)
local nLa = EgtGroup( DGD.PZ)
EgtSetName( nLa, 'AUX')
EgtSetColor( nLa, BROWN())
local nLs = EgtGroup( DGD.PZ)
EgtSetName( nLs, 'SOLID')
if DGD.bProoduce then
if DGD.Material and string.lower(DGD.Material) == 'wood' then
EgtSetColor( nLs, ORANGE())
EgtSetBackground( Color3d(176,208,210), Color3d(145,177,196), false)
elseif DGD.Material and string.lower(DGD.Material) == 'steel' then
EgtSetColor( nLs, Color3d(167,196,197))
-- EgtSetColor( nLs, Color3d(186,193,199))
EgtSetBackground( WHITE(), GRAY(), false)
elseif DGD.Material and string.lower(DGD.Material) == 'aluminum' then
EgtSetColor( nLs, Color3d(208,213,217))
-- EgtSetBackground( WHITE(), GRAY(), false)
EgtSetBackground( WHITE(), Color3d(170,170,170), false)
elseif DGD.Material and string.lower(DGD.Material) == 'fiberglass' then
EgtSetColor( nLs, Color3d(198,227,211))
EgtSetBackground( WHITE(), Color3d(210,255,210), false)
else
EgtSetColor( nLs, ORANGE())
end
EgtSetAlpha( nLs, 30)
else
EgtSetColor( nLs, BLACK())
EgtSetAlpha( nLs, 20)
EgtSetAlpha( nLa, 20)
end
local nFu, nFd
local sFlatU = 'FLAT_UP'
local sFlatU2 = 'FLAT_UP_2'
local sFlatD = 'FLAT_DW'
local sFlatD2 = 'FLAT_DW_2'
local sSideL = 'SIDE_LF'
local sSideR = 'SIDE_RH'
local sSide = 'SIDE'
local bMakeSideSurf, ptMedArc, bJoinRgt, bJoinLft = MakeSurfProfiles( nLs, sBotType, dRadProfB, sRightType, dRadProfR,
sTopType, dRadProfT, sLeftType, dRadProfL, sSide,
dPlnProfB, dPlnProfR, dPlnProfT, dPlnProf)
if not bMakeSideSurf then
local sErrMess = EgtDoorsMsg[677]
return bMakeSideSurf, 2, sErrMess
end
-- disegno facce sopra e sotto
if DGD.sFrame then
-- setto la disposizione di piatto o di fianco dei jamb laterali e superiore,
-- per quello inferiore, se le dimensioni della sezione sono sotto un certo valore, viene disposto solo di piatto
if nTypePiece == 3 then -- se frame SX
if DGD.Dws then -- se disposizione sul lato wide (di piatto)
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.RIGHT))
nFu = EgtRectangle2P( nLa, { DGD.Bur, DGD.Urb, DGD.Rub}, { DGD.Tdr, DGD.Drt, DGD.Rdt}, GDB_RT.GRID ) -- p2 a p9
nFd = EgtRectangle2P( nLa, { DGD.Bul, DGD.Ulb, DGD.Lub}, { DGD.Tdl, DGD.Dlt, DGD.Ldt}, GDB_RT.GRID ) -- p1 a p10
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
else -- altrimenti disposizione su lato narrow
nFu = EgtRectangle2P( nLa, { DGD.Lub, DGD.Bul, DGD.Ulb}, { DGD.Rut, DGD.Tur, DGD.Urt}) -- p1 a p8
nFd = EgtRectangle2P( nLa, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, { DGD.Rdt, DGD.Tdr, DGD.Drt}) -- p4 a p9
end
elseif nTypePiece == 4 then -- se frame DX
if DGD.Dws then -- se disposizione sul lato wide (di piatto)
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.LEFT))
nFu = EgtRectangle2P( nLa, { -DGD.Tdl, DGD.Dlt, -DGD.Ldt}, { -DGD.Bul, DGD.Ulb, -DGD.Lub}, GDB_RT.GRID ) -- p10 a p1
nFd = EgtRectangle2P( nLa, { -DGD.Tdr, DGD.Drt, -DGD.Rdt}, { -DGD.Bur, DGD.Urb, -DGD.Rub}, GDB_RT.GRID ) -- p9 a p2
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
else -- altrimenti disposizione su lato narrow
nFu = EgtRectangle2P( nLa, { DGD.Lub, DGD.Bul, DGD.Ulb}, { DGD.Rut, DGD.Tur, DGD.Urt}) -- p1 a p8
nFd = EgtRectangle2P( nLa, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, { DGD.Rdt, DGD.Tdr, DGD.Drt}) -- p4 a p9
end
elseif nTypePiece == 5 then -- tipo frame top
if DGD.Dws then -- se disposizione sul lato wide (di piatto)
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.FRONT))
nFu = EgtRectangle2P( nLa, { DGD.Lub, DGD.Ulb, DGD.Bul}, { DGD.Rdb, DGD.Drb, DGD.Bdr}, GDB_RT.GRID ) -- p1 a p3
nFd = EgtRectangle2P( nLa, { DGD.Lut, DGD.Ult, -DGD.Tul}, { DGD.Rdt, DGD.Drt, -DGD.Tdr}, GDB_RT.GRID ) -- p7 a p9
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
else -- altrimenti disposizione su lato narrow
nFu = EgtRectangle2P( nLa, { DGD.Lub, DGD.Bul, DGD.Ulb}, { DGD.Rut, DGD.Tur, DGD.Urt}) -- p1 a p8
nFd = EgtRectangle2P( nLa, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, { DGD.Rdt, DGD.Tdr, DGD.Drt}) -- p4 a p9
end
else -- tipo frame bottom
if DGD.Dws then -- se disposizione sul lato wide (di piatto)
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.BACK))
nFu = EgtRectangle2P( nLa, { -DGD.Ldt, DGD.Dlt, DGD.Tdl}, { -DGD.Rut, DGD.Urt, DGD.Tur}, GDB_RT.GRID ) -- p10 a p8
nFd = EgtRectangle2P( nLa, { -DGD.Ldb, DGD.Dlb, DGD.Bdl}, { -DGD.Rub, DGD.Urb, DGD.Bur}, GDB_RT.GRID ) --p4 a p2
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
else -- altrimenti disposizione su lato narrow
nFu = EgtRectangle2P( nLa, { DGD.Lub, DGD.Bul, DGD.Ulb}, { DGD.Rut, DGD.Tur, DGD.Urt}) -- p1 a p8
nFd = EgtRectangle2P( nLa, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, { DGD.Rdt, DGD.Tdr, DGD.Drt}) -- p4 a p9
end
end
else
-- se top è ad arco
if DGD.tProfs.top.radius then
-- percorso superiore
local nE1 = EgtLine( nLa, { DGD.Lub, DGD.Bul, DGD.Ulb}, { DGD.Rub, DGD.Bur, DGD.Urb}, GDB_RT.LOC) -- p1 a p2
local nE2
local nE4
local nE5
local nE6
if bJoinRgt then
nE2 = EgtLine( nLa, { DGD.Rub, DGD.Bur, DGD.Urb}, { DGD.Rua, DGD.Aur, DGD.Ura}, GDB_RT.LOC) -- p2 a p14(con XY nuova)
else
nE2 = EgtLine( nLa, { DGD.Rub, DGD.Bur, DGD.Urb}, { DGD.Rut, DGD.Aur, DGD.Ura}, GDB_RT.LOC) -- p2 a p14(con XY nuova)
nE5 = EgtLine( nLa, { DGD.Rut, DGD.Aur, DGD.Ura}, { DGD.Rua, DGD.Aur, DGD.Ura}, GDB_RT.LOC) -- linea giunzione discontinuità
end
local nE3 = EgtArcC2P( nLa, {((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Ura},
{ DGD.Rua, DGD.Aur, DGD.Ura}, { DGD.Lua, DGD.Aul, DGD.Ula}, GDB_RT.LOC) -- arco p14 a p13
-- per migliorare l'arco recupero la direzione iniziale, cancello l'arco e lo ricreo con il punto finale preciso
if nE3 then
local vcIni = EgtSV(nE3)
EgtErase(nE3)
nE3 = EgtArc2PV( nLa, { DGD.Rua, DGD.Aur, DGD.Ura}, { DGD.Lua, DGD.Aul, DGD.Ula}, vcIni, GDB_RT.LOC)
end
if bJoinLft then
nE4 = EgtLine( nLa, { DGD.Lua, DGD.Aul, DGD.Ula}, { DGD.Lub, DGD.Bul, DGD.Ulb}, GDB_RT.LOC) -- p13(con Y nuova) a p1
else
nE6 = EgtLine( nLa, { DGD.Lua, DGD.Aul, DGD.Ula}, { DGD.Lut, DGD.Aul, DGD.Ula}, GDB_RT.LOC) -- linea giunzione discontinuità
nE4 = EgtLine( nLa, { DGD.Lut, DGD.Aul, DGD.Ula}, { DGD.Lub, DGD.Bul, DGD.Ulb}, GDB_RT.LOC) -- p13(con XY nuova) a p1
end
if nE5 and nE6 then
nFu = EgtCurveCompo( nLa, {nE1,nE2,nE5,nE3,nE6,nE4}, true)
elseif nE5 and not nE6 then
nFu = EgtCurveCompo( nLa, {nE1,nE2,nE5,nE3,nE4}, true)
elseif not nE5 and nE6 then
nFu = EgtCurveCompo( nLa, {nE1,nE2,nE3,nE6,nE4}, true)
else
nFu = EgtCurveCompo( nLa, {nE1,nE2,nE3,nE4}, true)
end
-- percorso inferiore
nE5 = nil
nE6 = nil
nE1 = EgtLine( nLa, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, { DGD.Rdb, DGD.Bdr, DGD.Drb}, GDB_RT.LOC) -- p4 a p3
if bJoinRgt then
nE2 = EgtLine( nLa, { DGD.Rdb, DGD.Bdr, DGD.Drb}, { DGD.Rda, DGD.Adr, DGD.Dra}, GDB_RT.LOC) -- p3 a p15(con XY nuova)
else
nE2 = EgtLine( nLa, { DGD.Rdb, DGD.Bdr, DGD.Drb}, { DGD.Rdt, DGD.Adr, DGD.Dra}, GDB_RT.LOC) -- p3 a p15(con XY nuova)
nE5 = EgtLine( nLa, { DGD.Rdt, DGD.Adr, DGD.Dra}, { DGD.Rda, DGD.Adr, DGD.Dra}, GDB_RT.LOC) -- linea giunzione discontinuità
end
nE3 = EgtArcC2P( nLa, {((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Dra},
{ DGD.Rda, DGD.Adr, DGD.Dra}, { DGD.Lda, DGD.Adl, DGD.Dla}, GDB_RT.LOC) -- arco p15 a p16
-- per migliorare l'arco recupero la direzione iniziale, cancello l'arco e lo ricreo con il punto finale preciso
if nE3 then
local vcIni = EgtSV(nE3)
EgtErase(nE3)
nE3 = EgtArc2PV( nLa, { DGD.Rda, DGD.Adr, DGD.Dra}, { DGD.Lda, DGD.Adl, DGD.Dla}, vcIni, GDB_RT.LOC)
end
if bJoinLft then
nE4 = EgtLine( nLa, { DGD.Lda, DGD.Adl, DGD.Dla}, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, GDB_RT.LOC) -- p16 a p4
else
nE6 = EgtLine( nLa, { DGD.Lda, DGD.Adl, DGD.Dla}, { DGD.Ldt, DGD.Adl, DGD.Dla}, GDB_RT.LOC) -- linea giunzione discontinuità
nE4 = EgtLine( nLa, { DGD.Ldt, DGD.Adl, DGD.Dla}, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, GDB_RT.LOC) -- p16 a p4
end
if nE5 and nE6 then
nFd = EgtCurveCompo( nLa, {nE1,nE2,nE5,nE3,nE6,nE4}, true)
elseif nE5 and not nE6 then
nFd = EgtCurveCompo( nLa, {nE1,nE2,nE5,nE3,nE4}, true)
elseif not nE5 and nE6 then
nFd = EgtCurveCompo( nLa, {nE1,nE2,nE3,nE6,nE4}, true)
else
nFd = EgtCurveCompo( nLa, {nE1,nE2,nE3,nE4}, true)
end
elseif DGD.Tpa then -- se top è ad angolo
-- percorso superiore
local nE1 = EgtLine( nLa, { DGD.Lub, DGD.Bul, DGD.Ulb}, { DGD.Rub, DGD.Bur, DGD.Urb}, GDB_RT.LOC) -- p1 a p2
local nE2 = EgtLine( nLa, { DGD.Rub, DGD.Bur, DGD.Urb}, { DGD.Rua, DGD.Aur, DGD.Ura}, GDB_RT.LOC) -- p2 a p14
local nE3, nE4, nE5
if DGD.tProfs.top.xdeltapos > 0 then
nE3 = EgtLine( nLa, { DGD.Rua, DGD.Aur, DGD.Ura}, { DGD.Cmu, DGD.Aut, DGD.Ura}, GDB_RT.LOC) -- p14 a p19
nE4 = EgtLine( nLa, { DGD.Cmu, DGD.Aut, DGD.Ura}, { DGD.Lua, DGD.Aul, DGD.Ula}, GDB_RT.LOC) -- p19 a p13
nE5 = EgtLine( nLa, { DGD.Lua, DGD.Aul, DGD.Ula}, { DGD.Lub, DGD.Bul, DGD.Ulb}, GDB_RT.LOC) -- p13 a p1
nFu = EgtCurveCompo( nLa, {nE1,nE2,nE3,nE4,nE5}, true)
else
nE3 = EgtLine( nLa, { DGD.Rua, DGD.Aur, DGD.Ura}, { DGD.Lua, DGD.Aul, DGD.Ula}, GDB_RT.LOC) -- p14 a p13
nE4 = EgtLine( nLa, { DGD.Lua, DGD.Aul, DGD.Ula}, { DGD.Lub, DGD.Bul, DGD.Ulb}, GDB_RT.LOC) -- p13 a p1
nFu = EgtCurveCompo( nLa, {nE1,nE2,nE3,nE4}, true)
end
-- percorso inferiore
nE1 = EgtLine( nLa, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, { DGD.Rdb, DGD.Bdr, DGD.Drb}, GDB_RT.LOC) -- p4 a p3
nE2 = EgtLine( nLa, { DGD.Rdb, DGD.Bdr, DGD.Drb}, { DGD.Rda, DGD.Adr, DGD.Dra}, GDB_RT.LOC) -- p3 a p15
if DGD.tProfs.top.xdeltapos > 0 then
nE3 = EgtLine( nLa, { DGD.Rda, DGD.Adr, DGD.Dra}, { DGD.Cmd, DGD.Adt, DGD.Dra}, GDB_RT.LOC) -- p15 a p20
nE4 = EgtLine( nLa, { DGD.Cmd, DGD.Adt, DGD.Dra}, { DGD.Lda, DGD.Adl, DGD.Dla}, GDB_RT.LOC) -- p20 a p16
nE5 = EgtLine( nLa, { DGD.Lda, DGD.Adl, DGD.Dla}, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, GDB_RT.LOC) -- p16 a p4
nFd = EgtCurveCompo( nLa, {nE1,nE2,nE3,nE4,nE5}, true)
else
nE3 = EgtLine( nLa, { DGD.Rda, DGD.Adr, DGD.Dra}, { DGD.Lda, DGD.Adl, DGD.Dla}, GDB_RT.LOC) -- p15 a p16
nE4 = EgtLine( nLa, { DGD.Lda, DGD.Adl, DGD.Dla}, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, GDB_RT.LOC) -- p16 a p4
nFd = EgtCurveCompo( nLa, {nE1,nE2,nE3,nE4}, true)
end
else
if DGD.PROBE == 2 and bRemake then
EgtInvertCurve({nDoorLeft,nDoorTop,nDoorRight,nDoorBot})
EgtInvertCurve({nDoorLeftMid,nDoorTopMid,nDoorRightMid,nDoorBotMid})
EgtInvertCurve({nDoorLeftTop,nDoorTopTop,nDoorRightTop,nDoorBotTop})
nFu = EgtCurveCompo( nLa, {nDoorBotTop,nDoorRightTop,nDoorTopTop,nDoorLeftTop}, false)
nFd = EgtCurveCompo( nLa, {nDoorBot,nDoorRight,nDoorTop,nDoorLeft}, false)
else
nFu = EgtRectangle2P( nLa, { DGD.Lub, DGD.Bul, DGD.Ulb}, { DGD.Rut, DGD.Tur, DGD.Urt}) -- p1 a p8
nFd = EgtRectangle2P( nLa, { DGD.Ldb, DGD.Bdl, DGD.Dlb}, { DGD.Rdt, DGD.Tdr, DGD.Drt}) -- p4 a p9
end
end
end
local nFrU
local nFrD
local nCountSurf
if DGD.PROBE == 2 and bRemake then
nFrU = EgtSurfFlatRegion( nLs, nFu)
EgtSetName( nFrU, sFlatU2)
EgtSetAlpha( nFrU, 10)
end
nFrU = EgtSurfFlatRegion( nLs, nFu)
EgtSetName( nFrU, sFlatU)
if DGD.PROBE == 2 and bRemake then
nFrD = EgtSurfFlatRegion( nLs, nFd)
EgtInvertSurf(nFrD)
EgtSetName( nFrD, sFlatD2)
EgtSetAlpha( nFrD, 10)
end
nFrD = EgtSurfFlatRegion( nLs, nFd)
EgtInvertSurf(nFrD)
EgtSetName( nFrD, sFlatD)
-- tabelle percorsi profili
local tProPath = {}
-- disegno bordo sinistro
local nFrL
if sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == 'BD' or sLeftType == 'BU' or sLeftType == 'BDEB' or sLeftType == 'BUEB' or sLeftType == 'FDWC' then
-- disegno
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
tProPath.nClt = EgtLine( nLa, {DGD.Lut,DGD.Tul,DGD.Ult}, {DGD.Rut,DGD.Tur,DGD.Urt}) -- p7 a p8
tProPath.nClb = EgtLine( nLa, {DGD.Lub,DGD.Bul,DGD.Ulb}, {DGD.Rub,DGD.Bur,DGD.Urb}) -- p1 a p2
elseif nTypePiece == 4 then -- se frame DX
tProPath.nClt = EgtLine( nLa, {DGD.Rdt,DGD.Tdr,DGD.Drt}, {DGD.Ldt,DGD.Tdl,DGD.Dlt}) -- p9 a p10
tProPath.nClb = EgtLine( nLa, {DGD.Rdb,DGD.Bdr,DGD.Drb}, {DGD.Ldb,DGD.Bdl,DGD.Dlb}) -- p3 a p4
elseif nTypePiece == 5 then -- tipo frame top
tProPath.nClt = EgtLine( nLa, {DGD.Rut,DGD.Tur,DGD.Urt}, {DGD.Rub,DGD.Bur,DGD.Urb}) -- p8 a p2
tProPath.nClb = EgtLine( nLa, {DGD.Lut,DGD.Tul,DGD.Ult}, {DGD.Lub,DGD.Bul,DGD.Ulb}) -- p7 a p1
else -- tipo frame bottom
tProPath.nClt = EgtLine( nLa, {DGD.Rdb,DGD.Bdr,DGD.Drb}, {DGD.Rdt,DGD.Tdr,DGD.Drt}) -- p3 a p9
tProPath.nClb = EgtLine( nLa, {DGD.Ldb,DGD.Bdl,DGD.Dlb}, {DGD.Ldt,DGD.Tdl,DGD.Dlt}) -- p4 a p10
end
nFrL = EgtSurfTmRuled( nLs, tProPath.nClt, tProPath.nClb, 0.05)
EgtInvertSurf(nFrL)
EgtSetName( nFrL, sSideL)
end
-- se richiesta lavorazione
if GetEdgeToMachine( 'L') and DGD.MachEn > 0 then
local nLl = EgtGroup( DGD.PZ)
EgtSetName( nLl, 'Left')
EgtSetInfo( nLl, 'Offs', GetEdgeOffset( 'L'))
local nMId
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
nMId = EgtLine( nLl, {DGD.Lut,DGD.Tul,DGD.Ult}, {DGD.Lub,DGD.Bul,DGD.Ulb}) -- p7 a p1
elseif nTypePiece == 4 then -- se frame DX
nMId = EgtLine( nLl, {DGD.Rdt,DGD.Tdr,DGD.Drt}, {DGD.Rdb,DGD.Bdr,DGD.Drb}) -- p9 a p3
elseif nTypePiece == 5 then -- tipo frame top
nMId = EgtLine( nLl, {DGD.Rut,DGD.Tur,DGD.Urt}, {DGD.Lut,DGD.Tul,DGD.Ult}) -- p8 a p7
else -- tipo frame bottom
nMId = EgtLine( nLl, {DGD.Rdb,DGD.Bdr,DGD.Drb}, {DGD.Ldb,DGD.Bdl,DGD.Dlb}) -- p3 a p4
end
else
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Lda,max(DGD.Adl,DGD.Aul),DGD.Dla}, {DGD.Ldb,min(DGD.Bdl,DGD.Bul,DGD.Bml),DGD.Dlb}) -- p16 a p4
else
nMId = EgtLine( nLl, {DGD.Ldt,max(DGD.Tdl,DGD.Tul,DGD.Tml),DGD.Dlt}, {DGD.Ldb,min(DGD.Bdl,DGD.Bul,DGD.Bml),DGD.Dlb}) -- p10 a p4
end
end
if sLeftType == 'BD' or sLeftType == 'BU' or sLeftType == 'BDEB' or sLeftType == 'BUEB' then
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
if sLeftType == 'BD' or sLeftType == 'BDEB' then
EgtModifyCurveExtrusion( nMId, Vector3d( COS3, 0, SIN3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( COS3, 0, -SIN3), GDB_RT.GLOB)
end
elseif nTypePiece == 4 then -- se frame DX
if sLeftType == 'BD' or sLeftType == 'BDEB' then
EgtModifyCurveExtrusion( nMId, Vector3d( -COS3, 0, -SIN3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( -COS3, 0, SIN3), GDB_RT.GLOB)
end
elseif nTypePiece == 5 then -- tipo frame top
if sLeftType == 'BD' or sLeftType == 'BDEB' then
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -COS3, SIN3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -COS3, -SIN3), GDB_RT.GLOB)
end
else -- tipo frame bottom
if sLeftType == 'BD' or sLeftType == 'BDEB' then
EgtModifyCurveExtrusion( nMId, Vector3d( 0, COS3, -SIN3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( 0, COS3, SIN3), GDB_RT.GLOB)
end
end
else
-- se lato sinistro con serratura e senza maniglia e abilitata la funzione
-- di inversione automatica bevel sul lato inactive o discordanza tra i due profili, inverto l'inclinazione
if DGD.Lock == 'L' and ( DGD.sSwing == 'RHI' or DGD.sSwing == 'RHRI') and
( ( DGD.RevInBv and DGD.RevInBv == 1) or DGD.bBothOppoBevel) then
if DGD.Push then
EgtModifyCurveExtrusion( nMId, Vector3d( -SIN3, 0, COS3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( SIN3, 0, COS3), GDB_RT.GLOB)
end
else
if DGD.Push then
EgtModifyCurveExtrusion( nMId, Vector3d( SIN3, 0, COS3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( -SIN3, 0, COS3), GDB_RT.GLOB)
end
end
end
if DGD.sFrame then
if nTypePiece == 3 or nTypePiece == 4 then -- se frame SX o DX
EgtModifyCurveThickness( nMId, DGD.dW / COS3)
else
EgtModifyCurveThickness( nMId, DGD.dH / COS3)
end
else
EgtModifyCurveThickness( nMId, DGD.dT / COS3)
end
else
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
EgtModifyCurveExtrusion( nMId, Vector3d( 1, 0, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dW)
elseif nTypePiece == 4 then -- se frame DX
EgtModifyCurveExtrusion( nMId, Vector3d( -1, 0, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dW)
elseif nTypePiece == 5 then -- tipo frame top
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -1, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dH)
else -- tipo frame bottom
EgtModifyCurveExtrusion( nMId, Vector3d( 0, 1, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dH)
end
else
EgtModifyCurveThickness( nMId, DGD.dT)
end
end
EgtSetName( nMId, sLeftType .. EgtIf( string.find( sLeftType,'EB'), DGD.EBP, ''))
EgtSetColor( nMId, BLACK())
if DGD.Lock == 'L' then
EgtSetInfo( nMId, 'EdgeDoor', 'L')
else
EgtSetInfo( nMId, 'EdgeDoor', 'H')
end
end
elseif sLeftType == '1B' or sLeftType == '2B' or sLeftType == '3B' or sLeftType == '4B' or
sLeftType == '5B' or sLeftType == '6B' or sLeftType == '7B' or sLeftType == '8B' then
-- setto la griglia di fronte : da rivedere
if DGD.PROBE == 2 and bRemake then
tProPath.nClb = EgtArc3P( nLa, {DGD.Ldb,DGD.Bdl,DGD.Dlb}, {DGD.Lmb,DGD.Bml,DGD.Mlb}, {DGD.Lub,DGD.Bul,DGD.Ulb}) -- p4 a p5 a p1
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
tProPath.nClt = EgtArc3P( nLa, {DGD.Lda,DGD.Adl,DGD.Dla}, {DGD.Lma,DGD.Aml,DGD.Mla}, {DGD.Lua,DGD.Aul,DGD.Ula}) -- p16 a p17 a p13
else
tProPath.nClt = EgtArc3P( nLa, {DGD.Ldt,DGD.Tdl,DGD.Dlt}, {DGD.Lmt,DGD.Tml,DGD.Mlt}, {DGD.Lut,DGD.Tul,DGD.Ult}) -- p10 a p11 a p7
end
nFrL = EgtSurfTmRuled( nLs, tProPath.nClt, tProPath.nClb, 0.05)
EgtInvertSurf(nFrL)
EgtSetName( nFrL, sSideL)
end
-- se richiesta lavorazione
if GetEdgeToMachine( 'L') and DGD.MachEn > 0 then
local nLl = EgtGroup( DGD.PZ)
EgtSetName( nLl, 'Left')
EgtSetInfo( nLl, 'Offs', GetEdgeOffset( 'L'))
local nMId
if DGD.PROBE == 2 and bRemake then
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Lma, DGD.Aml, DGD.Dla}, { DGD.Lmb, DGD.Bml, DGD.Dlb}) -- pmu a pmd
else
nMId = EgtLine( nLl, {DGD.Lmt, DGD.Tml, DGD.Dlt}, { DGD.Lmb, DGD.Bml, DGD.Dlb}) -- pmu a pmd
end
else
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Lm, max(DGD.Adl,DGD.Aul), DGD.Dla}, { DGD.Lm, min(DGD.Bdl,DGD.Bul,DGD.Bml), DGD.Dlb}) -- pmu a pmd
else
nMId = EgtLine( nLl, {DGD.Lm, max(DGD.Tdl,DGD.Tul,DGD.Tml), DGD.Dlt}, { DGD.Lm, min(DGD.Bdl,DGD.Bul,DGD.Bml), DGD.Dlb}) -- pmu a pmd
end
end
EgtModifyCurveThickness( nMId, DGD.dT)
EgtSetName( nMId, sLeftType)
EgtSetColor( nMId, BLACK())
if DGD.Lock == 'L' then
EgtSetInfo( nMId, 'EdgeDoor', 'L')
else
EgtSetInfo( nMId, 'EdgeDoor', 'H')
end
end
elseif sLeftType == 'CV' then
-- setto la griglia di fronte: da rivedere
if DGD.PROBE == 2 and bRemake then
tProPath.nClb = EgtArc3P( nLa, {DGD.Ldb,DGD.Bdl,DGD.Dlb}, {DGD.Lmb,DGD.Bml,DGD.Mlb}, {DGD.Lub,DGD.Bul,DGD.Ulb}) -- p4 a p5 a p1
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
tProPath.nClt = EgtArc3P( nLa, {DGD.Lda,DGD.Adl,DGD.Dla}, {DGD.Lma,DGD.Aml,DGD.Mla}, {DGD.Lua,DGD.Aul,DGD.Ula}) -- p16 a p17 a p13
else
tProPath.nClt = EgtArc3P( nLa, {DGD.Ldt,DGD.Tdl,DGD.Dlt}, {DGD.Lmt,DGD.Tml,DGD.Mlt}, {DGD.Lut,DGD.Tul,DGD.Ult}) -- p10 a p11 a p7
end
nFrL = EgtSurfTmRuled( nLs, tProPath.nClt, tProPath.nClb, 0.05)
EgtInvertSurf(nFrL)
EgtSetName( nFrL, sSideL)
end
-- se richiesta lavorazione
if GetEdgeToMachine( 'L') and DGD.MachEn > 0 then
local nLl = EgtGroup( DGD.PZ)
EgtSetName( nLl, 'Left')
EgtSetInfo( nLl, 'Offs', GetEdgeOffset( 'L'))
local nMId
if DGD.PROBE == 2 and bRemake then
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Lma, DGD.Aml, DGD.Dla}, { DGD.Lmb, DGD.Bml, DGD.Dlb}) -- pmu a pmd
else
nMId = EgtLine( nLl, {DGD.Lmt, DGD.Tml, DGD.Dlt}, { DGD.Lmb, DGD.Bml, DGD.Dlb}) -- pmu a pmd
end
else
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Lm, max(DGD.Adl,DGD.Aul), DGD.Dla}, { DGD.Lm, min(DGD.Bdl,DGD.Bul,DGD.Bml), DGD.Dlb}) -- pmu a pmd
else
nMId = EgtLine( nLl, {DGD.Lm, max(DGD.Tdl,DGD.Tul,DGD.Tml), DGD.Dlt}, { DGD.Lm, min(DGD.Bdl,DGD.Bul,DGD.Bml), DGD.Dlb}) -- pmu a pmd
end
end
EgtModifyCurveThickness( nMId, DGD.dT)
EgtSetName( nMId, sLeftType)
EgtSetColor( nMId, BLACK())
if DGD.Lock == 'L' then
EgtSetInfo( nMId, 'EdgeDoor', 'L')
else
EgtSetInfo( nMId, 'EdgeDoor', 'H')
end
end
end
-- disegno bordo destro
local nFrR
if sRightType == 'SQ' or sRightType == 'EB' or sRightType == 'BD' or sRightType == 'BU' or sRightType == 'BDEB' or sRightType == 'BUEB' or sRightType == 'FDWC' then
-- disegno
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
tProPath.nCrt = EgtLine( nLa, {DGD.Ldt,DGD.Tdl,DGD.Dlt}, {DGD.Rdt,DGD.Tdr,DGD.Drt}) -- p10 a p9
tProPath.nCrb = EgtLine( nLa, {DGD.Ldb,DGD.Bdl,DGD.Dlb}, {DGD.Rdb,DGD.Bdr,DGD.Drb}) -- p4 a p3
elseif nTypePiece == 4 then -- se frame DX
tProPath.nCrt = EgtLine( nLa, {DGD.Rut,DGD.Tur,DGD.Urt}, {DGD.Lut,DGD.Tul,DGD.Ult}) -- p8 a p7
tProPath.nCrb = EgtLine( nLa, {DGD.Rub,DGD.Bur,DGD.Urb}, {DGD.Lub,DGD.Bul,DGD.Ulb}) -- p2 a p1
elseif nTypePiece == 5 then -- tipo frame top
tProPath.nCrt = EgtLine( nLa, {DGD.Rdt,DGD.Tdr,DGD.Drt}, {DGD.Rdb,DGD.Bdr,DGD.Drb}) -- p9 a p3
tProPath.nCrb = EgtLine( nLa, {DGD.Ldt,DGD.Tdl,DGD.Dlt}, {DGD.Ldb,DGD.Bdl,DGD.Dlb}) -- p10 a p4
else -- tipo frame bottom
tProPath.nCrt = EgtLine( nLa, {DGD.Rub,DGD.Bur,DGD.Urb}, {DGD.Rut,DGD.Tur,DGD.Urt}) -- p2 a p8
tProPath.nCrb = EgtLine( nLa, {DGD.Lub,DGD.Bul,DGD.Ulb}, {DGD.Lut,DGD.Tul,DGD.Ult}) -- p1 a p7
end
nFrR = EgtSurfTmRuled( nLs, tProPath.nCrt, tProPath.nCrb, 0.05)
EgtSetName( nFrR, sSideR)
end
-- se richiesta lavorazione
if GetEdgeToMachine( 'R') and DGD.MachEn > 0 then
local nLl = EgtGroup( DGD.PZ)
EgtSetName( nLl, 'Right')
EgtSetInfo( nLl, 'Offs', GetEdgeOffset( 'R'))
local nMId
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
nMId = EgtLine( nLl, {DGD.Ldb,DGD.Bdl,DGD.Dlb}, {DGD.Ldt,DGD.Tdl,DGD.Dlt}) -- p4 a p10
elseif nTypePiece == 4 then -- se frame DX
nMId = EgtLine( nLl, {DGD.Rub,DGD.Bur,DGD.Urb}, {DGD.Rut,DGD.Tur,DGD.Urt}) -- p2 a p8
elseif nTypePiece == 5 then -- tipo frame top
nMId = EgtLine( nLl, {DGD.Ldt,DGD.Tdl,DGD.Dlt}, {DGD.Rdt,DGD.Tdr,DGD.Drt}) -- p10 a p9
else -- tipo frame bottom
nMId = EgtLine( nLl, {DGD.Lub,DGD.Bul,DGD.Ulb}, {DGD.Rub,DGD.Bur,DGD.Urb}) -- p1 a p2
end
else
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Rdb,min(DGD.Bdr,DGD.Bur),DGD.Drb}, {DGD.Rda,max(DGD.Adr,DGD.Aur),DGD.Dra}) -- p3 a p15
else
nMId = EgtLine( nLl, {DGD.Rdb,min(DGD.Bdr,DGD.Bur,DGD.Bmr),DGD.Drb}, {DGD.Rdt,max(DGD.Tdr,DGD.Tur,DGD.Tmr),DGD.Drt}) -- p3 a p9
end
end
if sRightType == 'BD' or sRightType == 'BU' or sRightType == 'BDEB' or sRightType == 'BUEB' then
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
if sRightType == 'BD' or sRightType == 'BDEB' then
EgtModifyCurveExtrusion( nMId, Vector3d( COS3, 0, -SIN3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( COS3, 0, SIN3), GDB_RT.GLOB)
end
elseif nTypePiece == 4 then -- se frame DX
if sRightType == 'BD' or sRightType == 'BDEB' then
EgtModifyCurveExtrusion( nMId, Vector3d( -COS3, 0, SIN3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( -COS3, 0, -SIN3), GDB_RT.GLOB)
end
elseif nTypePiece == 5 then -- tipo frame top
if sRightType == 'BD' or sRightType == 'BDEB' then
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -COS3, -SIN3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -COS3, SIN3), GDB_RT.GLOB)
end
else -- tipo frame bottom
if sRightType == 'BD' or sRightType == 'BDEB' then
EgtModifyCurveExtrusion( nMId, Vector3d( 0, COS3, SIN3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( 0, COS3, -SIN3), GDB_RT.GLOB)
end
end
else
-- se lato destro con serratura e senza maniglia e abilitata la funzione
-- di inversione automatica bevel sul lato inactive o discordanza tra i due profili, inverto l'inclinazione
if DGD.Lock == 'R' and ( DGD.sSwing == 'LHI' or DGD.sSwing == 'LHRI') and
( ( DGD.RevInBv and DGD.RevInBv == 1) or DGD.bBothOppoBevel) then
if DGD.Push then
EgtModifyCurveExtrusion( nMId, Vector3d( SIN3, 0, COS3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( -SIN3, 0, COS3), GDB_RT.GLOB)
end
else
if DGD.Push then
EgtModifyCurveExtrusion( nMId, Vector3d( -SIN3, 0, COS3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( SIN3, 0, COS3), GDB_RT.GLOB)
end
end
end
if DGD.sFrame then
if nTypePiece == 3 or nTypePiece == 4 then -- se frame SX o DX
EgtModifyCurveThickness( nMId, DGD.dW / COS3)
else
EgtModifyCurveThickness( nMId, DGD.dH / COS3)
end
else
EgtModifyCurveThickness( nMId, DGD.dT / COS3)
end
else
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
EgtModifyCurveExtrusion( nMId, Vector3d( 1, 0, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dW)
elseif nTypePiece == 4 then -- se frame DX
EgtModifyCurveExtrusion( nMId, Vector3d( -1, 0, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dW)
elseif nTypePiece == 5 then -- tipo frame top
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -1, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dH)
else -- tipo frame bottom
EgtModifyCurveExtrusion( nMId, Vector3d( 0, 1, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dH)
end
else
EgtModifyCurveThickness( nMId, DGD.dT)
end
end
EgtSetName( nMId, sRightType .. EgtIf( string.find( sRightType,'EB'), DGD.EBP, ''))
EgtSetColor( nMId, BLACK())
if DGD.Lock == 'L' then
EgtSetInfo( nMId, 'EdgeDoor', 'H')
else
EgtSetInfo( nMId, 'EdgeDoor', 'L')
end
end
elseif sRightType == '1B' or sRightType == '2B' or sRightType == '3B' or sRightType == '4B' or
sRightType == '5B' or sRightType == '6B' or sRightType == '7B' or sRightType == '8B' then
-- setto la griglia di fronte: da rivedere
if DGD.PROBE == 2 and bRemake then
tProPath.nCrb = EgtArc3P( nLa, {DGD.Rdb,DGD.Bdr,DGD.Drb}, {DGD.Rmb,DGD.Bmr,DGD.Mrb}, {DGD.Rub,DGD.Bur,DGD.Urb}) -- p3 a p6 a p2
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
tProPath.nCrt = EgtArc3P( nLa, {DGD.Rda,DGD.Adr,DGD.Dra}, {DGD.Rma,DGD.Amr,DGD.Mra}, {DGD.Rua,DGD.Aur,DGD.Ura}) -- p15 a p18 a p14
else
tProPath.nCrt = EgtArc3P( nLa, {DGD.Rdt,DGD.Tdr,DGD.Drt}, {DGD.Rmt,DGD.Tmr,DGD.Mrt}, {DGD.Rut,DGD.Tur,DGD.Urt}) -- p9 a p12 a p8
end
nFrR = EgtSurfTmRuled( nLs, tProPath.nCrt, tProPath.nCrb, 0.05)
EgtSetName( nFrR, sSideR)
end
-- se richiesta lavorazione
if GetEdgeToMachine( 'R') and DGD.MachEn > 0 then
local nLl = EgtGroup( DGD.PZ)
EgtSetName( nLl, 'Right')
EgtSetInfo( nLl, 'Offs', GetEdgeOffset( 'R'))
local nMId
if DGD.PROBE == 2 and bRemake then
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Rmb, DGD.Bmr, DGD.Drb}, { DGD.Rma, DGD.Amr, DGD.Dra}) -- pmd a pmu
else
nMId = EgtLine( nLl, {DGD.Rmb, DGD.Bmr, DGD.Drb}, { DGD.Rmt, DGD.Tmr, DGD.Drt}) -- pmd a pmu
end
else
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Rm, min(DGD.Bdr,DGD.Bur), DGD.Drb}, { DGD.Rm, max(DGD.Adr,DGD.Aur), DGD.Dra}) -- pmd a pmu
else
nMId = EgtLine( nLl, {DGD.Rm, min(DGD.Bdr,DGD.Bur,DGD.Bmr), DGD.Drb}, { DGD.Rm, max(DGD.Tdr,DGD.Tur,DGD.Tmr), DGD.Drt}) -- pmd a pmu
end
end
EgtModifyCurveThickness( nMId, DGD.dT)
EgtSetName( nMId, sRightType)
EgtSetColor( nMId, BLACK())
if DGD.Lock == 'L' then
EgtSetInfo( nMId, 'EdgeDoor', 'H')
else
EgtSetInfo( nMId, 'EdgeDoor', 'L')
end
end
elseif sRightType == 'CV' then
-- setto la griglia di fronte: da rivedere
if DGD.PROBE == 2 and bRemake then
tProPath.nCrb = EgtArc3P( nLa, {DGD.Rdb,DGD.Bdr,DGD.Drb}, {DGD.Rmb,DGD.Bmr,DGD.Mrb}, {DGD.Rub,DGD.Bur,DGD.Urb}) -- p3 a p6 a p2
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
tProPath.nCrt = EgtArc3P( nLa, {DGD.Rda,DGD.Adr,DGD.Dra}, {DGD.Rma,DGD.Amr,DGD.Mra}, {DGD.Rua,DGD.Aur,DGD.Ura}) -- p15 a p18 a p14
else
tProPath.nCrt = EgtArc3P( nLa, {DGD.Rdt,DGD.Tdr,DGD.Drt}, {DGD.Rmt,DGD.Tmr,DGD.Mrt}, {DGD.Rut,DGD.Tur,DGD.Urt}) -- p9 a p12 a p8
end
nFrR = EgtSurfTmRuled( nLs, tProPath.nCrt, tProPath.nCrb, 0.05)
EgtSetName( nFrR, sSideR)
end
-- se richiesta lavorazione
if GetEdgeToMachine( 'R') and DGD.MachEn > 0 then
local nLl = EgtGroup( DGD.PZ)
EgtSetName( nLl, 'Right')
EgtSetInfo( nLl, 'Offs', GetEdgeOffset( 'R'))
local nMId
if DGD.PROBE == 2 and bRemake then
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Rmb, DGD.Bmr, DGD.Drb}, { DGD.Rma, DGD.Amr, DGD.Dra}) -- pmd a pmu
else
nMId = EgtLine( nLl, {DGD.Rmb, DGD.Bmr, DGD.Drb}, { DGD.Rmt, DGD.Tmr, DGD.Drt}) -- pmd a pmu
end
else
-- se top è ad arco e solo in modalità disegno
if ( DGD.tProfs.top.radius or DGD.Tpa) and DGD.MachEn == 0 then
nMId = EgtLine( nLl, {DGD.Rm, min(DGD.Bdr,DGD.Bur), DGD.Drb}, { DGD.Rm, max(DGD.Adr,DGD.Aur), DGD.Dra}) -- pmd a pmu
else
nMId = EgtLine( nLl, {DGD.Rm, min(DGD.Bdr,DGD.Bur,DGD.Bmr), DGD.Drb}, { DGD.Rm, max(DGD.Tdr,DGD.Tur,DGD.Tmr), DGD.Drt}) -- pmd a pmu
end
end
EgtModifyCurveThickness( nMId, DGD.dT)
EgtSetName( nMId, sRightType)
EgtSetColor( nMId, BLACK())
if DGD.Lock == 'L' then
EgtSetInfo( nMId, 'EdgeDoor', 'H')
else
EgtSetInfo( nMId, 'EdgeDoor', 'L')
end
end
end
-- bordo in basso
-- se richiesta lavorazione
if GetEdgeToMachine( 'B') and DGD.MachEn > 0 then
local nLl = EgtGroup( DGD.PZ)
EgtSetName( nLl, 'Bottom')
EgtSetInfo( nLl, 'Offs', DGD.tProfs.bottom.offset)
local nMId, nAsl, nAsr
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
nMId = EgtLine( nLl, {DGD.Lub,DGD.Bul,DGD.Ulb}, {DGD.Ldb,DGD.Bdl,DGD.Dlb}) -- p1 a p4
EgtModifyCurveExtrusion( nMId, Vector3d( 1, 0, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dW)
elseif nTypePiece == 4 then -- se frame DX
nMId = EgtLine( nLl, {DGD.Rdb,DGD.Bdr,DGD.Drb}, {DGD.Rub,DGD.Bur,DGD.Urb}) -- p3 a p2
EgtModifyCurveExtrusion( nMId, Vector3d( -1, 0, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dW)
elseif nTypePiece == 5 then -- tipo frame top
nMId = EgtLine( nLl, {DGD.Lut,DGD.Tul,DGD.Ult}, {DGD.Ldt,DGD.Tdl,DGD.Dlt}) -- p7 a p10
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -1, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dH)
else -- tipo frame bottom
nMId = EgtLine( nLl, {DGD.Ldb,DGD.Bdl,DGD.Dlb}, {DGD.Lub,DGD.Bul,DGD.Ulb}) -- p4 a p1
EgtModifyCurveExtrusion( nMId, Vector3d( 0, 1, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dH)
end
EgtSetName( nMId, 'SQ_H')
EgtSetColor( nMId, BLACK())
else
if sBotType == 'BD' or sBotType == 'BU' or sBotType == 'BDEB' or sBotType == 'BUEB' then
nMId = EgtLine( nLl, {min(DGD.Ldb,DGD.Lm,DGD.Lub),DGD.Bdl,DGD.Dlb}, {max(DGD.Rdb,DGD.Rm,DGD.Rub),DGD.Bdr,DGD.Drb}) -- p4 a p3
if DGD.Push then
EgtModifyCurveExtrusion( nMId, Vector3d( 0, SIN3, COS3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -SIN3, COS3), GDB_RT.GLOB)
end
EgtModifyCurveThickness( nMId, DGD.dT / COS3)
elseif sBotType == '1B' or sBotType == '2B' or sBotType == '3B' or sBotType == '4B' or
sBotType == '5B' or sBotType == '6B' or sBotType == '7B' or sBotType == '8B' then
nMId = EgtLine( nLl, {min(DGD.Ldb,DGD.Lm,DGD.Lub),DGD.Bml,DGD.Dlb}, {max(DGD.Rdb,DGD.Rm,DGD.Rub),DGD.Bmr,DGD.Drb}) -- p5 a p6 con Z0
EgtModifyCurveThickness( nMId, DGD.dT)
elseif sBotType == 'CV' then
nMId = EgtLine( nLl, {min(DGD.Ldb,DGD.Lm,DGD.Lub),DGD.Bml,DGD.Dlb}, {max(DGD.Rdb,DGD.Rm,DGD.Rub),DGD.Bmr,DGD.Drb}) -- p4 a p3
EgtModifyCurveThickness( nMId, DGD.dT)
else -- SQ/EB/FDWC
nMId = EgtLine( nLl, {min(DGD.Ldb,DGD.Lm,DGD.Lub),DGD.Bdl,DGD.Dlb}, {max(DGD.Rdb,DGD.Rm,DGD.Rub),DGD.Bdr,DGD.Drb}) -- p4 a p3
EgtModifyCurveThickness( nMId, DGD.dT)
end
-- creo percorsi anti-scheggia lungo lo spessore
if not ( sBotType == '1B' or sBotType == '2B' or sBotType == '3B' or sBotType == '4B' or
sBotType == '5B' or sBotType == '6B' or sBotType == '7B' or sBotType == '8B' or
sBotType == 'CV') then
-- griglia a sinistra per percorso a sinistra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.LEFT))
if sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == 'BD' or sLeftType == 'BU' or sLeftType == 'BDEB' or sLeftType == 'BUEB' or sLeftType == 'FDWC' then
nAsl = EgtLine( nLl, {-DGD.Bdl,DGD.Dlb,-DGD.Ldb}, {-DGD.Bul,DGD.Ulb,-DGD.Lub}, GDB_RT.GRID) -- p4 a p1
else
nAsl = EgtLine( nLl, {-DGD.Bdl,DGD.Dlb,-(min(DGD.Ldb,DGD.Lm,DGD.Lub))}, {-DGD.Bul,DGD.Ulb,-(min(DGD.Ldb,DGD.Lm,DGD.Lub))}, GDB_RT.GRID) -- p4 a p1
end
EgtModifyCurveThickness( nAsl, 0)
EgtSetColor( nAsl, BLACK())
-- griglia a destra per percorso a destra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.RIGHT))
if sRightType == 'SQ' or sRightType == 'EB' or sRightType == 'BD' or sRightType == 'BU' or sRightType == 'BDEB' or sRightType == 'BUEB' or sRightType == 'FDWC' then
nAsr = EgtLine( nLl, {DGD.Bur,DGD.Urb,DGD.Rub}, {DGD.Bdr,DGD.Drb,DGD.Rdb}, GDB_RT.GRID) -- p2 a p3
else
nAsr = EgtLine( nLl, {DGD.Bur,DGD.Urb,max(DGD.Rub,DGD.Rm,DGD.Rdb)}, {DGD.Bdr,DGD.Drb,max(DGD.Rub,DGD.Rm,DGD.Rdb)}, GDB_RT.GRID) -- p2 a p3
end
EgtModifyCurveThickness( nAsr, 0)
EgtSetColor( nAsr, BLACK())
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
if DGD.Lock == 'R' then
EgtSetName( nAsl, 'ASLB_HNG') -- indico nel nome che è sul lato hinge
EgtSetName( nAsr, 'ASRB')
else
EgtSetName( nAsl, 'ASLB')
EgtSetName( nAsr, 'ASRB_HNG') -- indico nel nome che è sul lato hinge
end
end
EgtSetName( nMId, sBotType .. EgtIf( string.find( sBotType,'EB'), DGD.EBP, '') .. '_H')
EgtSetColor( nMId, BLACK())
end
EgtSetInfo( nMId, 'EdgeDoor', 'B')
end
-- bordo in alto
-- se richiesta lavorazione
if GetEdgeToMachine( 'T') and DGD.MachEn > 0 then
local nLl = EgtGroup( DGD.PZ)
EgtSetName( nLl, 'Top')
EgtSetInfo( nLl, 'Offs', DGD.tProfs.top.offset)
local nMId, nAsl, nAsr
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
nMId = EgtLine( nLl, {DGD.Ldt,DGD.Tdl,DGD.Dlt}, {DGD.Lut,DGD.Tul,DGD.Ult}) -- p10 a p7
EgtModifyCurveExtrusion( nMId, Vector3d( 1, 0, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dW)
elseif nTypePiece == 4 then -- se frame DX
nMId = EgtLine( nLl, {DGD.Rut,DGD.Tur,DGD.Urt}, {DGD.Rdt,DGD.Tdr,DGD.Drt}) -- p8 a p9
EgtModifyCurveExtrusion( nMId, Vector3d( -1, 0, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dW)
elseif nTypePiece == 5 then -- tipo frame top
nMId = EgtLine( nLl, {DGD.Rdt,DGD.Tdr,DGD.Drt}, {DGD.Rut,DGD.Tur,DGD.Urt}) -- p9 a p8
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -1, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dH)
else -- tipo frame bottom
nMId = EgtLine( nLl, {DGD.Rub,DGD.Bur,DGD.Urb}, {DGD.Rdb,DGD.Bdr,DGD.Drb}) -- p2 a p3
EgtModifyCurveExtrusion( nMId, Vector3d( 0, 1, 0), GDB_RT.GLOB)
EgtModifyCurveThickness( nMId, DGD.dH)
end
EgtSetName( nMId, 'SQ_H')
EgtSetColor( nMId, BLACK())
else
-- se top è ad arco
if DGD.tProfs.top.radius then
if sTopType == 'BD' or sTopType == 'BU' or sTopType == 'BDEB' or sTopType == 'BUEB' or
sTopType == 'SQ' or sTopType == 'EB' or sTopType == 'BV' or sTopType == 'BVEB' or
sTopType == 'FDWC' then -- profilo top
if DGD.Push then -- se a spingere percorso con punti da curva sopra spessore (la curva più stretta)
nMId = EgtArcC2P( nLl, {((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Dra},
{ DGD.rma, DGD.amr, DGD.Dra}, { DGD.lma, DGD.aml, DGD.Dla}, GDB_RT.LOC) -- arco p22 a p23
-- nMId = EgtArcC2P( nLl, {((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Dra},
-- { DGD.Rua, DGD.Aur, DGD.Dra}, { DGD.Lua, DGD.Aul, DGD.Dla}, GDB_RT.LOC) -- arco p22 a p23
else -- altrimenti a tirare percorso con punti da curva sotto (la curva più stretta)
nMId = EgtArcC2P( nLl, {((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Dra},
{ DGD.rma, DGD.amr, DGD.Dra}, { DGD.lma, DGD.aml, DGD.Dla}, GDB_RT.LOC) -- arco p24 a p25
-- nMId = EgtArcC2P( nLl, {((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Dra},
-- { DGD.Rda, DGD.Adr, DGD.Dra}, { DGD.Lda, DGD.Adl, DGD.Dla}, GDB_RT.LOC) -- arco p24 a p25
end
elseif sTopType == 'CV' then
nMId = EgtArcC2P( nLl, {((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Dra},
{ DGD.rma, DGD.amr, DGD.Dra}, { DGD.lma, DGD.aml, DGD.Dla}, GDB_RT.LOC) -- arco interno P24 a P25
else
nMId = EgtArcC2P( nLl, {((DGD.dW/2)+DGD.tProfs.top.xdeltapos), (DGD.dH-DGD.tProfs.top.ydeltapos), DGD.Dra},
{ DGD.RMa, DGD.AMr, DGD.Dra}, { DGD.LMa, DGD.AMl, DGD.Dla}, GDB_RT.LOC) -- arco p22 a p23
end
EgtModifyCurveThickness( nMId, DGD.dT)
EgtSetName( nMId, sTopType .. EgtIf( string.find( sTopType,'EB'), DGD.EBP, '') .. '_H')
EgtSetColor( nMId, BLACK())
EgtSetInfo( nMId, 'EdgeDoor', 'T')
elseif DGD.Tpa then -- se top ad angolo
if sTopType == 'BD' or sTopType == 'BU' or sTopType == 'BDEB' or sTopType == 'BUEB' or
sTopType == 'SQ' or sTopType == 'EB' or sTopType == 'BV' or sTopType == 'BVEB' or
sTopType == 'FDWC' then -- profilo top
if DGD.Push then
if DGD.tProfs.top.xdeltapos > 0 then
local nE1 = EgtLine( nLl, {DGD.Rua,DGD.Aur,DGD.Dra}, {DGD.Cmu,DGD.Aut,DGD.Dla}) -- p14 a p19
local nE2 = EgtLine( nLl, {DGD.Cmu,DGD.Aut,DGD.Dla}, {DGD.Lua,DGD.Aul,DGD.Dla}) -- p19 a p13
-- eventuale allungamento percorso sull'inizio
local dDistMax = max(DGD.Rda,DGD.Rua,DGD.Rma) - min(DGD.Rda,DGD.Rua,DGD.Rma)
if dDistMax > GEO.EPS_SMALL and abs(max(DGD.Rda,DGD.Rua,DGD.Rma) - DGD.Rua) > GEO.EPS_SMALL then
local sVecIni = EgtSV(nE1)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nE1, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)) ,{DGD.Rua,DGD.Aur,DGD.Dra})
end
-- eventuale allungamento percorso sulla fine
dDistMax = max(DGD.Lda,DGD.Lua,DGD.Lma) - min(DGD.Lda,DGD.Lua,DGD.Lma)
if dDistMax > GEO.EPS_SMALL and abs(min(DGD.Lda,DGD.Lua,DGD.Lma) - DGD.Lua) > GEO.EPS_SMALL then
local sVecIni = EgtEV(nE2)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nE2, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)), {DGD.Lua,DGD.Aul,DGD.Dla})
end
nMId = EgtCurveCompo( nLl, {nE1,nE2}, true)
else
nMId = EgtLine( nLl, {DGD.Rua,DGD.Aur,DGD.Dra}, {DGD.Lua,DGD.Aul,DGD.Dla}) -- p14 a p13
-- eventuale allungamento percorso sull'inizio
local dDistMax = max(DGD.Rda,DGD.Rua,DGD.Rma) - min(DGD.Rda,DGD.Rua,DGD.Rma)
if dDistMax > GEO.EPS_SMALL and abs(max(DGD.Rda,DGD.Rua,DGD.Rma) - DGD.Rua) > GEO.EPS_SMALL then
local sVecIni = EgtSV(nMId)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nMId, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)) ,{DGD.Rua,DGD.Aur,DGD.Dra})
end
-- eventuale allungamento percorso sulla fine
dDistMax = max(DGD.Lda,DGD.Lua,DGD.Lma) - min(DGD.Lda,DGD.Lua,DGD.Lma)
if dDistMax > GEO.EPS_SMALL and abs(min(DGD.Lda,DGD.Lua,DGD.Lma) - DGD.Lua) > GEO.EPS_SMALL then
local sVecIni = EgtEV(nMId)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nMId, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)), {DGD.Lua,DGD.Aul,DGD.Dla})
end
end
else
if DGD.tProfs.top.xdeltapos > 0 then
local nE1 = EgtLine( nLl, {DGD.Rda,DGD.Adr,DGD.Dra}, {DGD.Cmd,DGD.Adt,DGD.Drt}) -- p15 a p20
local nE2 = EgtLine( nLl, {DGD.Cmd,DGD.Adt,DGD.Drt}, {DGD.Lda,DGD.Adl,DGD.Dla}) -- p20 a p16
-- eventuale allungamento percorso sull'inizio
local dDistMax = max(DGD.Rda,DGD.Rua,DGD.Rma) - min(DGD.Rda,DGD.Rua,DGD.Rma)
if dDistMax > GEO.EPS_SMALL and abs( max(DGD.Rda,DGD.Rua,DGD.Rma) - DGD.Rda) > GEO.EPS_SMALL then
local sVecIni = EgtSV(nE1)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nE1, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)) ,{DGD.Rda,DGD.Adr,DGD.Dra})
end
-- eventuale allungamento percorso sulla fine
dDistMax = max( DGD.Lda,DGD.Lua,DGD.Lma) - min(DGD.Lda,DGD.Lua,DGD.Lma)
if dDistMax > GEO.EPS_SMALL and abs( min(DGD.Lda,DGD.Lua,DGD.Lma) - DGD.Lda) > GEO.EPS_SMALL then
local sVecIni = EgtEV(nE2)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nE2, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)), {DGD.Lda,DGD.Adl,DGD.Dla})
end
nMId = EgtCurveCompo( nLl, {nE1,nE2}, true)
else
nMId = EgtLine( nLl, {DGD.Rda,DGD.Adr,DGD.Dra}, {DGD.Lda,DGD.Adl,DGD.Dla}) -- p15 a p16
-- eventuale allungamento percorso sull'inizio
local dDistMax = max(DGD.Rda,DGD.Rua,DGD.Rma) - min(DGD.Rda,DGD.Rua,DGD.Rma)
if dDistMax > GEO.EPS_SMALL and abs(max(DGD.Rda,DGD.Rua,DGD.Rma) - DGD.Rda) > GEO.EPS_SMALL then
local sVecIni = EgtSV(nMId)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nMId, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)) ,{DGD.Rda,DGD.Adr,DGD.Dra})
end
-- eventuale allungamento percorso sulla fine
dDistMax = max(DGD.Lda,DGD.Lua,DGD.Lma) - min(DGD.Lda,DGD.Lua,DGD.Lma)
if dDistMax > GEO.EPS_SMALL and abs(min(DGD.Lda,DGD.Lua,DGD.Lma) - DGD.Lda) > GEO.EPS_SMALL then
local sVecIni = EgtEV(nMId)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nMId, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)), {DGD.Lda,DGD.Adl,DGD.Dla})
end
end
end
else
if DGD.tProfs.top.xdeltapos > 0 then
local nE1 = EgtLine( nLl, {DGD.Rma,DGD.Amr,DGD.Dra}, {DGD.Cmm,DGD.Amt,DGD.Drt}) -- p18 a p21
local nE2 = EgtLine( nLl, {DGD.Cmm,DGD.Amt,DGD.Drt}, {DGD.Lma,DGD.Aml,DGD.Dla}) -- p21 a p17
-- eventuale allungamento percorso sull'inizio
local dDistMax = max(DGD.Rda,DGD.Rua,DGD.Rma) - min(DGD.Rda,DGD.Rua,DGD.Rma)
if dDistMax > GEO.EPS_SMALL and abs( max(DGD.Rda,DGD.Rua,DGD.Rma) - DGD.Rma) > GEO.EPS_SMALL then
local sVecIni = EgtSV(nE1)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nE1, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)) ,{DGD.Rdm,DGD.Amr,DGD.Dra})
end
-- eventuale allungamento percorso sulla fine
dDistMax = max( DGD.Lda,DGD.Lua,DGD.Lma) - min(DGD.Lda,DGD.Lua,DGD.Lma)
if dDistMax > GEO.EPS_SMALL and abs( min(DGD.Lda,DGD.Lua,DGD.Lma) - DGD.Lma) > GEO.EPS_SMALL then
local sVecIni = EgtEV(nE2)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nE2, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)), {DGD.Lma,DGD.Aml,DGD.Dla})
end
nMId = EgtCurveCompo( nLl, {nE1,nE2}, true)
else
nMId = EgtLine( nLl, {DGD.Rma,DGD.Amr,DGD.Dra}, {DGD.Lma,DGD.Aml,DGD.Dla}) -- p18 a p17
-- eventuale allungamento percorso sull'inizio
local dDistMax = max(DGD.Rda,DGD.Rua,DGD.Rma) - min(DGD.Rda,DGD.Rua,DGD.Rma)
if dDistMax > GEO.EPS_SMALL and abs(max(DGD.Rda,DGD.Rua,DGD.Rma) - DGD.Rma) > GEO.EPS_SMALL then
local sVecIni = EgtSV(nMId)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nMId, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)) ,{DGD.Rma,DGD.Amr,DGD.Dra})
end
-- eventuale allungamento percorso sulla fine
dDistMax = max(DGD.Lda,DGD.Lua,DGD.Lma) - min(DGD.Lda,DGD.Lua,DGD.Lma)
if dDistMax > GEO.EPS_SMALL and abs(min(DGD.Lda,DGD.Lua,DGD.Lma) - DGD.Lma) > GEO.EPS_SMALL then
local sVecIni = EgtEV(nMId)
local dCompoY = (dDistMax/sVecIni:getX()*sVecIni:getY())
EgtTrimExtendCurveByLen( nMId, sqrt( (dDistMax*dDistMax) + (dCompoY*dCompoY)), {DGD.Lma,DGD.Aml,DGD.Dla})
end
end
end
EgtModifyCurveThickness( nMId, DGD.dT)
EgtSetName( nMId, sTopType .. EgtIf( string.find( sTopType,'EB'), DGD.EBP, '') .. '_H')
EgtSetColor( nMId, BLACK())
EgtSetInfo( nMId, 'EdgeDoor', 'T')
else
if sTopType == 'BD' or sTopType == 'BU' or sTopType == 'BDEB' or sTopType == 'BUEB' or sTopType == 'SQ' or sTopType == 'EB' or sTopType == 'FDWC' then
nMId = EgtLine( nLl, {max(DGD.Rdt,DGD.Rm,DGD.Rut),DGD.Tdr,DGD.Drt}, {min(DGD.Ldt,DGD.Lm,DGD.Lut),DGD.Tdl,DGD.Dlt}) -- p9 a p10
if sTopType == 'BD' or sTopType == 'BU' or sTopType == 'BDEB' or sTopType == 'BUEB' then
if DGD.Push then
EgtModifyCurveExtrusion( nMId, Vector3d( 0, -SIN3, COS3), GDB_RT.GLOB)
else
EgtModifyCurveExtrusion( nMId, Vector3d( 0, SIN3, COS3), GDB_RT.GLOB)
end
EgtModifyCurveThickness( nMId, DGD.dT / COS3)
else -- SQ/EB/FDWC
EgtModifyCurveThickness( nMId, DGD.dT)
end
EgtSetName( nMId, sTopType .. EgtIf( string.find( sTopType,'EB'), DGD.EBP, '') .. '_H')
EgtSetColor( nMId, BLACK())
EgtSetInfo( nMId, 'EdgeDoor', 'T')
-- creo percorsi anti-scheggia lungo lo spessore
-- griglia a destra per percorso a destra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.RIGHT))
if sRightType == 'SQ' or sRightType == 'EB' or sRightType == 'BD' or sRightType == 'BU' or sRightType == 'BDEB' or sRightType == 'BUEB' or sRightType == 'FDWC' then
nAsr = EgtLine( nLl, {DGD.Tdr,DGD.Drt,DGD.Rdt}, {DGD.Tur,DGD.Urt,DGD.Rut}, GDB_RT.GRID) -- p9 a p8
else
nAsr = EgtLine( nLl, {DGD.Tdr,DGD.Drt,max(DGD.Rdt,DGD.Rm,DGD.Rut)}, {DGD.Tur,DGD.Urt,max(DGD.Rdt,DGD.Rm,DGD.Rut)}, GDB_RT.GRID) -- p9 a p8
end
EgtModifyCurveThickness( nAsr, 0)
EgtSetColor( nAsr, BLACK())
-- griglia a sinistra per percorso a sinistra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.LEFT))
if sLeftType == 'SQ' or sLeftType == 'EB' or sLeftType == 'BD' or sLeftType == 'BU' or sLeftType == 'BDEB' or sLeftType == 'BUEB' or sLeftType == 'FDWC' then
nAsl = EgtLine( nLl, {-DGD.Tul,DGD.Ult,-DGD.Lut}, {-DGD.Tdl,DGD.Dlt,-DGD.Ldt}, GDB_RT.GRID) -- p7 a p10
else
nAsl = EgtLine( nLl, {-DGD.Tul,DGD.Ult,-(min(DGD.Lut,DGD.Lm,DGD.Ldt))}, {-DGD.Tdl,DGD.Dlt,-(min(DGD.Lut,DGD.Lm,DGD.Ldt))}, GDB_RT.GRID) -- p7 a p10
end
EgtModifyCurveThickness( nAsl, 0)
EgtSetColor( nAsl, BLACK())
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
if DGD.Lock == 'R' then
EgtSetName( nAsl, 'ASLT_HNG') -- indico nel nome che è sul lato hinge
EgtSetName( nAsr, 'ASRT')
else
EgtSetName( nAsl, 'ASLT')
EgtSetName( nAsr, 'ASRT_HNG') -- indico nel nome che è sul lato hinge
end
elseif sTopType == '1B' or sTopType == '2B' or sTopType == '3B' or sTopType == '4B' or
sTopType == '5B' or sTopType == '6B' or sTopType == '7B' or sTopType == '8B' then
nMId = EgtLine( nLl, {max(DGD.Rdt,DGD.Rm,DGD.Rut),DGD.Tdr,DGD.Drt}, {min(DGD.Ldt,DGD.Lm,DGD.Lut),DGD.Tdl,DGD.Dlt}) -- p9 a p10
EgtModifyCurveThickness( nMId, DGD.dT)
EgtSetName( nMId, sTopType..'_H')
EgtSetColor( nMId, BLACK())
EgtSetInfo( nMId, 'EdgeDoor', 'T')
--[[
-- creo percorsi antischeggia lungo lo spessore
-- griglia a destra per percorso a destra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.RIGHT))
nAsr = EgtLine( nLl, {max(DGD.Tdr,DGD.Tur),DGD.Drt,max(DGD.Rdt,DGD.Rm,DGD.Rut)}, {max(DGD.Tdr,DGD.Tur),DGD.Urt,max(DGD.Rdt,DGD.Rm,DGD.Rut)}, GDB_RT.GRID) -- p9 a p8
EgtModifyCurveThickness( nAsr, 0)
EgtSetColor( nAsr, BLACK())
-- griglia a sinistra per percorso a sinistra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.LEFT))
nAsl = EgtLine( nLl, {-(max(DGD.Tul,DGD.Tdl)),DGD.Ult,-(min(DGD.Lut,DGD.Lm,DGD.Ldt))}, {-(max(DGD.Tul,DGD.Tdl)),DGD.Dlt,-(min(DGD.Lut,DGD.Lm,DGD.Ldt))}, GDB_RT.GRID) -- p7 a p10
EgtModifyCurveThickness( nAsl, 0)
EgtSetColor( nAsl, BLACK())
if DGD.Lock == 'R' then
EgtSetName( nAsl, 'ASLT_HNG') -- indico nel nome che è sul lato hinge
EgtSetName( nAsr, 'ASRT')
else
EgtSetName( nAsl, 'ASLT')
EgtSetName( nAsr, 'ASRT_HNG') -- indico nel nome che è sul lato hinge
end
]]--
elseif sTopType == 'CV' then
nMId = EgtLine( nLl, {max(DGD.Rdt,DGD.Rm,DGD.Rut),DGD.Tmr,DGD.Drt}, {min(DGD.Ldt,DGD.Lm,DGD.Lut),DGD.Tml,DGD.Dlt}) -- p9 a p10
EgtModifyCurveThickness( nMId, DGD.dT)
EgtSetName( nMId, sTopType..'_H')
EgtSetColor( nMId, BLACK())
EgtSetInfo( nMId, 'EdgeDoor', 'T')
--[[
-- creo percorsi antischeggia lungo lo spessore
-- griglia a destra per percorso a destra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.RIGHT))
nAsr = EgtLine( nLl, {max(DGD.Tdr,DGD.Tur),DGD.Drt,max(DGD.Rdt,DGD.Rm,DGD.Rut)}, {max(DGD.Tdr,DGD.Tur),DGD.Urt,max(DGD.Rdt,DGD.Rm,DGD.Rut)}, GDB_RT.GRID) -- p9 a p8
EgtModifyCurveThickness( nAsr, 0)
EgtSetColor( nAsr, BLACK())
-- griglia a sinistra per percorso a sinistra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.LEFT))
nAsl = EgtLine( nLl, {-(max(DGD.Tul,DGD.Tdl)),DGD.Ult,-(min(DGD.Lut,DGD.Lm,DGD.Ldt))}, {-(max(DGD.Tul,DGD.Tdl)),DGD.Dlt,-(min(DGD.Lut,DGD.Lm,DGD.Ldt))}, GDB_RT.GRID) -- p7 a p10
EgtModifyCurveThickness( nAsl, 0)
EgtSetColor( nAsl, BLACK())
if DGD.Lock == 'R' then
EgtSetName( nAsl, 'ASLT_HNG') -- indico nel nome che è sul lato hinge
EgtSetName( nAsr, 'ASRT')
else
EgtSetName( nAsl, 'ASLT')
EgtSetName( nAsr, 'ASRT_HNG') -- indico nel nome che è sul lato hinge
end
]]--
end
end
end
end
-- elimino le 12 linee
EgtErase(nDoorBot)
EgtErase(nDoorLeft)
EgtErase(nDoorTop)
EgtErase(nDoorRight)
EgtErase(nDoorBotMid)
EgtErase(nDoorLeftMid)
EgtErase(nDoorTopMid)
EgtErase(nDoorRightMid)
EgtErase(nDoorBotTop)
EgtErase(nDoorLeftTop)
EgtErase(nDoorTopTop)
EgtErase(nDoorRightTop)
-- per i frame risetto le variabili profilo a SQ
if DGD.sFrame then
DGD.tProfs.hingeedge.trimming = 'SQ'
DGD.tProfs.lockedge.trimming = 'SQ'
end
-- inserisco sfinestrature
if #DGD.tVisions > 0 then
InsertGeom( DGD.tVisions, DGD.Lock, DGD.Push, 'vision')
end
-- inserisco sfinestrature inferiori
if #DGD.tLouvers > 0 then
InsertGeom( DGD.tLouvers, DGD.Lock, DGD.Push, 'louver')
end
-- inserisco sfinestrature inferiori mail slot
if #DGD.tMailSlots > 0 then
InsertGeom( DGD.tMailSlots, DGD.Lock, DGD.Push, 'mail')
end
-- inserisco spioncini
if #DGD.tViewers > 0 then
InsertGeom( DGD.tViewers, DGD.Lock, DGD.Push, 'viewer')
end
-- inserisco disegni flush pull
if #DGD.tFlushPulls > 0 then
InsertGeom( DGD.tFlushPulls, DGD.Lock, DGD.Push, 'flush')
end
-- inserisco disegni cerniere
if #DGD.tHinges > 0 then
nNumHingePivot = nNumHingePivot + #DGD.tHinges -- prendo il numero di cerniere inserite
InsertGeom( DGD.tHinges, DGD.Lock, DGD.Push, 'hinge')
end
-- inserisco disegni EPT
if #DGD.tEPTs > 0 then
InsertGeom( DGD.tEPTs, DGD.Lock, DGD.Push, 'ept')
end
--inserisco disegni serrature
if #DGD.tLocks > 0 then
InsertGeom( DGD.tLocks, DGD.Lock, DGD.Push, 'lock')
end
--inserisco disegni flush bolt
if #DGD.tFlushBolts > 0 then
InsertGeom( DGD.tFlushBolts, DGD.Lock, DGD.Push, 'flushbolt')
end
--inserisco disegni edge pull
if #DGD.tEdgePulls > 0 then
InsertGeom( DGD.tEdgePulls, DGD.Lock, DGD.Push, 'edgepull')
end
--inserisco disegni Roller Latch
if #DGD.tRollerLatchs > 0 then
InsertGeom( DGD.tRollerLatchs, DGD.Lock, DGD.Push, 'rollerlatch')
end
--inserisco disegni Pivot
if #DGD.tPivots > 0 then
InsertGeom( DGD.tPivots, DGD.Lock, DGD.Push, 'pivot')
end
--inserisco disegni stops and closers
if #DGD.tStopsAndClosers > 0 then
InsertGeom( DGD.tStopsAndClosers, DGD.Lock, DGD.Push, 'stopandcloser')
end
--inserisco disegni over heads
if #DGD.tOHeads > 0 then
InsertGeom( DGD.tOHeads, DGD.Lock, DGD.Push, 'overhead')
end
--inserisco disegni strike
if #DGD.tStrikes > 0 then
InsertGeom( DGD.tStrikes, DGD.Lock, DGD.Push, 'strike')
end
--inserisco disegni groove
if #DGD.tGrooves > 0 then
InsertGeom( DGD.tGrooves, DGD.Lock, DGD.Push, 'groove')
end
--inserisco disegni rabbet
if #DGD.tRabbets > 0 then
InsertGeom( DGD.tRabbets, DGD.Lock, DGD.Push, 'rabbet')
end
--inserisco disegni face decoration
if #DGD.tDecorations > 0 then
InsertGeom( DGD.tDecorations, DGD.Lock, DGD.Push, 'facedecoration')
end
--debug
-- EgtSaveFile()
-- EgtMove(DGD.PZ, Point3d(0,0,nil) - ORIG())
-- sottraggo le superfici in modo da avere la visualizzazione della porta con le sfinestrature
-- ed elimino le superfici temporanee
SubAndDeleteTempSurf( nLs)
if DGD.sFrame then
if nTypePiece == 3 then -- se frame SX
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.FRONT))
EgtRotate( DGD.PZ, Point3d(0,0,0), Z_AX(), 90, GDB_RT.GRID) -- ruoto su faccia frontale
EgtMove( DGD.PZ, Point3d(DGD.dT,0,0) - ORIG(), GDB_RT.GRID)
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
elseif nTypePiece == 4 then -- se frame DX
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.FRONT))
EgtRotate( DGD.PZ, Point3d(DGD.dW,0,0), Z_AX(), -90, GDB_RT.GRID) -- ruoto su faccia frontale
EgtMove( DGD.PZ, Point3d(-DGD.dW,0,0) - ORIG(), GDB_RT.GRID)
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
elseif nTypePiece == 5 then -- tipo frame top
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.LEFT))
EgtRotate( DGD.PZ, Point3d(-DGD.dH,0,0), Z_AX(), 90, GDB_RT.GRID) -- ruoto su faccia sinistra
EgtMove( DGD.PZ, Point3d(DGD.dH,0,0) - ORIG(), GDB_RT.GRID)
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
EgtRotate( DGD.PZ, Point3d(0,0,0), Z_AX(), 90, GDB_RT.GRID) -- ruoto su faccia top
EgtMove( DGD.PZ, Point3d(DGD.dT,0,0) - ORIG(), GDB_RT.GRID)
else -- tipo frame bottom
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.LEFT))
EgtRotate( DGD.PZ, Point3d(0,0,0), Z_AX(), -90, GDB_RT.GRID) -- ruoto su faccia sinistra
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
EgtRotate( DGD.PZ, Point3d(0,0,0), Z_AX(), 90, GDB_RT.GRID) -- ruoto su faccia top
end
end
-- scritta TOP per debug
if DGD.sFrame then
if nTypePiece == 3 or nTypePiece == 4 then -- se frame SX o DX
EgtText(nLa,{ 5, DGD.dH - 100, DGD.dW},'TOP-'.. EgtIf( nTypePiece == 3, 'JL', 'JR') .. '-' .. DGD.sAliasSwng,20,GDB_RT.GLOB)
else
EgtText(nLa,{ 5, DGD.dW - 100, DGD.dH},'TOP-'.. EgtIf( nTypePiece == 5, 'JT', 'JB') .. '-' .. DGD.sAliasSwng,20,GDB_RT.GLOB)
end
else
if DGD.tProfs.top.angle then
-- faccio il calcolo per capire se taglia la scritta
local nDltPosY
if DGD.tProfs.top.angle > 0 then
nDltPosY = ( DGD.dW - DGD.tProfs.top.xdeltapos - (0.5*(DGD.Lut+DGD.Rut)-150)) * tan(DGD.tProfs.top.angle)
else
nDltPosY = ( ( 0.5*(DGD.Lut+DGD.Rut)+150) - DGD.tProfs.top.xdeltapos) * tan(abs(DGD.tProfs.top.angle))
end
if nDltPosY < 0 then
nDltPosY = 0
end
EgtText(nLa,{ 0.5*(DGD.Lut+DGD.Rut)-150, DGD.Tul - 100 - nDltPosY, DGD.dT},'TOP-'..DGD.sAliasSwng,50,GDB_RT.GLOB)
else
EgtText(nLa,{ 0.5*(DGD.Lut+DGD.Rut)-150, DGD.Tul - 100, DGD.dT},'TOP-'..DGD.sAliasSwng,50,GDB_RT.GLOB)
end
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
end
-------------------
-- quotatura porta
-------------------
InsertSize( 0, nil, ptMedArc, nil)
return true
end
-----------------------------------------------------------------
-- *** read Probe file ***
-----------------------------------------------------------------
local function LoadDataProbeFile( sOriProbeFile, sProbeFile)
local bReadFile = true
if DGD.PROBE == 2 then
local nIdPrb = OpenPrbFile( sOriProbeFile, 'r')
-- se trovato il file generico data.dat lo rinomino in <nomeddf>.dat
if nIdPrb then
nIdPrb:close() -- chiudo il file
EgtCopyFile( sOriProbeFile, sProbeFile) -- faccio la copia sovrascrivendo l'eventuale file <nomeddf>.dat
-- elimino il file data.dat così poi c'è il tempo per riaprire il file <nomeddf>.dat
EgtEraseFile( sOriProbeFile)
end
nIdPrb = OpenPrbFile( sProbeFile, 'r')
if nIdPrb then
-- leggo la prossima linea
local sLine = nIdPrb:read( '*l')
while sLine do
-- elimino spazi finali (compresi tab e simili)
sLine = EgtTrimRight( sLine)
-- se linea contiene qualcosa
if sLine:len() > 0 then
-- se non ci sono commenti
local nI = sLine:find( ';', 1, true)
if not nI then
if sLine:find( 'OPM=', 1, true) then
sLine = sLine:sub( 5)
tProbeDoor.OPM = tonumber(sLine)
elseif sLine:find( 'P1.x=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P1x = tonumber(sLine)
elseif sLine:find( 'P1.y=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P1y = tonumber(sLine)
elseif sLine:find( 'P2.x=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P2x = tonumber(sLine)
elseif sLine:find( 'P2.y=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P2y = tonumber(sLine)
elseif sLine:find( 'P3.x=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P3x = tonumber(sLine)
elseif sLine:find( 'P3.y=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P3y = tonumber(sLine)
elseif sLine:find( 'P4.x=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P4x = tonumber(sLine)
elseif sLine:find( 'P4.y=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P4y = tonumber(sLine)
elseif sLine:find( 'P5.x=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P5x = tonumber(sLine)
elseif sLine:find( 'P5.y=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P5y = tonumber(sLine)
elseif sLine:find( 'P6.x=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P6x = tonumber(sLine)
elseif sLine:find( 'P6.y=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P6y = tonumber(sLine)
elseif sLine:find( 'P7.x=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P7x = tonumber(sLine)
elseif sLine:find( 'P7.y=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P7y = tonumber(sLine)
elseif sLine:find( 'P8.x=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P8x = tonumber(sLine)
elseif sLine:find( 'P8.y=', 1, true) then
sLine = sLine:sub( 6)
tProbeDoor.P8y = tonumber(sLine)
elseif sLine:find( 'FD=', 1, true) then
sLine = sLine:sub( 4)
tProbeDoor.FD = tonumber(sLine)
elseif sLine:find( 'TD=', 1, true) then
sLine = sLine:sub( 4)
tProbeDoor.TD = tonumber(sLine)
elseif sLine:find( 'DR=', 1, true) then
sLine = sLine:sub( 4)
tProbeDoor.DR = EgtIf( DGD.bMM, 1, GEO.ONE_INCH)*tonumber(sLine)
elseif sLine:find( 'DO=', 1, true) then
sLine = sLine:sub( 4)
tProbeDoor.DO = EgtIf( DGD.bMM, 1, GEO.ONE_INCH)*tonumber(sLine)
elseif sLine:find( 'DD=', 1, true) then
sLine = sLine:sub( 4)
tProbeDoor.DD = tonumber(sLine)
elseif sLine:find( 'PX=', 1, true) then
sLine = sLine:sub( 4)
tProbeDoor.PX = tonumber(sLine)
elseif sLine:find( 'PY=', 1, true) then
sLine = sLine:sub( 4)
tProbeDoor.PY = tonumber(sLine)
elseif sLine:find( 'PZ=', 1, true) then
sLine = sLine:sub( 4)
tProbeDoor.PZ = tonumber(sLine)
-- se lo spessore passato è 0 lo setto allo spessore nominale
if abs(tProbeDoor.PZ) < GEO.EPS_SMALL then
tProbeDoor.PZ = DGD.dT
end
end
end
end
sLine = nIdPrb:read( '*l')
end
-- chiudo il file
nIdPrb:close()
else
bReadFile = false
end
end
return bReadFile
end
-----------------------------------------------------------------
-- *** Verify Mtable ***
-----------------------------------------------------------------
local function VerifyMtable()
local M
local bLocFoundMTable = true
-- verifico se esiste il nome file
if not sMTable or #sMTable <= 0 then
bLocFoundMTable = false
end
if bLocFoundMTable and DGD.MachEn > 0 then
-- verifico se esiste il file
sMTablePath = sBaseDir..'MTables\\'..sMTable..'.mtl'
if EgtExistsFile(sMTablePath) then
sMTablePath = sBaseDir..'MTables\\'
M = require( sMTable)
if M then
tMachineData = M.MMachineData
if not tMachineData then
local sMessageErr = string.format( EgtDoorsMsg[489], sMTable) -- dati macchina non validi
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 25
-- WriteErrFile( sErrFileM)
bLocFoundMTable = false
end
else
local sMessageErr = string.format( EgtDoorsMsg[490], sMTable) -- tabella non trovata
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 24
-- WriteErrFile( sErrFileM)
bLocFoundMTable = false
end
else
local sMessageErr = string.format( EgtDoorsMsg[487], 'Mtable ',sMTablePath) -- non c'è il file della tabella
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 23
-- WriteErrFile( sErrFileM)
bLocFoundMTable = false
end
elseif DGD.MachEn > 0 then
local sMessageErr = string.format( EgtDoorsMsg[487], 'Mtable ', sMTable) -- il nome del file della tabella non è valido
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 22
-- WriteErrFile( sErrFileM)
end
return bLocFoundMTable
end
-----------------------------------------------------------------
-- *** DOOR creation ***
-----------------------------------------------------------------
local function DoorCreation()
local bLocFoundMTable = true
-- Creo pezzo porta
EgtNewFile()
DGD.PZ = EgtGroup( GDB_ID.ROOT)
if not DGD.sFrame then
EgtSetName( DGD.PZ, 'DOOR')
elseif DGD.sFrame == 'L' then
EgtSetName( DGD.PZ, 'FRAME_LOCK')
elseif DGD.sFrame == 'LE' then
EgtSetName( DGD.PZ, 'FRAME_LOCK_EXT')
elseif DGD.sFrame == 'H' then
EgtSetName( DGD.PZ, 'FRAME_HINGE')
elseif DGD.sFrame == 'HE' then
EgtSetName( DGD.PZ, 'FRAME_HINGE_EXT')
elseif DGD.sFrame == 'T' then
EgtSetName( DGD.PZ, 'FRAME_TOP')
elseif DGD.sFrame == 'TE' then
EgtSetName( DGD.PZ, 'FRAME_TOP_EXT')
elseif DGD.sFrame == 'B' then
EgtSetName( DGD.PZ, 'FRAME_BOT')
elseif DGD.sFrame == 'BE' then
EgtSetName( DGD.PZ, 'FRAME_BOT_EXT')
end
EgtSetCurrPartLayer( DGD.PZ, GDB_ID.NULL)
-- scrivo le note
local tAppo
local sParam, sValue
for i = 1, #tGenInfo do
tAppo = tGenInfo[i]
sParam = tAppo[1]
sValue = tAppo[2]
EgtSetInfo( DGD.PZ, sParam, sValue)
end
-- nota del frame
EgtSetInfo( DGD.PZ, 'Frame', DGD.sFrame)
-- controllo la macchina solo se ho abilitato la generazione della geometria di lavorazione
if DGD.MachEn > 0 then
-- faccio qui il controllo come frame deve essere disposto ed eventualmente modifico la Mtable
if DGD.sFrame then
local nDispJamb = 0
if DGC.Dwjs and DGD.Material and string.lower(DGD.Material) == 'wood' then
nDispJamb = DGC.Dwjs
elseif DGC.Dsjs and DGD.Material and string.lower(DGD.Material) == 'steel' then
nDispJamb = DGC.Dsjs
elseif DGC.Dajs and DGD.Material and string.lower(DGD.Material) == 'aluminum' then
nDispJamb = DGC.Dajs
elseif DGC.Dfjs and DGD.Material and string.lower(DGD.Material) == 'fiberglass' then
nDispJamb = DGC.Dfjs
end
-- setto la disposizione di piatto o di fianco dei jamb laterali e superiore,
-- per quello inferiore, se le dimensioni della sezione sono sotto un certo valore, viene disposto solo di piatto
if nTypePiece == 3 then -- se frame SX
if nDispJamb > 0 and DGD.dW > DGC.Mjn then -- se disposizione sul lato narrow e lato maggiore del valore minimo
DGD.Dws = false
else
DGD.Dws = true
end
elseif nTypePiece == 4 then -- se frame DX
if nDispJamb > 0 and DGD.dW > DGC.Mjn then -- se disposizione sul lato narrow e lato maggiore del valore minimo
DGD.Dws = false
else
DGD.Dws = true
end
elseif nTypePiece == 5 then -- tipo frame top
if nDispJamb > 0 and DGD.dH > DGC.Mjn then -- se disposizione sul lato narrow e lato maggiore del valore minimo
DGD.Dws = false
else
DGD.Dws = true
end
else -- tipo frame bottom
if nDispJamb > 0 and DGD.dH > DGC.Mjn then -- se disposizione sul lato narrow e lato maggiore del valore minimo
DGD.Dws = false
else
DGD.Dws = true
end
end
-- se ho disposto eventuale frame sul lato wide modifico il nome della Mtable e la verifico
if DGD.Dws then
sMTable = sMTable .. '_wide'
bLocFoundMTable = VerifyMtable()
end
DGD.Spd = DGC.Spd or 0
else
DGD.Dws = nil
DGD.Spd = 0
end
-- Check machines and search into CurrCamInfo the parameter for manage large wide door
for i = 1, #tMachineData do
-- se nome macchina non c'è
if not tMachineData[i].MachName then
DoorOutLog( string.format(EgtDoorsMsg[488], tMachineData[i].MachName), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format(EgtDoorsMsg[488], tMachineData[i].MachName)
DGD.ERR = -12
-- se non c'è la macchina
elseif not EgtSetCurrMachine( tMachineData[i].MachName) then
DoorOutLog( string.format(EgtDoorsMsg[488], tMachineData[i].MachName), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format(EgtDoorsMsg[488], tMachineData[i].MachName)
DGD.ERR = -11
-- macchina presente
else
local CCI = require( 'CurrCamInfo')
for j = 1, #CCI do
if CCI[j].MachName == tMachineData[i].MachName then
if CCI[j].WideDoorWidth and CCI[j].WideDoorWidth > 0 then
DGD.Part = CCI[j].WideDoorWidth
end
if CCI[j].SideDoorDefined and CCI[j].SideDoorDefined >= 0 then
DGD.SDF = CCI[j].SideDoorDefined
end
end
end
end
end
-- Note della tabella utilizzata ( deve essere settata prima di creare il pezzo con CreateDoor() perchè i componenti inseriti vanno ad utilizzarla)
EgtSetInfo( DGD.PZ, 'MTable', sMTable)
EgtSetInfo( DGD.PZ, 'MTablePath', sMTablePath)
-- setto il tipo di disposizione del frame
EgtSetInfo( DGD.PZ, 'FrameDispositionOnSide', DGD.Dws)
-- setto la nota per large wide door
if DGD.Part and DGD.Part > 0 then
EgtSetInfo( DGD.PZ, 'ManageLargeWideDoor', DGD.Part)
end
end
-- Note della disposizione
EgtSetInfo( DGD.PZ, 'SwingDriveDisp', DGD.SwDD or 1)
if bLocFoundMTable then
------------------------------------------------------
------------------------------------------------------
-- Costruzione della porta
local bOk, nNumErr, sMessErr = CreateDoor()
------------------------------------------------------
------------------------------------------------------
-- In caso di errore, lo segnalo
if not bOk then
if nNumErr == 0 then
DoorOutLog( EgtDoorsMsg[454], 0)
DGD.ERM = DGD.ERM .. '\n' .. EgtDoorsMsg[454]
DGD.ERR = 10
elseif nNumErr == 1 then
DoorOutLog( EgtDoorsMsg[630], 0)
DGD.ERM = DGD.ERM .. '\n' .. EgtDoorsMsg[630]
DGD.ERR = 11
elseif nNumErr == 2 then
DoorOutLog( sMessErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessErr
DGD.ERR = 14
end
else
-- Note del profilo bevel invertito
EgtSetInfo( DGD.PZ, 'OppoBevelProf', DGD.bBothOppoBevel)
-- Note del raggio profilo su hinge
EgtSetInfo( DGD.PZ, 'RadHingeProfile', DGD.RPH or 0)
-- Note del raggio profilo su lock
EgtSetInfo( DGD.PZ, 'RadLockProfile', DGD.RPL or 0)
-- Note del raggio profilo su top
EgtSetInfo( DGD.PZ, 'RadTopProfile', DGD.RPT or 0)
-- Note del raggio profilo su bottom
EgtSetInfo( DGD.PZ, 'RadBottomProfile', DGD.RPB or 0)
-- Note del piano sul profilo CV su hinge
EgtSetInfo( DGD.PZ, 'PlnHingeProfile', DGD.PPH or 0)
-- Note del piano sul profilo CV su lock
EgtSetInfo( DGD.PZ, 'PlnLockProfile', DGD.PPL or 0)
-- Note del piano sul profilo CV su top
EgtSetInfo( DGD.PZ, 'PlnTopProfile', DGD.PPT or 0)
-- Note del piano sul profilo CV su bottom
EgtSetInfo( DGD.PZ, 'PlnBottomProfile', DGD.PPB or 0)
-- note del numero di elementi inseriti nel lato cerniere (esclusi EPT per il momento)
EgtSetInfo( DGD.PZ, 'NumHingesPivots', nNumHingePivot or 0)
-- note dispsizione jambs materiale legno
EgtSetInfo( DGD.PZ, 'DisposeWJambsOnSide', DGC.Dwjs or 0)
-- note dispsizione jambs materiale acciaio
EgtSetInfo( DGD.PZ, 'DisposeSJambsOnSide', DGC.Dsjs or 0)
-- note dispsizione jambs materiale alluminio
EgtSetInfo( DGD.PZ, 'DisposeAJambsOnSide', DGC.Dajs or 0)
-- note dispsizione jambs materiale fibra di vetro
EgtSetInfo( DGD.PZ, 'DisposeFJambsOnSide', DGC.Dfjs or 0)
-- nota presenza cutout
EgtSetInfo( DGD.PZ, 'ExistsCutOut', DGD.ExistCutOut)
-- nota mancanza riduzione sfridi
EgtSetInfo( DGD.PZ, 'WholeCutOut', DGD.NotExistHatch)
end
end
return bLocFoundMTable, bWriteWide
end
-----------------------------------------------------------------
-- *** DDF parse and make door ***
-----------------------------------------------------------------
local function ReadAndParseDdfAndMakeDoors()
local sOutLogMsg = ''
local sPrvKeyLine = ''
local bOpenDdf = true
local bWriteErr = false
local bLocFoundMTable
local nLimitPieces = 6
---------------------------------------------------
-- Lettura parametri necessari con errori bloccanti
---------------------------------------------------
-- Apertura file DDF
if not OpenFile( DGD.FILE) then
DoorOutLog( EgtDoorsMsg[434], 0)
DGD.ERM = DGD.ERM .. '\n' .. EgtDoorsMsg[434]
DGD.ERR = 1
bOpenDdf = false
end
-- esco se trovo il codice di fine file o non è finito il file
while bOpenDdf and not EndOfFile() and not KeyFromLine( '...') and nCountPieces < nLimitPieces do
-- Reset librerie per evitare l'errore in caso riparto da una situazione di errore dello script
ResetDoorsGlobData()
tGenInfo={}
if not KeyFromLine( '---') then
sPrvKeyLine = ''
-- Lettura numero versione ddf
GetVersion()
sOutLogMsg = ' DGD.nVersion=' .. tostring( DGD.nVersion)
DoorOutLog( sOutLogMsg, 0)
-- Lettura flag di produzione pezzo
GetProoduce()
sOutLogMsg = ' DGD.bProoduce=' .. tostring( DGD.bProoduce)
DoorOutLog( sOutLogMsg, 0)
-- Lettura unità di misura
if not GetMeasures() then
DoorOutLog( string.format( EgtDoorsMsg[435], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[435], GetLineNumber())
DGD.ERR = 2
bWriteErr = false
break
end
sOutLogMsg = ' DGD.bMM=' .. tostring( DGD.bMM)
DoorOutLog( sOutLogMsg, 0)
-- Lettura codice identificativo
if not GetCode() then
DoorOutLog( string.format( EgtDoorsMsg[436], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[436], GetLineNumber())
DGD.ERR = 3
bWriteErr = false
break
end
sOutLogMsg = ' DGD.sCode=' .. DGD.sCode
DoorOutLog( sOutLogMsg, 0)
-- Lettura dati ordine
if not GetOrder() then
DoorOutLog( string.format( EgtDoorsMsg[437], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[437], GetLineNumber())
DGD.ERR = 4
bWriteErr = false
break
end
sOutLogMsg = ' DGD.tOrder=' .. table.concat( DGD.tOrder, ',')
DoorOutLog( sOutLogMsg, 0)
-- Lettura data
if not GetDate() then
DoorOutLog( string.format( EgtDoorsMsg[438], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[438], GetLineNumber())
DGD.ERR = 5
bWriteErr = false
break
end
sOutLogMsg = ' DGD.sDate=' .. DGD.sDate
DoorOutLog( sOutLogMsg, 0)
-- lettura tipo pezzo
if GetPiece() then
sOutLogMsg = ' DGD.sFrame=' .. ( DGD.sFrame or '')
DoorOutLog( sOutLogMsg, 0)
end
-- lettura coordinate disposizione
if GetPosition() then
sOutLogMsg = ' DGD.tPosition=' .. EgtNumToString( DGD.tPosition[1], 4) .. ' ' .. EgtNumToString( DGD.tPosition[2], 4) .. ' ' .. EgtNumToString( DGD.tPosition[3], 4)
DoorOutLog( sOutLogMsg, 0)
end
-- Lettura dimensioni
if not GetSize() then
DoorOutLog( string.format( EgtDoorsMsg[439], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[439], GetLineNumber())
DGD.ERR = 6
bWriteErr = false
break
end
sOutLogMsg = ' DGD.dW='..EgtNumToString( DGD.dW, 4)..' DGD.dH='..EgtNumToString( DGD.dH, 4)..' DGD.dT='..EgtNumToString( DGD.dT, 4)
DoorOutLog( sOutLogMsg, 0)
-- lettura altezza originale porta (opzionale, solo per i frame)
if GetDoorHeight() then
sOutLogMsg = ' DGD.dOH='..EgtNumToString( DGD.dOH, 4)
DoorOutLog( sOutLogMsg, 0)
end
-- Lettura tipo di apertura
local bGetSwing, sTmpSwing = GetSwing()
if not bGetSwing then
DoorOutLog( string.format( EgtDoorsMsg[440], sTmpSwing, GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[440], sTmpSwing, GetLineNumber())
DGD.ERR = 7
bWriteErr = false
break
end
sOutLogMsg = ' DGD.sAliasSwng=' .. DGD.sAliasSwng
DoorOutLog( sOutLogMsg, 0)
sOutLogMsg = ' DGD.sSwing=' .. DGD.sSwing
DoorOutLog( sOutLogMsg, 0)
-- lettura disposizione porta senza bevel
if not GetSecurSide() then
DoorOutLog( EgtDoorsMsg[543], 0)
else
sOutLogMsg = ' DGD.sSecSide=' .. DGD.sSecSide
DoorOutLog( sOutLogMsg, 0)
end
-- lettura materiale porta
if not GetDoorMaterial() then
DoorOutLog( EgtDoorsMsg[668], 0)
else
sOutLogMsg = ' DGD.Material=' .. DGD.Material
DoorOutLog( sOutLogMsg, 0)
end
-- lettura proprietà porta
if not GetDoorProperties() then
DoorOutLog( EgtDoorsMsg[635], 0)
else
if DGD.Properties and #DGD.Properties > 0 then
local sProp = ''
for k = 1, #DGD.Properties do
sProp = sProp .. DGD.Properties[k] .. ','
end
sOutLogMsg = ' DGD.Properties=' .. sProp
DoorOutLog( sOutLogMsg, 0)
end
end
-- Lettura tipo di profili
local nErrPrf = GetProfiles()
if nErrPrf == 1 then
DoorOutLog( string.format( EgtDoorsMsg[441], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[441], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 2 then
DoorOutLog( string.format( EgtDoorsMsg[613], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[613], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 3 then
DoorOutLog( string.format( EgtDoorsMsg[614], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[614], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 4 then
DoorOutLog( string.format( EgtDoorsMsg[615], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[615], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 5 then
DoorOutLog( string.format( EgtDoorsMsg[637], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[637], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 6 then
DoorOutLog( string.format( EgtDoorsMsg[660], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[660], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 7 then
DoorOutLog( string.format( EgtDoorsMsg[661], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[661], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 8 then
DoorOutLog( string.format( EgtDoorsMsg[662], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[662], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 9 then
DoorOutLog( string.format( EgtDoorsMsg[663], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[663], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 10 then
DoorOutLog( string.format( EgtDoorsMsg[664], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[664], GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
elseif nErrPrf == 11 then
DoorOutLog( string.format( EgtDoorsMsg[703], DGD.nVersion, GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[703], DGD.nVersion, GetLineNumber())
DGD.ERR = 8
bWriteErr = false
break
else
-- se non ci sono proprietà alla porta, con modalità probe e uno dei fianchi è lavorato, do errore per incompatibilità
if not DGD.Properties and ( DGD.PROBE > 0 and DGC.NPM == 0) and
( DGD.tProfs.top.machining or DGD.tProfs.bottom.machining or DGD.tProfs.hingeedge.machining or DGD.tProfs.lockedge.machining) then
DoorOutLog( EgtDoorsMsg[632], 0)
DGD.ERM = DGD.ERM .. '\n' .. EgtDoorsMsg[632]
DGD.ERR = 13
bWriteErr = false
break
end
end
sOutLogMsg = ' DGD.tProfs.top='..DGD.tProfs.top.trimming..' '..
tostring(DGD.tProfs.top.machining)..' '..
EgtNumToString(DGD.tProfs.top.offset,4)
DoorOutLog( sOutLogMsg, 0)
sOutLogMsg = ' DGD.tProfs.bottom='..DGD.tProfs.bottom.trimming..' '..
tostring(DGD.tProfs.bottom.machining)..' '..
EgtNumToString(DGD.tProfs.bottom.offset,4)
DoorOutLog( sOutLogMsg, 0)
sOutLogMsg = ' DGD.tProfs.hingeedge='..DGD.tProfs.hingeedge.trimming..' '..
tostring(DGD.tProfs.hingeedge.machining)..' '..
EgtNumToString(DGD.tProfs.hingeedge.offset,4)
DoorOutLog( sOutLogMsg, 0)
sOutLogMsg = ' DGD.tProfs.lockedge='..DGD.tProfs.lockedge.trimming..' '..
tostring(DGD.tProfs.lockedge.machining)..' '..
EgtNumToString(DGD.tProfs.lockedge.offset,4)
DoorOutLog( sOutLogMsg, 0)
------------------------------------------
-- Lettura parametri ferramenta, opzionali
------------------------------------------
if DGD.nVersion >= 2 then
local StartHw = StringFromLine( 'hardware:')
if not StartHw then
DoorOutLog( string.format( EgtDoorsMsg[702], DGD.nVersion), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[702], DGD.nVersion)
DGD.ERR = 28
bWriteErr = false
break
end
end
-- Lettura sfinestrature vision cutout
if not DGD.sFrame then
if GetVisionCutOuts() then
if DGD.tVisions then
local nContVC = 1
while nContVC <= #DGD.tVisions do
sOutLogMsg = ' DGD.tVisions.Id='..EgtNumToString(nContVC,0)..' '..
DGD.tVisions[nContVC].shape
if DGD.tVisions[nContVC].length then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tVisions[nContVC].length,4)
end
if DGD.tVisions[nContVC].width then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tVisions[nContVC].width,4)
end
if DGD.tVisions[nContVC].top_rail then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tVisions[nContVC].top_rail,4)
end
if DGD.tVisions[nContVC].lock_stile then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tVisions[nContVC].lock_stile,4)
end
if DGD.tVisions[nContVC].radius then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tVisions[nContVC].radius,4)
end
if DGD.tVisions[nContVC].center_from_top then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tVisions[nContVC].center_from_top,4)
end
if DGD.tVisions[nContVC].center_from_lock then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tVisions[nContVC].center_from_lock,4)
end
if DGD.tVisions[nContVC].door_center then
sOutLogMsg = sOutLogMsg..' '..DGD.tVisions[nContVC].door_center
end
if DGD.tVisions[nContVC].split then
sOutLogMsg = sOutLogMsg..' '.. EgtIf( DGD.tVisions[nContVC].split, '1', '0')
end
if DGD.tVisions[nContVC].dir then
sOutLogMsg = sOutLogMsg..' '.. DGD.tVisions[nContVC].dir
end
DoorOutLog( sOutLogMsg, 0)
nContVC = nContVC + 1
end
end
end
end
if #DGD.tVisions == 0 then -- se non ho trovato sfinestrature
DoorOutLog( EgtDoorsMsg[442], 0)
end
-- Lettura sfinestratura inferiori: louver
if not DGD.sFrame then
if GetLouverCutOut() then
if DGD.tLouvers then
local nContLC = 1
while nContLC <= #DGD.tLouvers do
sOutLogMsg = ' DGD.tLouvers.Id='..EgtNumToString(nContLC,0)
if DGD.tLouvers[nContLC].length then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tLouvers[nContLC].length,4)
end
if DGD.tLouvers[nContLC].width then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tLouvers[nContLC].width,4)
end
if DGD.tLouvers[nContLC].bottom_rail then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tLouvers[nContLC].bottom_rail,4)
end
if DGD.tLouvers[nContLC].lock_stile then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tLouvers[nContLC].lock_stile,4)
end
if DGD.tLouvers[nContLC].door_center then
sOutLogMsg = sOutLogMsg..' '..DGD.tLouvers[nContLC].door_center
end
DoorOutLog( sOutLogMsg, 0)
nContLC = nContLC + 1
end
end
end
end
if #DGD.tLouvers == 0 then -- se non ho trovato sfinestrature inferiori
DoorOutLog( EgtDoorsMsg[443], 0)
end
-- Lettura sfinestrature inferiori: mail slot
if not DGD.sFrame then
if GetMailSlots() then
if DGD.tMailSlots then
local nContMS = 1
while nContMS <= #DGD.tMailSlots do
sOutLogMsg = ' DGD.tMailSlots.Id='..EgtNumToString(nContMS,0)..' '..
DGD.tMailSlots[nContMS].template
if DGD.tMailSlots[nContMS].length then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tMailSlots[nContMS].length,4)
end
if DGD.tMailSlots[nContMS].bottom_rail then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tMailSlots[nContMS].bottom_rail,4)
end
if DGD.tMailSlots[nContMS].delta_center then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tMailSlots[nContMS].delta_center,4)
end
DoorOutLog( sOutLogMsg, 0)
nContMS = nContMS + 1
end
end
end
end
if #DGD.tMailSlots == 0 then -- se non ho trovato sfinestrature inferiori tipo mail slot
DoorOutLog( EgtDoorsMsg[444], 0)
end
-- Lettura spioncini: viewer
if not DGD.sFrame then
if GetViewers() then
if DGD.tViewers then
local nContVw = 1
while nContVw <= #DGD.tViewers do
sOutLogMsg = ' DGD.tViewers.Id='..EgtNumToString(nContVw,0)..' '..
DGD.tViewers[nContVw].template
if DGD.tViewers[nContVw].bottom_rail then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tViewers[nContVw].bottom_rail,4)
end
if DGD.tViewers[nContVw].delta_center then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tViewers[nContVw].delta_center,4)
end
if DGD.tViewers[nContVw].side then
sOutLogMsg = sOutLogMsg..' '..DGD.tViewers[nContVw].side
end
DoorOutLog( sOutLogMsg, 0)
nContVw = nContVw + 1
end
end
end
end
if #DGD.tViewers == 0 then -- se non ho trovato spioncini viewer
DoorOutLog( EgtDoorsMsg[445], 0)
end
-- Lettura sfinestrature flush pull
if not DGD.sFrame then
if GetFlushPulls() then
if DGD.tFlushPulls then
local nContFp = 1
while nContFp <= #DGD.tFlushPulls do
sOutLogMsg = ' DGD.tFlushPulls.Id='..EgtNumToString(nContFp,0)..' '..
DGD.tFlushPulls[nContFp].template
if DGD.tFlushPulls[nContFp].position then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tFlushPulls[nContFp].position,4)
end
if DGD.tFlushPulls[nContFp].back_set then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tFlushPulls[nContFp].back_set,4)
end
if DGD.tFlushPulls[nContFp].depth then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tFlushPulls[nContFp].depth,4)
end
if DGD.tFlushPulls[nContFp].face then
sOutLogMsg = sOutLogMsg..' '..DGD.tFlushPulls[nContFp].face
end
DoorOutLog( sOutLogMsg, 0)
nContFp = nContFp + 1
end
end
end
end
if #DGD.tFlushPulls == 0 then -- se non ho trovato geometrie tipo flush pull
DoorOutLog( EgtDoorsMsg[446], 0)
end
-- Lettura dati cerniere
if not DGD.sFrame or DGD.sFrame == 'H' or DGD.sFrame == 'HE' then
if GetHinges() then
if DGD.tHinges then
local nContHg = 1
while nContHg <= #DGD.tHinges do
sOutLogMsg = ' DGD.tHinges.Id='..EgtNumToString(nContHg,0)..' '..
DGD.tHinges[nContHg].template
if DGD.tHinges[nContHg].position then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tHinges[nContHg].position,4)
end
if DGD.tHinges[nContHg].back_set then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tHinges[nContHg].back_set,4)
end
if DGD.tHinges[nContHg].thickness then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tHinges[nContHg].thickness,4)
end
DoorOutLog( sOutLogMsg, 0)
nContHg = nContHg + 1
end
end
end
end
if #DGD.tHinges == 0 then -- se non ho trovato cerniere
DoorOutLog( EgtDoorsMsg[447], 0)
end
-- Lettura dati EPT
if not DGD.sFrame or DGD.sFrame == 'H' or DGD.sFrame == 'HE' then
if GetEPT() then
if DGD.tEPTs then
local nContEPT = 1
while nContEPT <= #DGD.tEPTs do
sOutLogMsg = ' DGD.tEPTs.Id='..EgtNumToString(nContEPT,0)..' '..
DGD.tEPTs[nContEPT].template
if DGD.tEPTs[nContEPT].position then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tEPTs[nContEPT].position,4)
end
if DGD.tEPTs[nContEPT].back_set then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tEPTs[nContEPT].back_set,4)
end
DoorOutLog( sOutLogMsg, 0)
nContEPT = nContEPT + 1
end
end
end
end
if #DGD.tEPTs == 0 then -- se non ho trovato EPT
DoorOutLog( EgtDoorsMsg[557], 0)
end
-- Lettura dati serrature
if not DGD.sFrame or DGD.sFrame == 'L' or DGD.sFrame == 'LE' or DGD.nTypePz == 5 or
DGD.nTypePz == 6 then
if GetLocks() then
if DGD.tLocks then
local nContLk = 1
while nContLk <= #DGD.tLocks do
sOutLogMsg = ' DGD.tLocks.Id='..EgtNumToString(nContLk,0)..' '..
DGD.tLocks[nContLk].template
if DGD.tLocks[nContLk].position then
sOutLogMsg = sOutLogMsg .. ' ' .. EgtNumToString(DGD.tLocks[nContLk].position,4)
end
if DGD.tLocks[nContLk].back_set then
sOutLogMsg = sOutLogMsg .. ' ' .. EgtNumToString(DGD.tLocks[nContLk].back_set,4)
end
if DGD.tLocks[nContLk].offset then
sOutLogMsg = sOutLogMsg .. ' ' .. EgtNumToString(DGD.tLocks[nContLk].offset,4)
end
if DGD.tLocks[nContLk].side then
sOutLogMsg = sOutLogMsg .. ' ' .. DGD.tLocks[nContLk].side
end
if DGD.tLocks[nContLk].other_door then
sOutLogMsg = sOutLogMsg .. ' ' .. DGD.tLocks[nContLk].other_door
end
DoorOutLog( sOutLogMsg, 0)
nContLk = nContLk + 1
end
end
end
end
if #DGD.tLocks == 0 then -- se non ho trovato serrature
DoorOutLog( EgtDoorsMsg[448], 0)
end
-- Lettura dati flush bolts
if not DGD.sFrame or DGD.nTypePz == 5 or DGD.nTypePz == 6 then
if GetFlushBolts() then
if DGD.tFlushBolts then
local nContFBt = 1
while nContFBt <= #DGD.tFlushBolts do
sOutLogMsg = ' DGD.tFlushBolts.Id='..EgtNumToString(nContFBt,0)..' '..
DGD.tFlushBolts[nContFBt].template
if DGD.tFlushBolts[nContFBt].type then
sOutLogMsg = sOutLogMsg..' '..DGD.tFlushBolts[nContFBt].type
end
if DGD.tFlushBolts[nContFBt].side then
sOutLogMsg = sOutLogMsg..' '..DGD.tFlushBolts[nContFBt].side
end
if DGD.tFlushBolts[nContFBt].position then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tFlushBolts[nContFBt].position,4)
end
if DGD.tFlushBolts[nContFBt].offset then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tFlushBolts[nContFBt].offset,4)
end
if DGD.tFlushBolts[nContFBt].back_set then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tFlushBolts[nContFBt].back_set,4)
end
if DGD.tFlushBolts[nContFBt].other_door then
sOutLogMsg = sOutLogMsg .. ' ' .. DGD.tFlushBolts[nContFBt].other_door
end
DoorOutLog( sOutLogMsg, 0)
nContFBt = nContFBt + 1
end
end
end
end
if #DGD.tFlushBolts == 0 then -- se non ho trovato serrature
DoorOutLog( EgtDoorsMsg[449], 0)
end
-- Lettura dati serrature
if not DGD.sFrame or DGD.sFrame == 'L' or DGD.sFrame == 'LE' then
if GetEdgePulls() then
if DGD.tEdgePulls then
local nContEp = 1
while nContEp <= #DGD.tEdgePulls do
sOutLogMsg = ' DGD.tEdgePulls.Id='..EgtNumToString(nContEp,0)..' '..
DGD.tEdgePulls[nContEp].template
if DGD.tEdgePulls[nContEp].position then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tEdgePulls[nContEp].position,4)
end
DoorOutLog( sOutLogMsg, 0)
nContEp = nContEp + 1
end
end
end
end
if #DGD.tEdgePulls == 0 then -- se non ho trovato serrature
DoorOutLog( EgtDoorsMsg[450], 0)
end
-- Lettura dati Roller Latch
if not DGD.sFrame or DGD.sFrame == 'L' or DGD.sFrame == 'LE' or DGD.nTypePz == 5 or
DGD.nTypePz == 6 then
if GetRollerLatchs() then
if DGD.tRollerLatchs then
local nContRL = 1
while nContRL <= #DGD.tRollerLatchs do
sOutLogMsg = ' DGD.tRollerLatchs.Id='..EgtNumToString(nContRL,0)..' '..
DGD.tRollerLatchs[nContRL].template
if DGD.tRollerLatchs[nContRL].side then
sOutLogMsg = sOutLogMsg..' '..DGD.tRollerLatchs[nContRL].side
end
if DGD.tRollerLatchs[nContRL].position then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tRollerLatchs[nContRL].position,4)
end
if DGD.tRollerLatchs[nContRL].offset then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tRollerLatchs[nContRL].offset,4)
end
if DGD.tRollerLatchs[nContRL].other_door then
sOutLogMsg = sOutLogMsg .. ' ' .. DGD.tRollerLatchs[nContRL].other_door
end
DoorOutLog( sOutLogMsg, 0)
nContRL = nContRL + 1
end
end
end
end
if #DGD.tRollerLatchs == 0 then -- se non ho trovato Roller Latchs
DoorOutLog( EgtDoorsMsg[451], 0)
end
-- Lettura dati Pivot Hinge
if not DGD.sFrame or DGD.sFrame == 'H' or DGD.sFrame == 'HE' or DGD.nTypePz == 5 or DGD.nTypePz == 6 then
if GetPivots() then
if DGD.tPivots then
local nContPv = 1
while nContPv <= #DGD.tPivots do
sOutLogMsg = ' DGD.tPivots.Id='..EgtNumToString(nContPv,0)..' '..
DGD.tPivots[nContPv].template
if DGD.tPivots[nContPv].type then
sOutLogMsg = sOutLogMsg..' '..DGD.tPivots[nContPv].type
end
if DGD.tPivots[nContPv].side then
sOutLogMsg = sOutLogMsg..' '..DGD.tPivots[nContPv].side
end
if DGD.tPivots[nContPv].radius then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tPivots[nContPv].radius,4)
end
if DGD.tPivots[nContPv].position then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tPivots[nContPv].position,4)
end
if DGD.tPivots[nContPv].back_set then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tPivots[nContPv].back_set,4)
end
if DGD.tPivots[nContPv].depth_f then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tPivots[nContPv].depth_f,4)
end
if DGD.tPivots[nContPv].offset then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tPivots[nContPv].offset,4)
end
if DGD.tPivots[nContPv].other_door then
sOutLogMsg = sOutLogMsg .. ' ' .. DGD.tPivots[nContPv].other_door
end
DoorOutLog( sOutLogMsg, 0)
nContPv = nContPv + 1
end
end
end
end
if #DGD.tPivots == 0 then -- se non ho trovato Pivot Hinges
DoorOutLog( EgtDoorsMsg[452], 0)
end
-- Lettura dati stops and closers
if not DGD.sFrame or DGD.nTypePz == 5 then
if GetStopsAndClosers() then
if DGD.tStopsAndClosers then
local nContSC = 1
while nContSC <= #DGD.tStopsAndClosers do
sOutLogMsg = ' DGD.tStopsAndClosers.Id='..EgtNumToString(nContSC,0)..' '..
DGD.tStopsAndClosers[nContSC].template
if DGD.tStopsAndClosers[nContSC].position then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tStopsAndClosers[nContSC].position,4)
end
if DGD.tStopsAndClosers[nContSC].pocket_offset then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tStopsAndClosers[nContSC].pocket_offset,4)
end
if DGD.tStopsAndClosers[nContSC].other_door then
sOutLogMsg = sOutLogMsg .. ' ' .. DGD.tStopsAndClosers[nContSC].other_door
end
DoorOutLog( sOutLogMsg, 0)
nContSC = nContSC + 1
end
end
end
end
if #DGD.tStopsAndClosers == 0 then -- se non ho trovato stop and closers
DoorOutLog( EgtDoorsMsg[453], 0)
end
-- Lettura dati over head
if not DGD.sFrame or DGD.nTypePz == 5 then
if GetOverHeads() then
if DGD.tOHeads then
local nContOH = 1
while nContOH <= #DGD.tOHeads do
sOutLogMsg = ' DGD.tOHeads.Id='..EgtNumToString(nContOH,0)..' '..
DGD.tOHeads[nContOH].template
if DGD.tOHeads[nContOH].pockpos then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tOHeads[nContOH].pockpos,4)
end
if DGD.tOHeads[nContOH].pocklength then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tOHeads[nContOH].pocklength,4)
end
if DGD.tOHeads[nContOH].pocket_offset then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tOHeads[nContOH].pocket_offset,4)
end
if DGD.tOHeads[nContOH].armpos then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tOHeads[nContOH].armpos,4)
end
if DGD.tOHeads[nContOH].armlength then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tOHeads[nContOH].armlength,4)
end
if DGD.tOHeads[nContOH].other_door then
sOutLogMsg = sOutLogMsg .. ' ' .. DGD.tOHeads[nContOH].other_door
end
DoorOutLog( sOutLogMsg, 0)
nContOH = nContOH + 1
end
end
end
end
if #DGD.tOHeads == 0 then -- se non ho trovato over head
DoorOutLog( EgtDoorsMsg[526], 0)
end
-- Lettura dati strike ( non inserisce stike che stonno su frame top e bottom)
if not DGD.sFrame or DGD.sFrame == 'L' or DGD.sFrame == 'LE' or DGD.nTypePz == 5 or DGD.nTypePz == 6 then
if GetStrikes() then
if DGD.tStrikes then
local nContSt = 1
while nContSt <= #DGD.tStrikes do
sOutLogMsg = ' DGD.tStrikes.Id='..EgtNumToString(nContSt,0)..' '..
DGD.tStrikes[nContSt].template
if DGD.tStrikes[nContSt].position then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tStrikes[nContSt].position,4)
end
if DGD.tStrikes[nContSt].back_set then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tStrikes[nContSt].back_set,4)
end
if DGD.tStrikes[nContSt].offset then
sOutLogMsg = sOutLogMsg .. ' ' .. EgtNumToString(DGD.tStrikes[nContSt].offset,4)
end
if DGD.tStrikes[nContSt].other_door then
sOutLogMsg = sOutLogMsg .. ' ' .. DGD.tStrikes[nContSt].other_door
end
DoorOutLog( sOutLogMsg, 0)
nContSt = nContSt + 1
end
end
end
end
if #DGD.tStrikes == 0 then -- se non ho trovato strike
DoorOutLog( EgtDoorsMsg[535], 0)
end
-- Lettura dati groove
if not DGD.sFrame then
if GetGrooves() then
if DGD.tGrooves then
local nContGr = 1
while nContGr <= #DGD.tGrooves do
sOutLogMsg = ' DGD.tGrooves.Id='..EgtNumToString(nContGr,0)..' '..
DGD.tGrooves[nContGr].template
if DGD.tGrooves[nContGr].type then
sOutLogMsg = sOutLogMsg..' '..DGD.tGrooves[nContGr].type
end
if DGD.tGrooves[nContGr].width then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tGrooves[nContGr].width,4)
end
if DGD.tGrooves[nContGr].depth then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tGrooves[nContGr].depth,4)
end
if DGD.tGrooves[nContGr].fst then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tGrooves[nContGr].fst,4)
end
if DGD.tGrooves[nContGr].hst then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tGrooves[nContGr].hst,4)
end
if DGD.tGrooves[nContGr].lst then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tGrooves[nContGr].lst,4)
end
if DGD.tGrooves[nContGr].groove_offset then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tGrooves[nContGr].groove_offset,4)
end
if DGD.tGrooves[nContGr].side then
sOutLogMsg = sOutLogMsg..' '..DGD.tGrooves[nContGr].side
end
DoorOutLog( sOutLogMsg, 0)
nContGr = nContGr + 1
end
end
end
end
if #DGD.tGrooves == 0 then -- se non ho trovato groove
DoorOutLog( EgtDoorsMsg[536], 0)
end
-- Lettura dati rabbet
-- if not DGD.sFrame then
if GetRabbets() then
if DGD.tRabbets then
local nContRb = 1
while nContRb <= #DGD.tRabbets do
sOutLogMsg = ' DGD.tRabbets.Id='..EgtNumToString(nContRb,0)..' '..
DGD.tRabbets[nContRb].template
if DGD.tRabbets[nContRb].side then
sOutLogMsg = sOutLogMsg..' '..DGD.tRabbets[nContRb].side
end
if DGD.tRabbets[nContRb].width then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tRabbets[nContRb].width,4)
end
if DGD.tRabbets[nContRb].depth then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tRabbets[nContRb].depth,4)
end
if DGD.tRabbets[nContRb].oppo then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tRabbets[nContRb].oppo,4)
end
DoorOutLog( sOutLogMsg, 0)
nContRb = nContRb + 1
end
end
end
-- end
if #DGD.tRabbets == 0 then -- se non ho trovato rabbet
DoorOutLog( EgtDoorsMsg[537], 0)
end
-- Lettura dati Face Decoration
if not DGD.sFrame then
if GetDecorations() then
if DGD.tDecorations then
local nContDc = 1
while nContDc <= #DGD.tDecorations do
sOutLogMsg = ' DGD.tDecorations.Id='..EgtNumToString(nContDc,0)..' '..
DGD.tDecorations[nContDc].template
if DGD.tDecorations[nContDc].type then
sOutLogMsg = sOutLogMsg..' '..DGD.tDecorations[nContDc].type
end
if DGD.tDecorations[nContDc].depth then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tDecorations[nContDc].depth,4)
end
if DGD.tDecorations[nContDc].dft then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tDecorations[nContDc].dft,4)
end
if DGD.tDecorations[nContDc].dfb then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tDecorations[nContDc].dfb,4)
end
if DGD.tDecorations[nContDc].dfl then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tDecorations[nContDc].dfl,4)
end
if DGD.tDecorations[nContDc].dfh then
sOutLogMsg = sOutLogMsg..' '..EgtNumToString(DGD.tDecorations[nContDc].dfh,4)
end
if DGD.tDecorations[nContDc].face then
sOutLogMsg = sOutLogMsg .. ' ' .. DGD.tDecorations[nContDc].face
end
DoorOutLog( sOutLogMsg, 0)
nContDc = nContDc + 1
end
end
end
end
if #DGD.tDecorations == 0 then -- se non ho trovato serrature
DoorOutLog( EgtDoorsMsg[645], 0)
end
-- lettura nuovo gruppo options
if GetOptions() then
sOutLogMsg = ' DGD.tOptions=' .. table.concat( DGD.tOptions, ',')
DoorOutLog( sOutLogMsg, 0)
end
-- se a questo punto il ddf non termina o non ha il separatore di pezzo '---'
-- c'è un errore nel ddf appena letto
if not CheckKeyFromLine( '---') and not CheckKeyFromLine( '...') and not EndOfFile() then
DoorOutLog( string.format( EgtDoorsMsg[604], GetLineNumber()), 0)
DGD.ERM = DGD.ERM .. '\n' .. string.format( EgtDoorsMsg[604], GetLineNumber())
DGD.ERR = 9
bWriteErr = false
break
end
-------------------------------------------
-------------------------------------------
-- faccio la verifica sulla Mtable
-------------------------------------------
-------------------------------------------
sMTable = sMTableOri
-- per risalire al nome file della tabella, aggiungo eventuale nome materiale
-- tranne se il nome è wood
if DGD.Material and #DGD.Material > 0 and string.lower(DGD.Material) ~= 'wood' then
sMTable = sMTable .. '_' .. DGD.Material
end
bLocFoundMTable = VerifyMtable()
-- percorsi dei file pezzo locale
sTxtOkFile = sFileDir .. DGD.sCode .. '.tok'
sErrFile = sFileDir .. DGD.sCode .. '.txt'
sCncFile = sFileDir .. DGD.sCode .. '.cnc'
sNgeFile = sFileDir .. DGD.sCode .. '.nge'
sOriPrbFile = sFileDir .. 'data.dat'
sPrbFile = sFileDir .. DGD.sCode .. '.dat'
-- Rimozione vecchi file log, nge e cnc e tok
EgtEraseFile( sErrFile)
EgtEraseFile( sTxtOkFile)
EgtEraseFile( sNgeFile)
EgtEraseFile( sCncFile)
-- creo pezzo porta
if DGD.ERR <= 0 then
nCountPieces = nCountPieces + 1
-- leggo il file probe (se c'è il flag di ri-calcolo porta da file probe)
local bReadFileDat = LoadDataProbeFile( sOriPrbFile, sPrbFile)
if bReadFileDat then
-- Controllo che la versione del file .prb non coincide con il settaggio presente nel file CurrDoorsCustomData
if DGD.PROBE == 2 and ( not tProbeDoor.OPM or not DGC.Pms or ( tProbeDoor.OPM and DGC.Pms and tProbeDoor.OPM ~= DGC.Pms)) then
local sMessageErr = string.format( EgtDoorsMsg[659], sPrbFile) -- file dat non trovato
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 26
else
-- Creazione della porta
bLocFoundMTable = DoorCreation()
EgtSaveFile( sNgeFile)
DoorOutLog( ' *** Door creation completed ***', 0)
-- se prima porta
if nTypePiece == 1 then
sFirstDoor = sNgeFile
elseif nTypePiece == 2 then
sSecondDoor = sNgeFile
elseif nTypePiece == 3 then
sFrameSx = sNgeFile
elseif nTypePiece == 4 then
sFrameDx = sNgeFile
elseif nTypePiece == 5 then
sFrameTop = sNgeFile
elseif nTypePiece == 6 then
sFrameBot = sNgeFile
end
end
else
local sMessageErr = string.format( EgtDoorsMsg[631], sPrbFile) -- file dat non trovato
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 12
end
end
-- Scrivo il risultato su file apposito
WriteErrFile( sErrFile)
DoorOutLog( ' Err=' .. tostring( DGD.ERR) .. '\n', 1)
bWriteErr = true
else -- se non trovata descrizione ddf
sPrvKeyLine = '---'
end
-- se trovato separatore altro pezzo
if KeyFromLine( '---') then
if sNgeFile then
DoorOutLog( ' *** End piece file : ' .. sNgeFile ..' ***\n', 0)
sNgeFile = nil
end
DoorOutLog( ' *** Next piece into parsing file : ' .. DGD.FILE ..' ***\n', 0)
sPrvKeyLine = '---'
else
if sNgeFile then
DoorOutLog( ' *** End piece file : ' .. sNgeFile ..' ***', 0)
end
end
end -- end while
-- se il file txt dell'errore non ancora scritto, assegno le variabili di errore degli assemblati
if not bWriteErr then
if DGD.EGR == 0 then
DGD.EGR = DGD.ERR
end
if DGD.ERM and string.len(DGD.ERM) > 0 then
if DGD.EGM then
DGD.EGM = DGD.EGM .. '\n' .. DGD.ERM
end
end
end
-- Scrivo il risultato su file apposito
WriteErrFileAsmbl( sErrFileM)
if not bWriteErr then
DoorOutLog( ' Err=' .. tostring( DGD.ERR) .. '\n', 1)
end
-- Chiusura file DDF
if bOpenDdf then
CloseFile()
end
return bLocFoundMTable
end
-----------------------------------------------------------------
-- *** Main function ***
-----------------------------------------------------------------
local function Doors()
-- Reset librerie per evitare l'errore in caso riparto da una situazione di errore dello script
ResetDoorsLibs()
-- Reset dati globali
ResetDoorsGlobDataAssembly()
ResetDoorsGlobData()
-- Reset dati custom
ResetDoorsCustomData()
local sMessageErr
-- debug per abilitare le quote nell'EgtCam5
-- DGD.MachEn = 0
-- per evitare problemi nel caso che nel nome file o nella cartella sia presente 'ddf'
-- separo path nome ed estensione e poi successivamente concateno direttamente l'estensione
sFileDir, sFileName, sFileExt = EgtSplitPath( DGD.FILE)
sErrFileM = sFileDir .. sFileName .. '.txt'
sLogFile = sFileDir .. sFileName .. '.log'
sTxtOkFile = sFileDir .. sFileName .. '.tok'
-- Rimozione vecchi file log, nge e cnc
EgtEraseFile( sLogFile)
EgtEraseFile( sErrFileM)
EgtEraseFile( sTxtOkFile)
-- creo nuovo file log
OpenLogFile(sLogFile, 'w')
-- variabili per gestione file MTable
local sIniFilePath = EgtGetIniFile() -- percorso del file ini dell'EgtCam5
sMTable = EgtGetStringFromIni( 'Doors', 'CurrMTable', '', sIniFilePath)
sMTableOri = sMTable
local tMTable
local tMachineOptions
local bFoundMTable
-- local M
-- resetto contatore pezzi e il tipo pezzi
nCountPieces = 0
nTypePiece = 0
--[[
-- questo è un codice ipotetico
-- la tabella attualmente non viene passata dal file batch
-- verifico se c'è il nome tabella passato da batch
-- if DGD.NCGEN and DGD.NTB and string.len(DGD.NTB) > 0 then
-- sMTable = DGD.NTB
-- bFoundMTable = true
-- else
-- verifico se esiste il nome file
if sMTable and string.len(sMTable) > 0 then
bFoundMTable = true
end
-- end
-- se nome MTable presente
if bFoundMTable and DGD.MachEn > 0 then
-- verifico se esiste il file
sMTablePath = sBaseDir..'MTables\\'..sMTable..'.mtl'
if EgtExistsFile(sMTablePath) then
sMTablePath = sBaseDir..'MTables\\'
M = require( sMTable)
if M then
tMachineData = M.MMachineData
if not tMachineData then
sMessageErr = string.format( EgtDoorsMsg[489], sMTable) -- dati macchina non validi
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 25
WriteErrFile( sErrFileM)
bFoundMTable = false
end
else
sMessageErr = string.format( EgtDoorsMsg[490], sMTable) -- tabella non trovata
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 24
WriteErrFile( sErrFileM)
bFoundMTable = false
end
else
sMessageErr = string.format( EgtDoorsMsg[487], sMTablePath) -- non c'è il file della tabella
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 23
WriteErrFile( sErrFileM)
bFoundMTable = false
end
elseif DGD.MachEn > 0 then
sMessageErr = string.format( EgtDoorsMsg[487], sMTable) -- il nome del file della tabella non è valido
DoorOutLog( sMessageErr, 0)
DGD.ERM = DGD.ERM .. '\n' .. sMessageErr
DGD.ERR = 22
WriteErrFile( sErrFileM)
end
]]--
-- if ( bFoundMTable and DGD.MachEn > 0) or DGD.MachEn == 0 then
if DGD.MachEn >= 0 then
-- Segnalo inizio interpretazione file
DoorOutLog( ' *** Start parsing file : ' .. DGD.FILE ..' ***', 0)
-- controllo variabile che dovrebbe provenire dal prod
if not DGD.PROBE then DGD.PROBE = 0 end
-- controllo variabile che dovrebbe provenire dal CurrDoorsCustomData
if not DGC.NPM then DGC.NPM = 0 end
-- se DGD.NPM = 1 ma settata nuova interpretazione, forzo il parametro DGC.Pms = 1
if DGC.NPM > 0 then
DGC.Pms = 1
-- se DGD.NPM = 2 forzo il parametro DGC.PROBE = 1
if DGC.NPM == 2 then
DGD.PROBE = 1
end
end
-- controllo variabile che dovrebbe provenire dal CurrDoorsCustomData
if not DGC.Pms then DGC.Pms = 0 end
-- Lettura file DDF e creazione geometria porta
bFoundMTable = ReadAndParseDdfAndMakeDoors()
if bFoundMTable then
-- se non è lanciato dal batch e ci sono più pezzi li carico in un unico progetto
if nCountPieces > 1 and DGD.ERR <= 0 then
EgtNewFile()
DGD.PZ = EgtGroup( GDB_ID.ROOT)
EgtSetName( DGD.PZ, sFileName)
EgtSetCurrPartLayer( DGD.PZ, GDB_ID.NULL)
local nIdDummyPart = EgtGetFirstPart()
local nIdFrameSx, nIdDoor1, nIdDoor2, nIdFrameDx, nIdFrameTop, nIdFrameBot
local dOffsLeft = 0
if sFirstDoor and EgtInsertFile( sFirstDoor) then
-- non muovo la prima porta
nIdDoor1 = EgtGetLastPart()
EgtSetInfo( nIdDoor1, 'Assembly', 'first')
EgtSetInfo( nIdDoor1, 'MoveedTo', {0,0,0})
local dWidthPiece = EgtGetInfo( nIdDoor1, 'W', 'd')
dOffsLeft = dWidthPiece
-- setto nota modalità probe
EgtSetInfo( nIdDoor1, 'ProbeMode', DGD.PROBE)
-- setto nota postprocessor probe mode setting
EgtSetInfo( nIdDoor1, 'PostProbeSet', DGC.Pms)
EgtSetInfo( nIdDoor1, 'NewProbeMean', DGC.NPM)
end
if sSecondDoor and EgtInsertFile( sSecondDoor) then
-- rototraslazione del pezzo
nIdDoor2 = EgtGetLastPart()
EgtSetInfo( nIdDoor2, 'Assembly', 'second')
local dWidthPiece = EgtGetInfo( nIdDoor2, 'W', 'd')
local dThickPiece = EgtGetInfo( nIdDoor2, 'T', 'd')
if dOffsLeft > 0 then
dOffsLeft = dOffsLeft + 10
end
EgtMove( nIdDoor2, Point3d( dOffsLeft,0,0) - ORIG(), GDB_RT.GRID)
EgtSetInfo( nIdDoor2, 'MoveedTo', {dOffsLeft,0,0})
-- setto nota modalità probe
EgtSetInfo( nIdDoor2, 'ProbeMode', DGD.PROBE)
-- setto nota postprocessor probe mode setting
EgtSetInfo( nIdDoor2, 'PostProbeSet', DGC.Pms)
EgtSetInfo( nIdDoor2, 'NewProbeMean', DGC.NPM)
-- aggiorno offset per eventuale prossimo pezzo
dOffsLeft = dOffsLeft + dWidthPiece
end
if sFrameSx and EgtInsertFile( sFrameSx) then
-- rototraslazione del pezzo
nIdFrameSx = EgtGetLastPart()
EgtSetInfo( nIdFrameSx, 'Assembly', 'framesx')
local dWidthPiece = EgtGetInfo( nIdFrameSx, 'W', 'd')
local dThickPiece = EgtGetInfo( nIdFrameSx, 'T', 'd')
EgtMove( nIdFrameSx, Point3d(-( dWidthPiece + dThickPiece),0,0) - ORIG(), GDB_RT.GRID)
EgtSetInfo( nIdFrameSx, 'MoveedTo', {-( dWidthPiece + dThickPiece),0,0})
end
if sFrameDx and EgtInsertFile( sFrameDx) then
-- rototraslazione del pezzo
nIdFrameDx = EgtGetLastPart()
EgtSetInfo( nIdFrameDx, 'Assembly', 'framedx')
local dWidthPiece = EgtGetInfo( nIdFrameDx, 'W', 'd')
local dThickPiece = EgtGetInfo( nIdFrameDx, 'T', 'd')
if dOffsLeft > 0 then
EgtMove( nIdFrameDx, Point3d(( dOffsLeft + dThickPiece),0,0) - ORIG(), GDB_RT.GRID)
EgtSetInfo( nIdFrameDx, 'MoveedTo', {( dOffsLeft + dThickPiece),0,0})
else
EgtMove( nIdFrameDx, Point3d( dThickPiece,0,0) - ORIG(), GDB_RT.GRID)
EgtSetInfo( nIdFrameDx, 'MoveedTo', {dThickPiece,0,0})
end
dOffsLeft = dOffsLeft + dWidthPiece + dThickPiece
end
if sFrameTop and EgtInsertFile( sFrameTop) then
-- rototraslazione del pezzo
nIdFrameTop = EgtGetLastPart()
EgtSetInfo( nIdFrameTop, 'Assembly', 'frametop')
local dWidthPiece = EgtGetInfo( nIdFrameTop, 'W', 'd')
local dThickPiece = EgtGetInfo( nIdFrameTop, 'T', 'd')
if dOffsLeft > 0 then
EgtMove( nIdFrameTop, Point3d(( dOffsLeft + dThickPiece),0,0) - ORIG(), GDB_RT.GRID)
EgtSetInfo( nIdFrameTop, 'MoveedTo', {( dOffsLeft + dThickPiece),0,0})
else
EgtMove( nIdFrameTop, Point3d( dThickPiece,0,0) - ORIG(), GDB_RT.GRID)
EgtSetInfo( nIdFrameTop, 'MoveedTo', {dThickPiece,0,0})
end
dOffsLeft = dOffsLeft + dWidthPiece + dThickPiece
end
if sFrameBot and EgtInsertFile( sFrameBot) then
-- rototraslazione del pezzo
nIdFrameBot = EgtGetLastPart()
EgtSetInfo( nIdFrameBot, 'Assembly', 'framebot')
local dWidthPiece = EgtGetInfo( nIdFrameBot, 'W', 'd')
local dThickPiece = EgtGetInfo( nIdFrameBot, 'T', 'd')
if dOffsLeft > 0 then
EgtMove( nIdFrameBot, Point3d(( dOffsLeft + dThickPiece),0,0) - ORIG(), GDB_RT.GRID)
EgtSetInfo( nIdFrameBot, 'MoveedTo', {( dOffsLeft + dThickPiece),0,0})
else
EgtMove( nIdFrameBot, Point3d( dThickPiece,0,0) - ORIG(), GDB_RT.GRID)
EgtSetInfo( nIdFrameBot, 'MoveedTo', {dThickPiece,0,0})
end
end
if nIdFrameSx or nIdDoor1 or nIdDoor2 or nIdFrameDx or nIdFrameBot then
EgtErase(nIdDummyPart)
end
-- setto la griglia top
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
sNgeFile = sFileDir .. sFileName .. '.nge'
EgtSaveFile( sNgeFile)
elseif nCountPieces == 1 and DGD.ERR <= 0 then
if sFrameSx then
local nIdPiece = EgtGetLastPart()
EgtSetInfo( nIdPiece, 'Assembly', 'framesx')
EgtSetInfo( nIdPiece, 'MoveedTo', {0,0,0})
elseif sFrameDx then
local nIdPiece = EgtGetLastPart()
EgtSetInfo( nIdPiece, 'Assembly', 'framedx')
EgtSetInfo( nIdPiece, 'MoveedTo', {0,0,0})
elseif sFrameTop then
local nIdPiece = EgtGetLastPart()
EgtSetInfo( nIdPiece, 'Assembly', 'frametop')
EgtSetInfo( nIdPiece, 'MoveedTo', {0,0,0})
elseif sFrameBot then
local nIdPiece = EgtGetLastPart()
EgtSetInfo( nIdPiece, 'Assembly', 'framebot')
EgtSetInfo( nIdPiece, 'MoveedTo', {0,0,0})
end
-- setto nota modalità probe
local nIdPiece = EgtGetLastPart()
EgtSetInfo( nIdPiece, 'ProbeMode', DGD.PROBE)
-- setto nota postprocessor probe mode setting
EgtSetInfo( nIdPiece, 'PostProbeSet', DGC.Pms)
EgtSetInfo( nIdPiece, 'NewProbeMean', DGC.NPM)
-- setto la griglia top
EgtSetGridFrame( Frame3d( 0,0,0, GDB_FR.TOP))
sNgeFile = sFileDir .. sFileName .. '.nge'
EgtSaveFile( sNgeFile)
end
-- Se richiesta generazione lavorazioni da file batch e non ci sono stati errori
if DGD.NCGEN and DGD.ERR <= 0 then
if not dofile( sBaseDir..'Machining.lua') then -- se machining va male
if string.len(DGD.EMC) > 0 then
DoorOutLog( DGD.EMC, 0)
else
DoorOutLog( EgtDoorsMsg[455], 0)
end
DGD.ERM = DGD.ERM .. '\n' .. EgtDoorsMsg[455]
if DGD.ERR <= 0 then
DGD.ERR = 20
end
DoorOutLog( ' Err=' .. tostring( DGD.ERR) .. '\n', 1)
else
DoorOutLog( ' ' .. EgtDoorsMsg[498], 0)
EgtOutText( EgtDoorsMsg[498])
end
end
end
end
-- chiudo file log
CloseLogFile()
-- Reset librerie
ResetDoorsLibs()
package.loaded.EgtDoorsBase = nil
if DGD.EGR and DGD.EGR ~= 0 and DGD.ERR ~= DGD.EGR then
DGD.ERR = DGD.EGR
elseif DGD.EGR and DGD.EGR ~= 0 then
DGD.ERR = DGD.EGR
end
DGC = nil
return DGD.ERR
end
DGD.Doors = Doors
return {}
Reference in New Issue View Git Blame Copy Permalink