SaraP
67589d44ef
- arco a 3 centri - migliorie e correzioni varie per gestire correttamente l'arco a 3 centri ( calcolo solidi, strip, outline del fill).
6702 lines
292 KiB
Lua
6702 lines
292 KiB
Lua
--
|
|
-- EEEEEEEEEE GGGGGG TTTTTTTTTTTTTT
|
|
-- EEEEEEEEEE GGGGGGGGGG TTTTTTTTTTTTTT
|
|
-- EEEE GGGG GGGG TTTT
|
|
-- EEEE GGGG TTTT
|
|
-- EEEEEEE GGGG GGGGGGG TTTT
|
|
-- EEEEEEE GGGG GGGGGGG TTTT
|
|
-- EEEE GGGG GGGG TTTT
|
|
-- EEEE GGGG GGGG TTTT
|
|
-- EEEEEEEEEE GGGGGGGGGG TTTT
|
|
-- EEEEEEEEEE GGGGGG TTTT
|
|
--
|
|
-- by Egalware s.r.l.
|
|
-- Window project software by Egalware s.r.l. 2023/05/02
|
|
|
|
-- Tabella per definizione modulo
|
|
local WinCalculate = {}
|
|
|
|
-- Include
|
|
require( 'EgtBase')
|
|
require( 'WinConst')
|
|
|
|
_G.package.loaded.JSON = nil
|
|
local JSON = require( 'JSON')
|
|
_G.package.loaded.XML = nil
|
|
local XML = require( 'xml2lua')
|
|
_G.package.loaded.XMLHandler = nil
|
|
local XMLHandler = require( 'xml2lua_tree')
|
|
|
|
local s_nRedisConnectionId = 0 -- 0 connessione non definita, > 0 connessione definita
|
|
local s_dDowelTol = 1
|
|
local s_dSimplSolidApprox = 0.2 -- approssimazione lineare nel caso di solidi semplificati
|
|
local s_nSashNbr = 0 -- contatore delle ante per assegnare nomi
|
|
|
|
local s_bCalcSolid = false
|
|
function WinCalculate.GetCalcSolid()
|
|
return s_bCalcSolid
|
|
end
|
|
function WinCalculate.SetCalcSolid( bValue)
|
|
s_bCalcSolid = bValue
|
|
end
|
|
|
|
local s_bSimplSolid = false
|
|
function WinCalculate.SetSimplifiedSolid( bValue)
|
|
s_bSimplSolid = bValue
|
|
end
|
|
|
|
local s_bCalcPreview = false
|
|
function WinCalculate.SetCalcPreview( bValue)
|
|
s_bCalcPreview = bValue
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che copia la info di chiave sInfo da nSou a nDest
|
|
local function CopyInfo( nDest, nSou, sInfo, Default)
|
|
local sVal = EgtGetInfo( nSou, sInfo) or Default
|
|
EgtSetInfo( nDest, sInfo, sVal)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che restituisce o crea il layer ausiliario per soldi di ferramenta e accessori
|
|
local function GetAuxLayer()
|
|
local nAuxLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AUX)
|
|
if not nAuxLayerId then
|
|
nAuxLayerId = EgtGroup( GDB_ID.ROOT)
|
|
EgtSetName( nAuxLayerId, WIN_AUX)
|
|
EgtSetLevel( nAuxLayerId, GDB_LV.SYSTEM)
|
|
end
|
|
return nAuxLayerId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che trova il punto di intersezione fra due curve considerandole estese
|
|
local function FindIntersectionPoint( nCrv1, nCrv2, ptRef)
|
|
|
|
local ptInt = EgtIP( nCrv1, nCrv2, ptRef)
|
|
|
|
-- se il punto di intersezione non esiste ritento estendendo le curve
|
|
if not ptInt then
|
|
local nGrp = EgtGetParent( nCrv1)
|
|
local dExtraLen = 10000
|
|
local nCrvA, nCrvB
|
|
if EgtGetType( nCrv1) == GDB_TY.CRV_LINE and EgtGetType( nCrv2) == GDB_TY.CRV_LINE then
|
|
-- caso linea-linea : estendo le due linee
|
|
nCrvA = EgtCopyGlob( nCrv1, nGrp)
|
|
nCrvB = EgtCopyGlob( nCrv2, nGrp)
|
|
EgtExtendCurveStartByLen( nCrvA, dExtraLen)
|
|
EgtExtendCurveEndByLen( nCrvA, dExtraLen)
|
|
EgtExtendCurveStartByLen( nCrvB, dExtraLen)
|
|
EgtExtendCurveEndByLen( nCrvB, dExtraLen)
|
|
|
|
elseif EgtGetType( nCrv1) == GDB_TY.CRV_ARC and EgtGetType( nCrv2) == GDB_TY.CRV_ARC then
|
|
-- caso arco-arco : cerco intersezione tra le due circonferenze
|
|
nCrvA = EgtCircle( nGrp, EgtCP( nCrv1), EgtArcRadius( nCrv1))
|
|
nCrvB = EgtCircle( nGrp, EgtCP( nCrv2), EgtArcRadius( nCrv2))
|
|
|
|
else
|
|
-- caso arco-linea : cerco intersezione fra la linea e la circonferenza
|
|
local nArc = EgtIf( EgtGetType( nCrv1) == GDB_TY.CRV_ARC, nCrv1, nCrv2)
|
|
local nLine = EgtIf( nArc == nCrv1, nCrv2, nCrv1)
|
|
nCrvA = EgtCircle( nGrp, EgtCP( nArc), EgtArcRadius( nArc))
|
|
nCrvB = EgtCopyGlob( nLine, nGrp)
|
|
EgtExtendCurveStartByLen( nCrvB, dExtraLen)
|
|
EgtExtendCurveEndByLen( nCrvB, dExtraLen)
|
|
end
|
|
|
|
ptInt = EgtIP( nCrvA, nCrvB, ptRef)
|
|
EgtErase( { nCrvA, nCrvB})
|
|
end
|
|
|
|
return ptInt
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che data una lista di curve ordinate e orientate che creano una curva chiusa, ne individua la regione definita
|
|
local function CalcIntersectionRegion( vCrvs, nGrp)
|
|
|
|
local nSurfId
|
|
|
|
-- gruppo temporaneo per i conti
|
|
local nGrpTmp = EgtGroup( nGrp)
|
|
EgtSetStatus( nGrpTmp, GDB_ST.OFF)
|
|
|
|
-- costruisco le regioni definite dai semipiani delle linee che compongono il contorno e
|
|
-- costruisco le circonferenze associate agli archi verificando non ve ne siano di coincidenti
|
|
local dExtraLen = 10000
|
|
local vSemiPlaneSurfs = {}
|
|
local tArcs = {}
|
|
for i = 1, #vCrvs do
|
|
if EgtGetType( vCrvs[i]) == GDB_TY.CRV_LINE then
|
|
local vtDir = EgtSV( vCrvs[i])
|
|
local vtOrtho = Vector3d( vtDir)
|
|
vtOrtho:rotate( Z_AX(), 90)
|
|
local nSemiPlaneId = EgtSurfFrRectangle( nGrpTmp, ORIG(), Point3d( EgtCurveLength( vCrvs[i]) + 2 * dExtraLen, dExtraLen, 0))
|
|
local frRect = Frame3d( EgtSP( vCrvs[i]) - vtDir * dExtraLen, vtDir, vtOrtho, Z_AX())
|
|
EgtTransform( nSemiPlaneId, frRect)
|
|
table.insert( vSemiPlaneSurfs, nSemiPlaneId)
|
|
|
|
else
|
|
-- creo circonferenza corrispondente
|
|
local nCircleId = EgtCopyGlob( vCrvs[i], nGrpTmp)
|
|
local dAngOld = EgtArcAngCenter( vCrvs[i])
|
|
EgtModifyArcAngCenter( nCircleId, EgtIf( dAngOld > 0, 360, -360))
|
|
-- verifico se coincide con altra circonferenza già costruita
|
|
local dRad = EgtArcRadius( nCircleId)
|
|
local ptC = EgtCP( nCircleId)
|
|
local bOverlap = false
|
|
for j = 1, #tArcs do
|
|
if AreSamePointApprox( tArcs[j].ptC, ptC) and abs( tArcs[j].dRad - dRad) < GEO.EPS_SMALL then
|
|
bOverlap = true
|
|
table.insert( tArcs[j].nArcId, vCrvs[i])
|
|
break
|
|
end
|
|
end
|
|
if not bOverlap then
|
|
table.insert( tArcs, { nCircleId = nCircleId, nArcId = {vCrvs[i]}, dRad = dRad, ptC = ptC})
|
|
end
|
|
end
|
|
end
|
|
|
|
-- calcolo la regione definita dai semipiani
|
|
for i = 2, #vSemiPlaneSurfs do
|
|
EgtSurfFrIntersect( vSemiPlaneSurfs[1], vSemiPlaneSurfs[i])
|
|
EgtErase( vSemiPlaneSurfs[i])
|
|
end
|
|
nSurfId = vSemiPlaneSurfs[1]
|
|
|
|
-- se presenti archi, calcolo il loro contributo alla regione
|
|
if #tArcs > 0 then
|
|
|
|
local nCrvBorder = EgtExtractSurfFrChunkLoops( nSurfId, 0, nGrpTmp)
|
|
|
|
-- riordino circonferenze per raggio decrescente ( per gestire prima quelle più grandi che potrebbero contenere le altre)
|
|
table.sort( tArcs, function ( a, b) return a.dRad > b.dRad end)
|
|
|
|
for i = 1, #tArcs do
|
|
local nCircleId = tArcs[i].nCircleId
|
|
-- limito la circonferenza alla regione
|
|
local nSurfTrim = EgtSurfFlatRegion( nGrpTmp, nCrvBorder)
|
|
local nCrv, nCnt = EgtTrimCurveWithRegion( nCircleId, nSurfTrim, true, false)
|
|
|
|
if not nCrv then
|
|
-- è errore, lo ignoro
|
|
nCnt = 0
|
|
end
|
|
|
|
if nCnt > 0 then
|
|
-- unisco tratto iniziale e finale se consecutivi
|
|
if nCnt > 1 and AreSamePointApprox( EgtSP( nCrv), EgtEP( nCrv + nCnt - 1)) then
|
|
EgtModifyCurveStartPoint( nCrv, EgtSP( nCrv + nCnt - 1))
|
|
EgtErase( nCrv + nCnt - 1)
|
|
nCnt = nCnt - 1
|
|
end
|
|
|
|
-- spezzo in corrispondenza di eventuali punti tangenti alla regione
|
|
local vArcs = EgtTableFill( nCrv, nCnt)
|
|
for j = nCrv, nCrv + nCnt - 1 do
|
|
local nInters, nPntCnt, nCrvCnt = EgtCurveCurveInters( j, nCrvBorder, nGrpTmp)
|
|
local nCurrCrv = j
|
|
for nPntId = nInters, nInters + nPntCnt - 1 do
|
|
local dPar = EgtCurveParamAtPoint( nCurrCrv, EgtSP( nPntId))
|
|
local nNewCrv = EgtSplitCurveAtParam( nCurrCrv, dPar)
|
|
if nNewCrv then
|
|
table.insert( vArcs, nNewCrv)
|
|
nCurrCrv = nNewCrv
|
|
end
|
|
end
|
|
end
|
|
|
|
-- considero solo i tratti che poggiano sulle curve orginali
|
|
for j = 1, #vArcs do
|
|
|
|
local bOk = false
|
|
for k = 1, #tArcs[i].nArcId do
|
|
local nOrigArc = tArcs[i].nArcId[k]
|
|
local dParS = EgtCurveParamAtPoint( nOrigArc, EgtSP( vArcs[j]))
|
|
local dParE = EgtCurveParamAtPoint( nOrigArc, EgtEP( vArcs[j]))
|
|
if not dParS and not dParE then
|
|
-- se il nuovo tratto non poggia sull'originale, verifico se è l'originale a poggiare sul nuovo
|
|
local dPar1 = EgtCurveParamAtPoint( vArcs[j], EgtSP( nOrigArc))
|
|
local dPar2 = EgtCurveParamAtPoint( vArcs[j], EgtEP( nOrigArc))
|
|
if dPar1 or dPar2 then
|
|
bOk = true
|
|
break
|
|
end
|
|
elseif dParS and abs( dParS - 1) > GEO.EPS_SMALL then
|
|
bOk = true
|
|
break
|
|
elseif dParE and dParE > GEO.EPS_SMALL then
|
|
bOk = true
|
|
break
|
|
end
|
|
end
|
|
|
|
if not bOk then
|
|
EgtErase( vArcs[j])
|
|
else
|
|
-- modifico il bordo con il nuovo tratto
|
|
local dParS = EgtCurveParamAtPoint( nCrvBorder, EgtSP( vArcs[j]), 100 * GEO.EPS_SMALL)
|
|
local dParE = EgtCurveParamAtPoint( nCrvBorder, EgtEP( vArcs[j]), 100 * GEO.EPS_SMALL)
|
|
EgtTrimCurveStartEndAtParam( nCrvBorder, dParE, dParS)
|
|
EgtAddCurveCompoCurve( nCrvBorder, vArcs[j])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- ricostruisco la superficie
|
|
nSurfId = EgtSurfFlatRegion( nGrpTmp, nCrvBorder)
|
|
end
|
|
|
|
EgtRelocateGlob( nSurfId, nGrp)
|
|
EgtErase( nGrpTmp)
|
|
return nSurfId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- Gestione delle curve superflue in TrimOrderedCurves : le modalità di trattamento sono indicate da nMode e sono le seguenti
|
|
-- 0/nil = curva eliminata ( caso standard)
|
|
-- 1 = curva eliminata rimuovendo la corrispondenza dalle info della curva di base outline da cui deriva ( se chiamata da outline)
|
|
-- 2 = curva non viene eliminata ma viene settata info che indica di ignorarla ( se chiamata dal geo)
|
|
local function AdjustExtraCurvesForTrim( nCrvId, nSurfId, nMode)
|
|
|
|
if not nMode or nMode == 0 then
|
|
EgtErase( nCrvId)
|
|
|
|
elseif nMode == 1 then
|
|
-- rimuovo la info che riconduce alla curva che sto per eliminare dalla curva corrispondente del base outline
|
|
local nBaseOutline = EgtGetInfo( nCrvId, WIN_COPY, 'i')
|
|
EgtRemoveInfo( nBaseOutline, WIN_COPY)
|
|
-- elimino la curva
|
|
EgtErase( nCrvId)
|
|
|
|
elseif nMode == 2 then
|
|
-- se la curva è fuori dalla regione non va eliminata ma viene settata info che indica di ignorarla. Se è on o in allora il suo contributo è lo stesso di un'altra
|
|
-- curva di bordo quindi può essere eliminata
|
|
local nTestCrv = EgtCopyGlob( nCrvId, EgtGetParent( nSurfId))
|
|
local nTmp, nCnt = EgtTrimCurveWithRegion( nTestCrv, nSurfId, true, true)
|
|
if nCnt > 0 then
|
|
-- elimino il profilo corrispondente solo se non è curva in o out ( per non eliminare il profilo principale)
|
|
local nSemiProfileId = EgtGetInfo( nCrvId, WIN_SEMI_PROFILE, 'i')
|
|
local nProfileId = EgtGetParent( nSemiProfileId)
|
|
if EgtGetName( nProfileId) ~= WIN_PRF_MAIN then
|
|
EgtErase( nProfileId)
|
|
end
|
|
-- elimino la curva
|
|
EgtErase( nCrvId)
|
|
else
|
|
EgtSetInfo( nCrvId, WIN_GEO_EXTRA, true)
|
|
EgtSetStatus( nCrvId, GDB_ST.OFF)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che data una lista di curve ordinate e orientate le estende o le taglia per creare una curva chiusa
|
|
local function TrimOrderedCurves( vCrvs, nExtraCurvesMode)
|
|
|
|
-- costruisco la regione definita dalle curve
|
|
local nGrpTmp = EgtGroup( GDB_ID.ROOT)
|
|
EgtSetStatus( nGrpTmp, GDB_ST.OFF)
|
|
local nSurfId = CalcIntersectionRegion( vCrvs, nGrpTmp)
|
|
|
|
-- copia estesa delle curve
|
|
local dExtraLen = 10000
|
|
local vCopies = {}
|
|
for i = 1, #vCrvs do
|
|
vCopies[i] = EgtCopyGlob( vCrvs[i], nGrpTmp)
|
|
if EgtGetType( vCrvs[i]) == GDB_TY.CRV_LINE then
|
|
-- se linea allungo le estremità
|
|
EgtExtendCurveStartByLen( vCopies[i], dExtraLen)
|
|
EgtExtendCurveEndByLen( vCopies[i], dExtraLen)
|
|
else
|
|
-- se arco lo trasformo in una circonferenza
|
|
local dAngOld = EgtArcAngCenter( vCrvs[i])
|
|
EgtModifyArcAngCenter( vCopies[i], EgtIf( dAngOld > 0, 360, -360))
|
|
end
|
|
end
|
|
|
|
-- recupero le curve di bordo della regione
|
|
local nBorderId = EgtExtractSurfFrChunkLoops( nSurfId, 0, nGrpTmp)
|
|
local nCrvBorder, nCnt = EgtExplodeCurveCompo( nBorderId)
|
|
|
|
-- individuo una curva di vCrvs e un tratto di nCrvBorder in corrispondenza biunivoca per gestire correttamente il ciclo
|
|
-- ( possono esserci curve di vCrvs senza corrispondente o con più corrispondenti tra le curve di bordo)
|
|
local nFirstIdxCrv = 1
|
|
local nFirstIdxBorder = 1
|
|
for i = 1, #vCrvs do
|
|
local vCrvBorderRef = {}
|
|
for nId = nCrvBorder, nCrvBorder + nCnt - 1 do
|
|
local dDist = EgtPointCurveDist( EgtMP( nId), vCopies[i])
|
|
if dDist < GEO.EPS_SMALL then
|
|
table.insert( vCrvBorderRef, nId)
|
|
end
|
|
end
|
|
if #vCrvBorderRef == 1 then
|
|
-- preparo indici in modo che siano 0-based
|
|
nFirstIdxCrv = i - 1
|
|
nFirstIdxBorder = vCrvBorderRef[1] - nCrvBorder
|
|
break
|
|
end
|
|
end
|
|
|
|
local vResultCurves = {}
|
|
local nC = nFirstIdxCrv
|
|
local nB = nFirstIdxBorder
|
|
repeat
|
|
-- se ho terminato le curve di bordo da associare devo cancellare tutte le curve rimaste
|
|
if nB == nFirstIdxBorder and nC ~= nFirstIdxCrv then
|
|
AdjustExtraCurvesForTrim( vCrvs[nC+1], nSurfId, nExtraCurvesMode)
|
|
|
|
else
|
|
local dDist = EgtPointCurveDist( EgtMP( nCrvBorder + nB), vCopies[nC+1])
|
|
-- se trovo corrispondenza
|
|
if dDist < GEO.EPS_SMALL then
|
|
-- assegno il nome
|
|
local sName = EgtGetName( vCrvs[nC+1])
|
|
if sName then
|
|
EgtSetName( nCrvBorder + nB, sName)
|
|
end
|
|
-- copio le info
|
|
local vInfo = EgtGetAllInfo( vCrvs[nC+1])
|
|
for j = 1, #vInfo do
|
|
local sInfo = EgtSplitString( vInfo[j], '=')
|
|
EgtSetInfo( nCrvBorder + nB, sInfo[1], sInfo[2])
|
|
end
|
|
-- riposiziono
|
|
EgtRelocateGlob( nCrvBorder + nB, vCrvs[nC+1], GDB_IN.AFTER)
|
|
-- modifico l'id sostutuendolo alla curva originale
|
|
EgtErase( vCrvs[nC+1])
|
|
EgtChangeId( nCrvBorder + nB, vCrvs[nC+1])
|
|
|
|
table.insert( vResultCurves, vCrvs[nC+1])
|
|
-- passo alla curva di bordo successiva
|
|
nB = ( nB + 1) % nCnt
|
|
else
|
|
-- la curva non appartiene al bordo, quindi va gestita opportunamente
|
|
AdjustExtraCurvesForTrim( vCrvs[nC+1], nSurfId, nExtraCurvesMode)
|
|
end
|
|
end
|
|
|
|
-- passo alla curva successiva
|
|
nC = ( nC + 1) % #vCrvs
|
|
until nC == nFirstIdxCrv
|
|
|
|
EgtErase( nGrpTmp)
|
|
return vResultCurves
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che data una curva di outline restituisce l'id del suo profilo
|
|
local function GetOutlineProfileId( nOutlineId, bForceBottomRail, nProfileType)
|
|
|
|
-- ciclo fino a trovare il primo parent che abbia un AreaType definito ( frame o sash)
|
|
local nParentId = EgtGetParent( nOutlineId)
|
|
local nAreaType = WIN_AREATYPES.NULL
|
|
while nParentId and ( nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL) do
|
|
nParentId = EgtGetParent( nParentId)
|
|
nAreaType = EgtGetInfo( nParentId or GDB_ID.NULL, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL
|
|
end
|
|
|
|
-- recupero il gruppo contenente il profilo
|
|
local nProfilesGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nLayerId
|
|
if nAreaType == WIN_AREATYPES.FRAME then
|
|
nLayerId = EgtGetFirstNameInGroup( nProfilesGrpId, WIN_FRAME)
|
|
elseif nAreaType == WIN_AREATYPES.SASH then
|
|
nLayerId = EgtGetFirstNameInGroup( nProfilesGrpId, WIN_SASH)
|
|
end
|
|
|
|
-- recupero il nome del profilo
|
|
local sProfileName = EgtGetInfo( nOutlineId, WIN_PROFILETYPE)
|
|
|
|
-- controlli per bottomrail
|
|
if EgtGetName( nOutlineId) == WIN_BOTTOM and bForceBottomRail then
|
|
local nBottomRailTot = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or 0
|
|
if nBottomRailTot > 0 then
|
|
sProfileName = WIN_FILL_RAIL
|
|
end
|
|
elseif nProfileType == WIN_PRF.BOTTOMRAIL then
|
|
sProfileName = WIN_RAIL
|
|
elseif nProfileType == WIN_PRF.BOTTOMRAIL_FINAL then
|
|
sProfileName = WIN_FILL_RAIL
|
|
end
|
|
|
|
-- recupero il profilo
|
|
return EgtGetFirstNameInGroup( nLayerId, sProfileName)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che recupera il pezzo associato ad un outline
|
|
local function FindAssociatedPart( nOutlineId, bUseBottomRail)
|
|
|
|
local nCrvId = nOutlineId
|
|
local nPartId = EgtGetInfo( nCrvId, WIN_REF_PART, 'i')
|
|
if not nPartId then
|
|
-- cerco la prima curva da cui deriva che ha un pezzo associato
|
|
-- recupero il base outline da cui deriva
|
|
local nBaseOutline = EgtGetInfo( nOutlineId, WIN_COPY, 'i')
|
|
nBaseOutline = EgtGetInfo( nBaseOutline, WIN_SOU, 'i')
|
|
while nBaseOutline and not nPartId do
|
|
-- verifico se ha un profilo associato ( e quindi un pezzo)
|
|
local sProfileType = EgtGetInfo( nBaseOutline, WIN_PROFILETYPE)
|
|
if sProfileType then
|
|
-- recupero l'outline associato
|
|
nCrvId = EgtGetInfo( nBaseOutline, WIN_COPY, 'i')
|
|
nPartId = EgtGetInfo( nCrvId, WIN_REF_PART, 'i')
|
|
end
|
|
nBaseOutline = EgtGetInfo( nBaseOutline, WIN_SOU, 'i')
|
|
end
|
|
end
|
|
|
|
-- se serve bottomrail verifico se presente
|
|
if bUseBottomRail then
|
|
local vBottomRailParts = EgtGetInfo( nCrvId, WIN_REF_BOTTOMRAIL_PART, 'vi')
|
|
if vBottomRailParts then
|
|
nPartId = vBottomRailParts[#vBottomRailParts]
|
|
end
|
|
end
|
|
|
|
return nPartId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola il box di un profilo ( guardando la sua curva Ref) rispetto al suo frame
|
|
local function GetProfileLocalBox( nProfileId)
|
|
-- recupero il frame del profilo
|
|
local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frFrame = EgtFR( nFrameId, GDB_ID.ROOT)
|
|
-- recupero il Ref del profilo e ne calcolo il box
|
|
local nRefId = EgtGetFirstNameInGroup( nProfileId, WIN_REF)
|
|
local b3Box = EgtGetBBoxRef( nRefId, GDB_BB.STANDARD, frFrame, GDB_RT.GLOB)
|
|
return b3Box
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
----------------------------- CALCOLO DEI PROFILI ------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che restituisce il primo tipo di area definito tra le sottoaree che si generano da nAreaId
|
|
local function GetAreaChildrenType( nAreaId)
|
|
|
|
local vStack = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*') or {}
|
|
local i = 1
|
|
while vStack[i] do
|
|
local nType = EgtGetInfo( vStack[i], WIN_AREATYPE, 'i')
|
|
-- appena trovo un tipo definito esco
|
|
if nType == WIN_AREATYPES.FILL then
|
|
return WIN_CHILDREN_TYPES.FILL
|
|
elseif nType == WIN_AREATYPES.SASH then
|
|
return WIN_CHILDREN_TYPES.SASH
|
|
else
|
|
-- altrimenti analizzo le sottoaree
|
|
local vSubAreas = EgtGetNameInGroup( vStack[i], WIN_AREA .. '*') or {}
|
|
vStack = EgtJoinTables( vStack, vSubAreas)
|
|
end
|
|
i = i + 1
|
|
end
|
|
-- se non trovo un tipo definito
|
|
return WIN_CHILDREN_TYPES.NULL
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetClosestAreaChildrenType( nAreaId)
|
|
|
|
local nChildrenType = WIN_CHILDREN_TYPES.NULL
|
|
local nType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
while nChildrenType == WIN_CHILDREN_TYPES.NULL and nType ~= WIN_AREATYPES.FRAME do
|
|
nAreaId = EgtGetParent( nAreaId)
|
|
nType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
nChildrenType = GetAreaChildrenType( nAreaId)
|
|
end
|
|
|
|
return nChildrenType
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che verifica la tipologia delle curve figlie di una curva
|
|
local function GetChildrenType( nCrvId)
|
|
|
|
local vStack = EgtGetInfo( nCrvId, WIN_CHILD, 'vi') or {}
|
|
local i = 1
|
|
local vFillChildren = {}
|
|
local vSashChildren = {}
|
|
while vStack[i] do
|
|
-- verifico se la sua area è di tipo sash o fill
|
|
local nAreaId = EgtGetParent( EgtGetParent( vStack[i]))
|
|
local nType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
if nType == WIN_AREATYPES.FILL then
|
|
table.insert( vFillChildren, vStack[i])
|
|
elseif nType == WIN_AREATYPES.SASH then
|
|
table.insert( vSashChildren, vStack[i])
|
|
else
|
|
-- recupero i suoi figli
|
|
local vChildren = EgtGetInfo( vStack[i], WIN_CHILD, 'vi') or {}
|
|
if #vChildren == 0 then
|
|
-- se non ha figli, per non creare problemi nel caso di cambio profilo ( in cui è necessario conoscere la struttura completa),
|
|
-- assegno come tipologia quella dell'area più "vicina" nella struttura delle aree
|
|
local nCurrType = GetClosestAreaChildrenType( nAreaId)
|
|
if nCurrType == WIN_CHILDREN_TYPES.FILL then
|
|
table.insert( vFillChildren, vStack[i])
|
|
elseif nCurrType == WIN_CHILDREN_TYPES.SASH then
|
|
table.insert( vSashChildren, vStack[i])
|
|
end
|
|
end
|
|
-- aggiungo i suoi figli tra gli elementi da analizzare
|
|
vStack = EgtJoinTables( vStack, vChildren)
|
|
end
|
|
-- aggiorno il contatore
|
|
i = i + 1
|
|
end
|
|
|
|
-- salvo i figli individuati come info della curva
|
|
EgtSetInfo( nCrvId, WIN_SASH_CHILDREN, vSashChildren)
|
|
EgtSetInfo( nCrvId, WIN_FILL_CHILDREN, vFillChildren)
|
|
|
|
if #vFillChildren > 0 and #vSashChildren > 0 then
|
|
return WIN_CHILDREN_TYPES.MIXED -- cambio profilo
|
|
elseif #vFillChildren > 0 then
|
|
return WIN_CHILDREN_TYPES.FILL
|
|
elseif #vSashChildren > 0 then
|
|
return WIN_CHILDREN_TYPES.SASH
|
|
else
|
|
return WIN_CHILDREN_TYPES.NULL
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che identifica il tipo di split ( mullion, mixed, ...)
|
|
local function GetSplitType( nSplitId, nSplitLayerId)
|
|
|
|
local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i')
|
|
-- la tipologia è salvata nel layer solo se si tratta di un french split, negli altri casi va calcolata
|
|
if not nSplitType then
|
|
-- controllo se è dentro anta o telaio
|
|
local nParentAreaId = EgtGetParent( nSplitLayerId)
|
|
local nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL
|
|
while nParentAreaId and nParentAreaType ~= WIN_AREATYPES.SASH and nParentAreaType ~= WIN_AREATYPES.FRAME do
|
|
nParentAreaId = EgtGetParent( nParentAreaId)
|
|
nParentAreaType = EgtGetInfo( nParentAreaId or GDB_ID.NULL, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL
|
|
end
|
|
|
|
if nParentAreaType == WIN_AREATYPES.SASH then
|
|
-- se dentro anta
|
|
nSplitType = WIN_SPLITTYPES.INSASH
|
|
else
|
|
-- se dentro telaio verifico la tipologia dei figli
|
|
local nChildrenType = GetChildrenType( nSplitId)
|
|
if nChildrenType == WIN_CHILDREN_TYPES.MIXED then
|
|
nSplitType = WIN_SPLITTYPES.MIXED
|
|
elseif nChildrenType == WIN_CHILDREN_TYPES.FILL then
|
|
nSplitType = WIN_SPLITTYPES.INFRAME
|
|
else -- sash o non definiti
|
|
nSplitType = WIN_SPLITTYPES.MULLION
|
|
end
|
|
end
|
|
|
|
if not nSplitType then
|
|
nSplitType = WIN_SPLITTYPES.NULL
|
|
end
|
|
end
|
|
-- salvo la tipologia come info sulla curva
|
|
EgtSetInfo( nSplitId, WIN_SPLITTYPE, nSplitType)
|
|
return nSplitType
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function FindAdjacentSashType( nSplitId, nCurrId)
|
|
-- recupero l'altro child dello split
|
|
local vSplitChildren = EgtGetInfo( nSplitId, WIN_CHILD, 'vi')
|
|
local nAdjChild = EgtIf( vSplitChildren[1] == nCurrId, vSplitChildren[2], vSplitChildren[1])
|
|
-- recupero la sua tipologia dalla sua area
|
|
local nAdjSash = EgtGetParent( EgtGetParent( nAdjChild))
|
|
local nAdjType = EgtGetInfo( nAdjSash, WIN_SASHTYPE, 'i')
|
|
return nAdjType
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che imposta i tipi di profilo in base al tipo di pezzi
|
|
local function CalcProfileType( nAreaId)
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
|
|
-- FRAME
|
|
if nAreaType == WIN_AREATYPES.FRAME then
|
|
-- gestione soglia
|
|
local sThreshold = EgtGetInfo( nAreaId, WIN_THRESHOLD_PROFILE) or WIN_BOTTOM
|
|
local bThreshold = ( sThreshold == WIN_THRESHOLD)
|
|
|
|
-- assegno il profilo alle curve di outline
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
local sName = EgtGetName( nOutlineId)
|
|
-- recupero il tipo dei figli
|
|
local nChildrenType = GetChildrenType( nOutlineId)
|
|
|
|
-- a) se non definiti gestisco come anta o fixed
|
|
if nChildrenType == WIN_CHILDREN_TYPES.NULL then
|
|
local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0
|
|
if nBottomRail > 0 then
|
|
-- se bottomrail gestisco come fixed
|
|
bThreshold = false
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL .. '_' .. sThreshold)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_TOP)
|
|
end
|
|
else
|
|
-- se no bottomrail gestisco come anta
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH .. '_' .. sThreshold)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_TOP)
|
|
end
|
|
end
|
|
|
|
-- b) se anta
|
|
elseif nChildrenType == WIN_CHILDREN_TYPES.SASH then
|
|
EgtRemoveInfo( nAreaId, WIN_BOTTOMRAIL)
|
|
-- verifico tipologia di anta contro cui poggia
|
|
local vChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi')
|
|
local nSashArea = EgtGetParent( EgtGetParent( vChildren[1]))
|
|
local nSashType = EgtGetInfo( nSashArea, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL
|
|
-- b1) alzante scorrevole
|
|
if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE or nSashType == WIN_SASHTYPES.SLIDE_FIXED or nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then
|
|
EgtSetInfo( nAreaId, WIN_SLIDE_WINDOW, true)
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE .. '_' .. sThreshold)
|
|
-- se le ante contro cui poggia sono tutte mobili devo aggiornare il profilo
|
|
if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK .. '_' .. sThreshold)
|
|
elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then
|
|
for i = 2, #vChildren do
|
|
local nSashArea = EgtGetParent( EgtGetParent( vChildren[i]))
|
|
local nSashType = EgtGetInfo( nSashArea, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL
|
|
if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK .. '_' .. sThreshold)
|
|
break
|
|
elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then
|
|
break
|
|
end
|
|
end
|
|
end
|
|
elseif sName == WIN_TOP then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_TOP)
|
|
else
|
|
if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED)
|
|
end
|
|
end
|
|
-- b2) standard
|
|
else
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH .. '_' .. sThreshold)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_TOP)
|
|
end
|
|
end
|
|
|
|
-- c) se riempimento
|
|
elseif nChildrenType == WIN_CHILDREN_TYPES.FILL then
|
|
bThreshold = false
|
|
if sName == WIN_BOTTOM then
|
|
-- verifico presenza bottomrail
|
|
local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0
|
|
if nBottomRail == 0 then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED .. '_' .. sThreshold)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL .. '_' .. sThreshold)
|
|
end
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_TOP)
|
|
end
|
|
|
|
-- d) se cambio profilo
|
|
elseif nChildrenType == WIN_CHILDREN_TYPES.MIXED then
|
|
EgtRemoveInfo( nAreaId, WIN_BOTTOMRAIL)
|
|
bThreshold = false
|
|
EgtSetInfo( nOutlineId, WIN_PRF_CHANGE, true)
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_MIXED_BOTTOM)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_MIXED_TOP)
|
|
end
|
|
end
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
-- assegno info soglia
|
|
if bThreshold then
|
|
EgtSetInfo( nAreaId, WIN_THRESHOLD, true)
|
|
end
|
|
|
|
|
|
-- SPLIT
|
|
elseif nAreaType == WIN_AREATYPES.SPLIT then
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT)
|
|
local vSplitIds = EgtGetAllInGroup( nSplitLayerId)
|
|
for i = 1, #vSplitIds do
|
|
-- ricavo il tipo di split
|
|
local nSplitType = GetSplitType( vSplitIds[i], nSplitLayerId)
|
|
|
|
if nSplitType == WIN_SPLITTYPES.MULLION then
|
|
-- verifico direzione per assengare il profilo
|
|
local vtMedia = ( ( EgtEV( vSplitIds[i]) - EgtSV( vSplitIds[i])) / 2)
|
|
if not vtMedia:normalize() then
|
|
vtMedia = EgtSV( vSplitIds[i])
|
|
end
|
|
if abs( vtMedia:getX()) > abs( vtMedia:getY()) then
|
|
EgtSetInfo( vSplitIds[i], WIN_PROFILETYPE, WIN_SASH_HORIZONTAL)
|
|
else
|
|
EgtSetInfo( vSplitIds[i], WIN_PROFILETYPE, WIN_SASH_VERTICAL)
|
|
end
|
|
|
|
elseif nSplitType == WIN_SPLITTYPES.INSASH then
|
|
EgtSetInfo( vSplitIds[i], WIN_PROFILETYPE, WIN_SASH_SPLIT)
|
|
|
|
elseif nSplitType == WIN_SPLITTYPES.INFRAME then
|
|
EgtSetInfo( vSplitIds[i], WIN_PROFILETYPE, WIN_FRAME_SPLIT)
|
|
|
|
elseif nSplitType == WIN_SPLITTYPES.MIXED then
|
|
EgtSetInfo( vSplitIds[i], WIN_PROFILETYPE, WIN_MIXED_SPLIT)
|
|
EgtSetInfo( vSplitIds[i], WIN_PRF_CHANGE, true)
|
|
|
|
-- verifico se l'orientamento dello split è coerente con il cambio profilo ( vetro fisso a destra e anta a sinistra) :
|
|
-- recupero il lato da cui si trova il figlio di tipo anta
|
|
local nSashChild = EgtGetInfo( vSplitIds[i], WIN_SASH_CHILDREN, 'i')
|
|
local nRefCrv = EgtGetNext( nSashChild) or EgtGetPrev( nSashChild)
|
|
local _, _, nSide = EgtPointCurveDistSide( EgtMP( nRefCrv), vSplitIds[i], Z_AX())
|
|
-- se si trova a destra, lo split va invertito
|
|
if nSide == 1 then
|
|
EgtInvertCurve( vSplitIds[i])
|
|
-- scambio le info di intersezione
|
|
local vStartInters = EgtGetInfo( vSplitIds[i], WIN_SPLIT_STARTINTERS, 'vi')
|
|
local vEndInters = EgtGetInfo( vSplitIds[i], WIN_SPLIT_ENDINTERS, 'vi')
|
|
EgtSetInfo( vSplitIds[i], WIN_SPLIT_STARTINTERS, vEndInters)
|
|
EgtSetInfo( vSplitIds[i], WIN_SPLIT_ENDINTERS, vStartInters)
|
|
end
|
|
end
|
|
-- se split di tipo french non ha profilo assegnato perchè non ha un pezzo associato
|
|
end
|
|
|
|
-- SASH
|
|
elseif nAreaType == WIN_AREATYPES.SASH then
|
|
-- verifico tipologia di anta ( battente, ricevente, alzante scorrevole)
|
|
local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL
|
|
-- verifico se bottomrail
|
|
local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0
|
|
-- imposto profili sash
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
local sName = EgtGetName( nOutlineId)
|
|
|
|
-- se non è definita tipologia
|
|
if nSashType == WIN_SASHTYPES.NULL then
|
|
if sName == WIN_BOTTOM then
|
|
if nBottomRail == 0 then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL_BOTTOM)
|
|
end
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP)
|
|
end
|
|
|
|
else
|
|
-- verifico se deriva da una curva di split ( e quindi deve avere profilo speciale e.g. battente/ricevente)
|
|
local nSouId = EgtGetInfo( nOutlineId, WIN_SOU, 'i')
|
|
if EgtGetName( nSouId) == WIN_SPLIT then
|
|
-- setto info sulla curva per ricordare che deriva da un french split
|
|
EgtSetInfo( nOutlineId, WIN_CRV_ON_FRENCH_SPLIT, true)
|
|
|
|
-- a) battente/ricevente
|
|
if nSashType == WIN_SASHTYPES.ACTIVE then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE)
|
|
elseif nSashType == WIN_SASHTYPES.INACTIVE then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_INACTIVE)
|
|
elseif nSashType == WIN_SASHTYPES.ACTIVE_OUT or nSashType == WIN_SASHTYPES.INACTIVE_OUT then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_OUT)
|
|
elseif nSashType == WIN_SASHTYPES.ACTIVE_IN or nSashType == WIN_SASHTYPES.INACTIVE_IN then
|
|
-- devo verificare il tipo dell'anta adiacente
|
|
local nAdjSashType = FindAdjacentSashType( nSouId, nOutlineId)
|
|
if nSashType == WIN_SASHTYPES.ACTIVE_IN then
|
|
if nAdjSashType == WIN_SASHTYPES.ACTIVE_OUT then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_IN)
|
|
else -- adiacente è inactive
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE)
|
|
end
|
|
elseif nSashType == WIN_SASHTYPES.INACTIVE_IN then
|
|
if nAdjSashType == WIN_SASHTYPES.INACTIVE_OUT then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_IN)
|
|
else -- adiacente è active
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_INACTIVE)
|
|
end
|
|
end
|
|
|
|
-- b) alzante scorrevole
|
|
elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then
|
|
local nAdjSashType = FindAdjacentSashType( nSouId, nOutlineId)
|
|
if nAdjSashType == WIN_SASHTYPES.SLIDE_MOVABLE then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_ACTIVE_IN)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_ACTIVE)
|
|
end
|
|
elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_INACTIVE)
|
|
elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_INACTIVE)
|
|
end
|
|
|
|
else
|
|
-- a) alzante scorrevole
|
|
if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_BOTTOM)
|
|
elseif sName == WIN_TOP then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_TOP)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_SIDE)
|
|
end
|
|
elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_BOTTOM)
|
|
elseif sName == WIN_TOP then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_TOP)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_SIDE)
|
|
end
|
|
elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_BOTTOM)
|
|
elseif sName == WIN_TOP then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_TOP)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_SIDE)
|
|
end
|
|
|
|
-- b) standard
|
|
else
|
|
if sName == WIN_BOTTOM then
|
|
-- verifico se bottomrail
|
|
if nBottomRail == 0 then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL_BOTTOM)
|
|
end
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che cicla ricorsivamente su aree e sottoaree per impostare i tipi di profilo
|
|
local function CalculateAreaProfileType( nAreaId)
|
|
-- calcolo i profili per l'area corrente
|
|
CalcProfileType( nAreaId)
|
|
-- calcolo i profili per le eventuali sottoaree
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
CalculateAreaProfileType( nChildAreaId)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
------------------------------ CALCOLO OUTLINE ---------------------------------
|
|
----------------------------------------------------------------------------------
|
|
local function TrimSplitWithOutline( nSplitId)
|
|
-- estendo agli estremi ( TO DO : gestire caso di split non lineare)
|
|
EgtExtendCurveStartByLen( nSplitId, 50)
|
|
EgtExtendCurveEndByLen( nSplitId, 50)
|
|
-- lo taglio con outline
|
|
local nStartIntersId = EgtGetInfo( nSplitId, WIN_SPLIT_STARTINTERS, 'i')
|
|
local nOutlineId = EgtGetInfo( nStartIntersId, WIN_COPY, 'i')
|
|
local ptStartInters = EgtIP( nSplitId, nOutlineId, EgtSP( nSplitId))
|
|
local dStartInters = EgtCurveParamAtPoint( nSplitId, ptStartInters)
|
|
EgtTrimCurveStartAtParam( nSplitId, dStartInters)
|
|
local nEndIntersId = EgtGetInfo( nSplitId, WIN_SPLIT_ENDINTERS, 'i')
|
|
nOutlineId = EgtGetInfo( nEndIntersId, WIN_COPY, 'i')
|
|
local ptEndInters = EgtIP( nSplitId, nOutlineId, EgtEP( nSplitId))
|
|
local dEndInters = EgtCurveParamAtPoint( nSplitId, ptEndInters)
|
|
EgtTrimCurveEndAtParam( nSplitId, dEndInters)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola l'outline per aree virtuali ausiliarie di split a griglia
|
|
local function CalculateVirtualAreaOutline( nAreaId, dZmove)
|
|
|
|
local nOutlineLayerId = EgtGroup( nAreaId)
|
|
EgtSetName( nOutlineLayerId, WIN_OUTLINE)
|
|
EgtSetStatus( nOutlineLayerId, GDB_ST.OFF)
|
|
|
|
local nBaseOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nBaseOutlineId = EgtGetFirstInGroup( nBaseOutlineLayerId)
|
|
while nBaseOutlineId do
|
|
local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i')
|
|
local nOutlineId
|
|
|
|
if EgtGetName( nSouId) == WIN_SPLIT then
|
|
-- se deriva da split lo copio e lo traslo
|
|
nOutlineId = EgtCopy( nSouId, nOutlineLayerId)
|
|
EgtMove( nOutlineId, Z_AX() * dZmove)
|
|
EgtSetName( nOutlineId, EgtGetName( nBaseOutlineId))
|
|
-- salvo riferimento dello split da cui deriva
|
|
EgtSetInfo( nOutlineId, WIN_REF_SPLIT, nSouId)
|
|
-- verifico orientamento
|
|
local nCrvRef = EgtGetPrev( nBaseOutlineId) or EgtGetNext( nBaseOutlineId)
|
|
local _, _, nSide = EgtPointCurveDistSide( EgtMP( nCrvRef), nOutlineId, Z_AX())
|
|
if nSide == 1 then
|
|
EgtInvertCurve( nOutlineId)
|
|
EgtSetInfo( nOutlineId, WIN_INV_SPLIT, true)
|
|
end
|
|
else
|
|
local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') or GDB_ID.NULL
|
|
nOutlineId = EgtCopy( nCopyId, nOutlineLayerId)
|
|
end
|
|
|
|
if nOutlineId then
|
|
-- sistemo le info
|
|
EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId)
|
|
EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId)
|
|
EgtRemoveInfo( nOutlineId, WIN_CHILD)
|
|
end
|
|
|
|
nBaseOutlineId = EgtGetNext( nBaseOutlineId)
|
|
end
|
|
-- taglio tutti i contorni
|
|
TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function CalculateSplitOutline( nAreaId)
|
|
|
|
-- copio il layer di base outline
|
|
local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT)
|
|
local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId)
|
|
EgtSetName( nSplitLayerId, WIN_SPLIT)
|
|
EgtSetStatus( nSplitLayerId, GDB_ST.OFF)
|
|
|
|
local vBaseSplitIds = EgtGetAllInGroup( nBaseSplitLayerId)
|
|
local vSplitIds = EgtGetAllInGroup( nSplitLayerId)
|
|
|
|
-- se split interni ad anta ricavo quota in z dal suo profilo
|
|
local dZMove = 0
|
|
local nSplitType = EgtGetInfo( vSplitIds[1], WIN_SPLITTYPE, 'i')
|
|
if nSplitType == WIN_SPLITTYPES.INSASH then
|
|
-- recupero area sash che lo contiene
|
|
local nSashAreaId = nAreaId
|
|
local nAreaType = EgtGetInfo( nSashAreaId, WIN_AREATYPE, 'i')
|
|
while nAreaType ~= WIN_AREATYPES.SASH do
|
|
nSashAreaId = EgtGetParent( nSashAreaId)
|
|
nAreaType = EgtGetInfo( nSashAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
-- recupero il profilo dell'anta da una curva dell'outline
|
|
local nSashBaseOutlineLayerId = EgtGetFirstNameInGroup( nSashAreaId, WIN_AREAOUTLINE)
|
|
local nSashBaseOutlineId = EgtGetFirstInGroup( nSashBaseOutlineLayerId)
|
|
local sSashProfile = EgtGetInfo( nSashBaseOutlineId, WIN_PROFILETYPE)
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
|
|
local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile)
|
|
-- calcolo offset sulla z dell'anta
|
|
dZMove = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd')
|
|
end
|
|
|
|
-- verifico se presenti aree ausiliarie per split a griglia
|
|
local vAuxAreas = EgtGetNameInGroup( nAreaId, WIN_VIRTUAL_AREA) or {}
|
|
for i = 1, #vAuxAreas do
|
|
CalculateVirtualAreaOutline( vAuxAreas[i], dZMove)
|
|
end
|
|
|
|
-- sistemo gli outline degli split
|
|
for i = 1, #vSplitIds do
|
|
-- sistemo le info
|
|
EgtSetInfo( vBaseSplitIds[i], WIN_COPY, vSplitIds[i])
|
|
EgtSetInfo( vSplitIds[i], WIN_COPY, vBaseSplitIds[i])
|
|
-- taglio con outline
|
|
TrimSplitWithOutline( vSplitIds[i])
|
|
-- aggiusto quota
|
|
EgtMove( vSplitIds[i], Z_AX() * dZMove)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function CalculateFillOutline( nAreaId, nAreaLayerId, nOutlineLayerId)
|
|
|
|
-- recupero area parent di tipo telaio/anta che la contiene
|
|
local vSplitAreas = {}
|
|
local nParentArea = EgtGetParent( nAreaId)
|
|
local nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i')
|
|
while nAreaType ~= WIN_AREATYPES.FRAME and nAreaType ~= WIN_AREATYPES.SASH do
|
|
if nAreaType == WIN_AREATYPES.SPLIT then
|
|
table.insert( vSplitAreas, nParentArea)
|
|
end
|
|
nParentArea = EgtGetParent( nParentArea)
|
|
nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i')
|
|
end
|
|
|
|
-- 1) calcolo l'area complessiva di fill definita dal suo parent
|
|
local nParentOutlineLayer = EgtGetFirstNameInGroup( nParentArea, WIN_OUTLINE)
|
|
local vAdjustZ = {}
|
|
local nRefZ
|
|
local nParentOutlineId = EgtGetFirstInGroup( nParentOutlineLayer)
|
|
while nParentOutlineId do
|
|
-- copio la curva di outline del parent
|
|
local nOutlineId = EgtCopy( nParentOutlineId, nOutlineLayerId)
|
|
EgtSetInfo( nOutlineId, WIN_REF_OUTLINE, nParentOutlineId)
|
|
|
|
-- recupero il suo profilo per calcolare l'offset perpendicolare
|
|
local nParentProfileId = GetOutlineProfileId( nParentOutlineId, true)
|
|
local b3FrameProfile = GetProfileLocalBox( nParentProfileId)
|
|
local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd') or 0
|
|
local dDimRef = b3FrameProfile:getMin():getX()
|
|
local dFillPerpOffset = abs( dDimRef) - dOverlap
|
|
if EgtGetName( nParentProfileId) == WIN_FILL_RAIL then
|
|
-- se bottom rail considero la distanza necessaria per il numero di bottomrail richiesti
|
|
local nBottomRails = EgtGetInfo( nParentOutlineId, WIN_BOTTOMRAIL, 'i')
|
|
local dRailDelta1 = EgtGetInfo( nParentProfileId, WIN_RAILDELTA .. '1', 'd')
|
|
local dRailDelta2 = EgtGetInfo( nParentProfileId, WIN_RAILDELTA .. '2', 'd')
|
|
dFillPerpOffset = dFillPerpOffset + dRailDelta1 + ( nBottomRails - 1) * dRailDelta2
|
|
end
|
|
EgtOffsetCurve( nOutlineId, - dFillPerpOffset)
|
|
|
|
-- movimento in z : se non è definito ( come nel caso di alcuni pezzi di telaio con cambio profilo) salvo la curva per correggere la sua z in seguito, se è definito salvo
|
|
-- una curva come riferimento per le curve da correggere
|
|
local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd')
|
|
if not dFillZOffset then
|
|
table.insert( vAdjustZ, nOutlineId)
|
|
else
|
|
nRefZ = nOutlineId
|
|
EgtMove( nOutlineId, Z_AX() * dFillZOffset)
|
|
end
|
|
|
|
nParentOutlineId = EgtGetNext( nParentOutlineId)
|
|
end
|
|
-- sistemo quote per tratti che non avevano movimento in z definito nel profilo
|
|
for i = 1, #vAdjustZ do
|
|
EgtMove( vAdjustZ[i], ( EgtSP( nRefZ):getZ() - EgtSP( vAdjustZ[i]):getZ()) * Z_AX())
|
|
end
|
|
-- accorcio gli offset
|
|
local vCrvs = TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1)
|
|
|
|
|
|
-- 2) taglio con split
|
|
if #vSplitAreas == 0 then
|
|
return
|
|
end
|
|
-- creo bordo complessivo dell'outline, salvando le info come temp prop della curva per non perderle
|
|
local vRefOutlines = {}
|
|
for i = 1, #vCrvs do
|
|
vRefOutlines[i] = EgtGetInfo( vCrvs[i], WIN_REF_OUTLINE, 'i')
|
|
end
|
|
local nCompo = EgtCurveCompo( nOutlineLayerId, vCrvs)
|
|
for i = 0, #vCrvs - 1 do
|
|
EgtCurveCompoSetTempProp( nCompo, i, vRefOutlines[i+1])
|
|
end
|
|
|
|
-- recupero gli split coinvolti nell'area fill
|
|
local tabSplits = {}
|
|
local vBaseOutlines = EgtGetAllInGroup( nAreaLayerId)
|
|
for i = 1, #vBaseOutlines do
|
|
-- verifico se deriva da split
|
|
local nSouId = EgtGetInfo( vBaseOutlines[i], WIN_SOU, 'i')
|
|
while nSouId and EgtGetName( nSouId) ~= WIN_SPLIT do
|
|
nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i')
|
|
end
|
|
if nSouId then
|
|
tabSplits[nSouId] = vBaseOutlines[i]
|
|
end
|
|
end
|
|
|
|
-- taglio con split
|
|
for i = #vSplitAreas, 1, -1 do
|
|
local nSplitBaseOutline = EgtGetFirstNameInGroup( vSplitAreas[i], WIN_BASESPLIT)
|
|
local vSplitBaseOutlines = EgtGetAllInGroup( nSplitBaseOutline)
|
|
for j = 1, #vSplitBaseOutlines do
|
|
-- verifico sia uno split coinvolto nell'area fill considerata
|
|
if tabSplits[vSplitBaseOutlines[j]] then
|
|
|
|
-- a) creo la curva di outline corrispondente allo split
|
|
local nSplitOutline = EgtGetInfo( vSplitBaseOutlines[j], WIN_COPY, 'i')
|
|
local nOutlineId = EgtCopy( nSplitOutline, nOutlineLayerId)
|
|
-- verifico orientamento
|
|
local nRefCrv = EgtGetPrev( tabSplits[vSplitBaseOutlines[j]]) or EgtGetNext( tabSplits[vSplitBaseOutlines[j]])
|
|
local _, _, nSide = EgtPointCurveDistSide( EgtMP( nRefCrv), vSplitBaseOutlines[j], Z_AX())
|
|
if nSide == 1 then
|
|
EgtInvertCurve( nOutlineId)
|
|
end
|
|
-- calcolo gli offset
|
|
local nParentProfileId = GetOutlineProfileId( nSplitOutline, true)
|
|
local b3FrameProfile = GetProfileLocalBox( nParentProfileId)
|
|
local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd')
|
|
local bMixedSplit = EgtGetInfo( nSplitOutline, WIN_PRF_CHANGE, 'b') or false
|
|
local dDimRef = EgtIf( bMixedSplit, b3FrameProfile:getMax():getX(), b3FrameProfile:getMin():getX())
|
|
local dFillPerpOffset = abs( dDimRef) - dOverlap
|
|
EgtOffsetCurve( nOutlineId, - dFillPerpOffset)
|
|
-- movimento in z
|
|
local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd')
|
|
EgtMove( nOutlineId, Z_AX() * dFillZOffset)
|
|
|
|
-- b) aggiorno la curva complessiva di outline con la curva appena calcolata
|
|
local ptS = EgtIP( nOutlineId, nCompo, EgtSP( nOutlineId))
|
|
local ptE = EgtIP( nOutlineId, nCompo, EgtEP( nOutlineId))
|
|
local dBorderParS = EgtCurveParamAtPoint( nCompo, ptS)
|
|
local dBorderParE = EgtCurveParamAtPoint( nCompo, ptE)
|
|
EgtTrimCurveStartEndAtParam( nCompo, dBorderParE, dBorderParS)
|
|
local dSplitParS = EgtCurveParamAtPoint( nOutlineId, ptS)
|
|
local dSplitParE = EgtCurveParamAtPoint( nOutlineId, ptE)
|
|
EgtTrimCurveStartEndAtParam( nOutlineId, dSplitParS, dSplitParE)
|
|
EgtAddCurveCompoCurve( nCompo, nOutlineId)
|
|
local _, dParEnd = EgtCurveDomain( nCompo)
|
|
EgtCurveCompoSetTempProp( nCompo, dParEnd - 1, EgtIf( nSide == 1, - nSplitOutline, nSplitOutline))
|
|
end
|
|
end
|
|
end
|
|
|
|
-- spezzo la curva di outline nelle sue sottocurve e riassegno le info
|
|
local vTempProps = EgtCurveCompoGetTempProp( nCompo)
|
|
local nCrv, nCnt = EgtExplodeCurveCompo( nCompo)
|
|
for i = 0, nCnt - 1 do
|
|
EgtSetInfo( nCrv + i, WIN_REF_OUTLINE, vTempProps[i+1])
|
|
if vTempProps[i+1] < 0 then
|
|
EgtSetInfo( nCrv + i, WIN_INV_SPLIT, true)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola l'outline dall'area outline ( base outline)
|
|
local function CalculateOutlineFromAreaOutline( nAreaId)
|
|
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
-- recupero il base outline e creo gruppo per outline
|
|
local nAreaOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineLayerId = EgtGroup( nAreaId)
|
|
EgtSetName( nOutlineLayerId, WIN_OUTLINE)
|
|
EgtSetStatus( nOutlineLayerId, GDB_ST.OFF)
|
|
CopyInfo( nOutlineLayerId, nAreaOutlineLayerId, WIN_JOINTS)
|
|
|
|
-- FRAME
|
|
if nAreaType == WIN_AREATYPES.FRAME then
|
|
-- sistemo le info
|
|
local nAreaOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId)
|
|
while nAreaOutlineId do
|
|
local nOutlineId = EgtCopyGlob( nAreaOutlineId, nOutlineLayerId)
|
|
EgtSetInfo( nAreaOutlineId, WIN_COPY, nOutlineId)
|
|
EgtSetInfo( nOutlineId, WIN_COPY, nAreaOutlineId)
|
|
-- se bottom riporto informazione dei bottomrail e soglia
|
|
if EgtGetName( nOutlineId) == WIN_BOTTOM then
|
|
CopyInfo( nOutlineId, nAreaId, WIN_BOTTOMRAIL)
|
|
CopyInfo( nOutlineId, nAreaId, WIN_THRESHOLD)
|
|
end
|
|
nAreaOutlineId = EgtGetNext( nAreaOutlineId)
|
|
end
|
|
|
|
|
|
-- SPLIT
|
|
elseif nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then
|
|
|
|
-- a) outline dell'area
|
|
local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId)
|
|
while nBaseOutlineId do
|
|
-- recupero la curva di outline corrispondente alla curva del base outline da cui deriva e la copio
|
|
local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i')
|
|
local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') or GDB_ID.NULL
|
|
local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId)
|
|
|
|
if nOutlineId then
|
|
-- se deriva da split devo aggiornare il nome, controllare l'orientamento e settare il riferimento
|
|
local sSouName = EgtGetName( nSouId)
|
|
if sSouName == WIN_SPLIT then
|
|
local sBaseName = EgtGetName( nBaseOutlineId)
|
|
EgtSetName( nOutlineId, sBaseName)
|
|
EgtSetInfo( nOutlineId, WIN_REF_SPLIT, nSouId)
|
|
-- verifico orientamento
|
|
local nCrvRef = EgtGetPrev( nBaseOutlineId) or EgtGetNext( nBaseOutlineId)
|
|
local _, _, nSide = EgtPointCurveDistSide( EgtMP( nCrvRef), nOutlineId, Z_AX())
|
|
if nSide == 1 then
|
|
EgtInvertCurve( nOutlineId)
|
|
EgtSetInfo( nOutlineId, WIN_INV_SPLIT, true)
|
|
end
|
|
end
|
|
|
|
-- sistemo le info
|
|
EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId)
|
|
EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId)
|
|
EgtRemoveInfo( nOutlineId, WIN_CHILD)
|
|
end
|
|
|
|
nBaseOutlineId = EgtGetNext( nBaseOutlineId)
|
|
end
|
|
-- taglio tutti i contorni
|
|
TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1)
|
|
|
|
-- b) split
|
|
if nAreaType == WIN_AREATYPES.SPLIT then
|
|
CalculateSplitOutline( nAreaId)
|
|
end
|
|
|
|
|
|
-- SASH
|
|
elseif nAreaType == WIN_AREATYPES.SASH then
|
|
-- recupero se anta battente ricevente
|
|
local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL
|
|
|
|
-- recupero gruppo profili anta e telaio
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
|
|
local nFrameProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_FRAME)
|
|
|
|
-- ciclo su profilo disegnato anta
|
|
local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId)
|
|
while nBaseOutlineId do
|
|
-- recupero la curva di outline del base outline da cui deriva e la copio
|
|
local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i')
|
|
local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') or GDB_ID.NULL
|
|
local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId)
|
|
|
|
if nOutlineId then
|
|
-- recupero profilo
|
|
local sSashProfile = EgtGetInfo( nBaseOutlineId, WIN_PROFILETYPE)
|
|
local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile)
|
|
|
|
-- calcolo offset sulla z dell'anta
|
|
local dSashZOffset = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd')
|
|
|
|
-- sposto anta in Z
|
|
EgtMove( nOutlineId, Z_AX() * dSashZOffset)
|
|
|
|
-- sistemo le info
|
|
EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId)
|
|
EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId)
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, sSashProfile)
|
|
if EgtGetName( nOutlineId) == WIN_BOTTOM then
|
|
CopyInfo( nOutlineId, nAreaId, WIN_BOTTOMRAIL)
|
|
end
|
|
EgtRemoveInfo( nOutlineId, WIN_PRF_CHANGE)
|
|
EgtRemoveInfo( nOutlineId, WIN_REF_SPLIT)
|
|
EgtRemoveInfo( nOutlineId, WIN_INV_SPLIT)
|
|
EgtRemoveInfo( nOutlineId, WIN_THRESHOLD)
|
|
|
|
-- verifico se outline e' segmento battente o ricevente ( che quindi deriva da split di tipo french)
|
|
local bOnFrenchSplit = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b') or false
|
|
if not bOnFrenchSplit then
|
|
-- se outline non è segmento battente o ricevente necessita di offset
|
|
-- recupero a ritroso il profilo dell'elemento del frame su cui poggia
|
|
local nFrameBaseOutlineId = nSouId
|
|
local sFrameProfile = EgtGetInfo( nFrameBaseOutlineId, WIN_PROFILETYPE)
|
|
while not sFrameProfile and nFrameBaseOutlineId do
|
|
nFrameBaseOutlineId = EgtGetInfo( nFrameBaseOutlineId, WIN_SOU , 'i')
|
|
sFrameProfile = EgtGetInfo( nFrameBaseOutlineId or GDB_ID.NULL, WIN_PROFILETYPE)
|
|
end
|
|
local nFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileLayerId, sFrameProfile)
|
|
|
|
-- calcolo il box del riferimento del profilo del frame
|
|
local b3FrameProfile = GetProfileLocalBox( nFrameProfileId)
|
|
-- calcolo offset perpendicolare
|
|
local sOverlapInfo = EgtIf( EgtGetName( nOutlineId) == WIN_BOTTOM, WIN_SASH_BOTTOM_OVERLAP, WIN_SASH_TOP_OVERLAP)
|
|
local dOverlap = EgtGetInfo( nFrameProfileId, sOverlapInfo, 'd')
|
|
local dSashPerpOffset = abs( b3FrameProfile:getMin():getX()) - dOverlap
|
|
|
|
-- faccio offset
|
|
EgtOffsetCurve( nOutlineId, - dSashPerpOffset)
|
|
|
|
else
|
|
-- se deriva da french split sistemo il nome
|
|
local sBaseName = EgtGetName( nBaseOutlineId)
|
|
EgtSetName( nOutlineId, sBaseName)
|
|
-- controllo l'orientamento
|
|
local nCrvRef = EgtGetPrev( nBaseOutlineId) or EgtGetNext( nBaseOutlineId)
|
|
local _, _, nSide = EgtPointCurveDistSide( EgtMP( nCrvRef), nOutlineId, Z_AX())
|
|
if nSide == 1 then
|
|
EgtInvertCurve( nOutlineId)
|
|
end
|
|
end
|
|
end
|
|
|
|
nBaseOutlineId = EgtGetNext( nBaseOutlineId)
|
|
end
|
|
-- accorcio gli offset
|
|
TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1)
|
|
|
|
|
|
-- FILL
|
|
elseif nAreaType == WIN_AREATYPES.FILL then
|
|
CalculateFillOutline( nAreaId, nAreaOutlineLayerId, nOutlineLayerId)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che cicla ricorsivamente su aree e sottaree per calcolare gli outlines
|
|
local function CalculateAreaOutline( nAreaId)
|
|
-- calcolo outlines per l'area corrente
|
|
CalculateOutlineFromAreaOutline( nAreaId)
|
|
-- calcolo outlines per le eventuali sottoaree
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
CalculateAreaOutline( nChildAreaId)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
------------------------ FUNZIONI AUX PER CALCOLO PEZZI ------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che restituisce il WIN_PRF in base al nome della curva
|
|
local function GetOutlineProfileType( nOutlineId, bForceBottomRail, nBottomRail)
|
|
-- ricavo tipo dal nome
|
|
local sName = EgtGetName( nOutlineId)
|
|
local nProfileType = WIN_PRF.NULL
|
|
if sName == WIN_TOP then
|
|
nProfileType = WIN_PRF.TOP
|
|
elseif sName == WIN_BOTTOM then
|
|
local nBottomRailTot = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or 0
|
|
if bForceBottomRail and nBottomRailTot > 0 then
|
|
nProfileType = WIN_PRF.BOTTOMRAIL_FINAL
|
|
elseif nBottomRail then
|
|
-- verifico se bottomrail intermedio o finale
|
|
if nBottomRail == nBottomRailTot then
|
|
nProfileType = WIN_PRF.BOTTOMRAIL_FINAL
|
|
else
|
|
nProfileType = WIN_PRF.BOTTOMRAIL
|
|
end
|
|
else
|
|
nProfileType = WIN_PRF.BOTTOM
|
|
end
|
|
elseif sName == WIN_LEFT then
|
|
nProfileType = WIN_PRF.LEFT
|
|
elseif sName == WIN_RIGHT then
|
|
nProfileType = WIN_PRF.RIGHT
|
|
elseif sName == WIN_SPLIT then
|
|
nProfileType = WIN_PRF.SPLIT
|
|
end
|
|
return nProfileType
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che restituisce il tipo di controprofilo dell'outline adiacente
|
|
local function GetProfileCtrIn( nPrevOutlineId, nOutlineId, nPrevProfileId)
|
|
local sPrevCtrIn = WIN_CTRIN
|
|
-- gestione particolare del caso di split o cambio profilo
|
|
if not EgtGetFirstNameInGroup( nPrevProfileId, sPrevCtrIn) then
|
|
|
|
local nRefSplitId = EgtGetInfo( nPrevOutlineId, WIN_REF_SPLIT, 'i')
|
|
if nRefSplitId or EgtGetName( nPrevOutlineId) == WIN_SPLIT then
|
|
-- 1) split
|
|
-- verifico da quale lato dello split originale si trova l'outline per decidere quale controprofilo considerare
|
|
local _, _, nSide = EgtPointCurveDistSide( EgtMP( nOutlineId), nRefSplitId or nPrevOutlineId, Z_AX())
|
|
if nSide == 1 then
|
|
sPrevCtrIn = WIN_CTRIN .. '1' -- dx
|
|
else
|
|
sPrevCtrIn = WIN_CTRIN .. '2' -- sx
|
|
end
|
|
else
|
|
-- 2) pezzo del telaio con cambio profilo
|
|
-- il profilo da usare dipende dal pezzo corrente: se ha figli di tipo fill allora è legato alla parte fill del cambio profilo, se ha figli di tipo sash è legato alla parte sash,
|
|
-- se ha entrambe le tipologie di figli allora è mixed split e va considerata la parte sash ( perchè è quella utilizzata per tagliare il pezzo)
|
|
local vSashChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi')
|
|
if vSashChildren then
|
|
sPrevCtrIn = WIN_SASH .. WIN_CTRIN
|
|
else
|
|
sPrevCtrIn = WIN_FILL .. WIN_CTRIN
|
|
end
|
|
end
|
|
end
|
|
|
|
return sPrevCtrIn
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che costruisce una superficie estrudendo il nSectionId lungo l'outline
|
|
local function CreateProfileSurfById( nOutlineId, nProfileId, nSectionId, dExtraLen, nLayerId)
|
|
|
|
-- creo guida con estensione in tangenza
|
|
local nGuideId = EgtCopy( nOutlineId, nLayerId)
|
|
if EgtGetType( nGuideId) == GDB_TY.CRV_LINE then
|
|
EgtExtendCurveStartByLen( nGuideId, dExtraLen)
|
|
EgtExtendCurveEndByLen( nGuideId, dExtraLen)
|
|
else
|
|
nGuideId = EgtCurveCompo( nLayerId, nGuideId)
|
|
EgtAddCurveCompoLineTg( nGuideId, dExtraLen)
|
|
EgtAddCurveCompoLineTg( nGuideId, dExtraLen, false)
|
|
end
|
|
-- correzione nel caso di bottomrail
|
|
local sProfileType = EgtGetInfo( nProfileId, WIN_PRF_TYPE)
|
|
if sProfileType == WIN_RAIL or sProfileType == WIN_FILL_RAIL then
|
|
local dOffs = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd')
|
|
EgtOffsetCurve( nGuideId, - dOffs)
|
|
end
|
|
|
|
-- verifico se necessaria inversione della guida nel caso sia curva "virtuale" ( ovvero in area null o split) che deriva da pezzo di split
|
|
if EgtExistsInfo( nOutlineId, WIN_INV_SPLIT) then
|
|
EgtInvertCurve( nGuideId)
|
|
end
|
|
|
|
-- recupero il profilo da estrudere
|
|
local nSectionRefId = EgtCopyGlob( nSectionId, nLayerId)
|
|
|
|
-- posiziono la sezione di estrusione sulla guida :
|
|
-- recupero frame del profilo
|
|
local nProfileFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frProfile = EgtFR( nProfileFrameId, GDB_ID.ROOT)
|
|
frProfile:invert()
|
|
-- calcolo il frame di destinazione sulla guida
|
|
local frDest = Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId), GDB_RT.GLOB)
|
|
-- posiziono con i riferimenti
|
|
EgtTransform( nSectionRefId, frProfile, GDB_RT.GLOB)
|
|
EgtTransform( nSectionRefId, frDest, GDB_RT.GLOB)
|
|
|
|
-- creo la superfice di estrusione
|
|
local nStmId = EgtSurfTmSwept( nLayerId, nSectionRefId, nGuideId, false, WIN_SURF_APPROX)
|
|
EgtErase( nGuideId)
|
|
EgtErase( nSectionRefId)
|
|
|
|
return nStmId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- come CreateProfileSurfById ma riceve il nome della sezione da estrudere
|
|
local function CreateProfileSurf( nOutlineId, nProfileId, sSectionName, dExtraLen, nLayerId)
|
|
-- recupero l'id della sezione da estrudere
|
|
local nSectionId = EgtGetFirstNameInGroup( nProfileId, sSectionName)
|
|
if not nSectionId then return end
|
|
return CreateProfileSurfById( nOutlineId, nProfileId, nSectionId, dExtraLen, nLayerId)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che verifica gli outlines prev/next per lo split controllando l'interferenza tra i profili
|
|
local function TestSplitTrimOutlines( nOutlineId, vTrimOutlines, nMainProfile, b3Profile, nGrpTmp, bPrevOrNext)
|
|
|
|
local vRealTrimOutlines = {}
|
|
|
|
-- 1) recupero le curve da testare
|
|
local vTestOutlines = {}
|
|
|
|
-- a) curve individuate dalle intersezioni degli outlines
|
|
for i = 1, #vTrimOutlines do
|
|
vTestOutlines[i] = vTrimOutlines[i]
|
|
end
|
|
|
|
-- b) curve vicine a quelle individuate dalle intersezioni che interferiscono con l'outline ( guardando interferenza grossolana dei pezzi)
|
|
-- recupero le curve di bordo del pezzo di split
|
|
local nOutlineCopyId = EgtCopyGlob( nOutlineId, nGrpTmp)
|
|
if bPrevOrNext then
|
|
EgtTrimCurveEndAtParam( nOutlineCopyId, 0.5)
|
|
else
|
|
EgtTrimCurveStartAtParam( nOutlineCopyId, 0.5)
|
|
end
|
|
local nOutId = EgtOffsetCurveAdv( nOutlineCopyId, b3Profile:getMax():getX())
|
|
local nInId = EgtOffsetCurveAdv( nOutlineCopyId, b3Profile:getMin():getX())
|
|
|
|
-- curve precedenti
|
|
local nTestCurve = EgtGetPrev( vTrimOutlines[1]) or EgtGetLastInGroup( EgtGetParent( vTrimOutlines[1]))
|
|
local bInters = true
|
|
while bInters and nTestCurve ~= vTrimOutlines[#vTrimOutlines] do
|
|
|
|
local nRefPart = FindAssociatedPart( nTestCurve, true)
|
|
local nRefGeo = EgtGetFirstNameInGroup( nRefPart, WIN_GEO)
|
|
local nRefSurf = EgtGetFirstNameInGroup( nRefGeo, WIN_GEO_SURF)
|
|
|
|
local nClassOut = EgtCurveWithRegionClassify( nOutId, nRefSurf)
|
|
if nClassOut == GDB_CRC.OUT then
|
|
local nClassIn = EgtCurveWithRegionClassify( nInId, nRefSurf)
|
|
-- se non c'è interferenza interrompo la ricerca
|
|
if nClassIn == GDB_CRC.OUT then
|
|
bInters = false
|
|
end
|
|
end
|
|
-- se interferenza lo aggiungo tra le curve da controllare
|
|
if bInters then
|
|
table.insert( vTestOutlines, 1, nTestCurve)
|
|
nTestCurve = EgtGetPrev( nTestCurve) or EgtGetLastInGroup( EgtGetParent( nTestCurve))
|
|
end
|
|
end
|
|
|
|
-- curve successive
|
|
nTestCurve = EgtGetNext( vTrimOutlines[#vTrimOutlines]) or EgtGetFirstInGroup( EgtGetParent( vTrimOutlines[1]))
|
|
bInters = true
|
|
while bInters and nTestCurve ~= vTrimOutlines[1] do
|
|
|
|
local nRefPart = FindAssociatedPart( nTestCurve, true)
|
|
local nRefGeo = EgtGetFirstNameInGroup( nRefPart, WIN_GEO)
|
|
local nRefSurf = EgtGetFirstNameInGroup( nRefGeo, WIN_GEO_SURF)
|
|
|
|
local nClassOut = EgtCurveWithRegionClassify( nOutId, nRefSurf)
|
|
if nClassOut == GDB_CRC.OUT then
|
|
local nClassIn = EgtCurveWithRegionClassify( nInId, nRefSurf)
|
|
if nClassIn == GDB_CRC.OUT then
|
|
bInters = false
|
|
end
|
|
end
|
|
if bInters then
|
|
table.insert( vTestOutlines, nTestCurve)
|
|
nTestCurve = EgtGetNext( nTestCurve) or EgtGetFirstInGroup( EgtGetParent( nTestCurve))
|
|
end
|
|
end
|
|
|
|
-- 2) testo le curve controllando intersezione tra le superfici dei pezzi
|
|
-- creo il solido principale
|
|
local dExtraLen = b3Profile:getDimX()
|
|
local nMainSurf = CreateProfileSurf( nOutlineId, nMainProfile, WIN_SECTION, 4 * dExtraLen, nGrpTmp)
|
|
EgtCutSurfTmPlane( nMainSurf, EgtMP( nOutlineId), EgtIf( bPrevOrNext, 1, -1) * EgtSV( nOutlineId))
|
|
|
|
-- recupero profili per i conti
|
|
local vProfiles = {}
|
|
local vsCtrIn = {}
|
|
for i = 1, #vTestOutlines do
|
|
vProfiles[i] = GetOutlineProfileId( vTestOutlines[i], true)
|
|
vsCtrIn[i] = GetProfileCtrIn( vTestOutlines[i], nOutlineId, vProfiles[i])
|
|
end
|
|
|
|
-- testo le curve
|
|
for i = 1, #vTestOutlines do
|
|
-- creo la superficie di test limitandola con le sue vicine
|
|
local nTestSurf = CreateProfileSurf( vTestOutlines[i], vProfiles[i], vsCtrIn[i], 4 * dExtraLen, nGrpTmp)
|
|
if i > 1 then
|
|
if AreSameVectorApprox( EgtEV( vTestOutlines[i-1]), EgtSV( vTestOutlines[i])) then
|
|
EgtCutSurfTmPlane( nTestSurf, EgtEP( vTestOutlines[i-1]), - EgtEV( vTestOutlines[i-1]), false)
|
|
else
|
|
local nTrimSurf = CreateProfileSurf( vTestOutlines[i-1], vProfiles[i-1], WIN_OFST .. vsCtrIn[i-1], 4 * dExtraLen, nGrpTmp)
|
|
EgtSurfTmCut( nTestSurf, nTrimSurf, true, false)
|
|
end
|
|
end
|
|
if i < #vTestOutlines then
|
|
if AreSameVectorApprox( EgtEV( vTestOutlines[i]), EgtSV( vTestOutlines[i+1])) then
|
|
EgtCutSurfTmPlane( nTestSurf, EgtEP( vTestOutlines[i]), EgtEV( vTestOutlines[i]), false)
|
|
else
|
|
local nTrimSurf = CreateProfileSurf( vTestOutlines[i+1], vProfiles[i+1], WIN_OFST .. vsCtrIn[i+1], 4 * dExtraLen, nGrpTmp)
|
|
EgtSurfTmCut( nTestSurf, nTrimSurf, true, false)
|
|
end
|
|
end
|
|
-- calcolo intersezione con il solido : se c'è intersezione è una vera curva di trim, altrimenti non va considerata
|
|
local nId, _, nCrvCnt = EgtSurfTmSurfTmInters( nMainSurf, nTestSurf, nGrpTmp)
|
|
if nId and nCrvCnt > 0 then
|
|
table.insert( vRealTrimOutlines, vTestOutlines[i])
|
|
end
|
|
end
|
|
|
|
return vRealTrimOutlines
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che recupera gli outline precedenti e successivi
|
|
local function GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId)
|
|
|
|
local vPrevOutlineId = {}
|
|
local vNextOutlineId = {}
|
|
|
|
if nProfileType ~= WIN_PRF.SPLIT then
|
|
vPrevOutlineId = { EgtGetPrev( nOutlineId) or EgtGetLastInGroup( nOutlineLayerId)}
|
|
vNextOutlineId = { EgtGetNext( nOutlineId) or EgtGetFirstInGroup( nOutlineLayerId)}
|
|
|
|
else
|
|
-- se split recupero tutte le curve di base outline che lo tagliano dalle info
|
|
local vPrevBaseOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'vi')
|
|
local vNextBaseOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'vi')
|
|
-- recupero gli outlines associati
|
|
for i = 1, #vPrevBaseOutlineId do
|
|
vPrevOutlineId[i] = EgtGetInfo( vPrevBaseOutlineId[i], WIN_COPY, 'i')
|
|
end
|
|
for i = 1, #vNextBaseOutlineId do
|
|
vNextOutlineId[i] = EgtGetInfo( vNextBaseOutlineId[i], WIN_COPY, 'i')
|
|
end
|
|
|
|
-- controllo validità delle curve trovate verificando l'interferenza tra i profili
|
|
local nGrpTmp = EgtGroup( GDB_ID.ROOT)
|
|
local nMainProfile = GetOutlineProfileId( nOutlineId)
|
|
local b3Profile = GetProfileLocalBox( nMainProfile)
|
|
vPrevOutlineId = TestSplitTrimOutlines( nOutlineId, vPrevOutlineId, nMainProfile, b3Profile, nGrpTmp, true)
|
|
vNextOutlineId = TestSplitTrimOutlines( nOutlineId, vNextOutlineId, nMainProfile, b3Profile, nGrpTmp, false)
|
|
EgtErase( nGrpTmp)
|
|
|
|
-- considero come curve prev e next quelle associate ad un pezzo e non curve virtuali per rendere più solidi i conti successivi
|
|
-- verifico la coerenza dell'orientamento e la indico con il segno ( > 0 concorde, < 0 discorde e va invertita)
|
|
for i = 1, #vPrevOutlineId do
|
|
local nPart = FindAssociatedPart( vPrevOutlineId[i], true)
|
|
local bInvert = EgtGetInfo( vPrevOutlineId[i], WIN_INV_SPLIT, 'b') or false
|
|
vPrevOutlineId[i] = EgtGetInfo( nPart, WIN_REF_OUTLINE, 'i')
|
|
if bInvert then
|
|
vPrevOutlineId[i] = - vPrevOutlineId[i]
|
|
end
|
|
end
|
|
for i = 1, #vNextOutlineId do
|
|
local nPart = FindAssociatedPart( vNextOutlineId[i], true)
|
|
local bInvert = EgtGetInfo( vNextOutlineId[i], WIN_INV_SPLIT, 'b') or false
|
|
vNextOutlineId[i] = EgtGetInfo( nPart, WIN_REF_OUTLINE, 'i')
|
|
if bInvert then
|
|
vNextOutlineId[i] = - vNextOutlineId[i]
|
|
end
|
|
end
|
|
end
|
|
|
|
return vPrevOutlineId, vNextOutlineId
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
-------------------------------- GEO -------------------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che dato il tipo di pezzo e di giunzione, restituisce se e' corto, lungo o angolato
|
|
local function CalcPartJointType( nProfileType, JointType)
|
|
|
|
if JointType == WIN_JNT.ANGLED then
|
|
return WIN_PART_JNT.ANGLED
|
|
end
|
|
if nProfileType == WIN_PRF.BOTTOMRAIL or nProfileType == WIN_PRF.BOTTOMRAIL_FINAL or nProfileType == WIN_PRF.SPLIT then
|
|
return WIN_PART_JNT.SHORT
|
|
elseif nProfileType == WIN_PRF.BOTTOM or nProfileType == WIN_PRF.TOP then
|
|
if JointType == WIN_JNT.FULL_H then
|
|
return WIN_PART_JNT.FULL
|
|
elseif JointType == WIN_JNT.FULL_V then
|
|
return WIN_PART_JNT.SHORT
|
|
end
|
|
elseif nProfileType == WIN_PRF.LEFT or nProfileType == WIN_PRF.RIGHT then
|
|
if JointType == WIN_JNT.FULL_V then
|
|
return WIN_PART_JNT.FULL
|
|
elseif JointType == WIN_JNT.FULL_H then
|
|
return WIN_PART_JNT.SHORT
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola e salva nel profilo il delta del bottomrail corrente rispetto alla sua curva di outline
|
|
local function SaveRailDelta( nProfileId, nBottomRail)
|
|
local dDelta1 = EgtGetInfo( nProfileId, WIN_RAILDELTA .. '1', 'd')
|
|
local dDelta2 = EgtGetInfo( nProfileId, WIN_RAILDELTA .. '2', 'd')
|
|
local dOffs = dDelta1 + ( nBottomRail - 1) * dDelta2
|
|
EgtSetInfo( nProfileId, WIN_RAILDELTA, dOffs)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea il gruppo con i profili di un pezzo
|
|
local function CalcProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutlineId, nProfileType, nBottomRail)
|
|
|
|
-- creo gruppo per i profili
|
|
local nProfileLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nProfileLayerId, WIN_PROFILE)
|
|
EgtSetStatus( nProfileLayerId, GDB_ST.OFF)
|
|
|
|
-- recupero profilo principale e ne creo copia
|
|
local nOrigMainProfileId = GetOutlineProfileId( nOutlineId, false, nProfileType)
|
|
local nMainProfileId = EgtCopy( nOrigMainProfileId, nProfileLayerId)
|
|
local sMainProfileType = EgtGetName( nMainProfileId)
|
|
EgtSetInfo( nMainProfileId, WIN_PRF_TYPE, sMainProfileType)
|
|
EgtSetName( nMainProfileId, WIN_PRF_MAIN)
|
|
-- se bottomrail salvo info per scostamento dall'outline
|
|
if sMainProfileType == WIN_FILL_RAIL or sMainProfileType == WIN_RAIL then
|
|
SaveRailDelta( nMainProfileId, nBottomRail)
|
|
end
|
|
|
|
-- recupero profili start e ne creo copia
|
|
-- se il tipo corrente è split il pezzo va tagliato con il bottomrail, altrimenti con il bottom
|
|
for i = 1, #vPrevOutlineId do
|
|
local nOrigStartProfileId = GetOutlineProfileId( abs( vPrevOutlineId[i]), nProfileType == WIN_PRF.SPLIT)
|
|
local nStartProfileId = EgtCopy( nOrigStartProfileId, nProfileLayerId)
|
|
local sStartProfileType = EgtGetName( nStartProfileId)
|
|
EgtSetInfo( nStartProfileId, WIN_PRF_TYPE, sStartProfileType)
|
|
EgtSetName( nStartProfileId, WIN_PRF_START)
|
|
if sStartProfileType == WIN_FILL_RAIL then
|
|
local nBottomRailTot = EgtGetInfo( abs( vPrevOutlineId[i]), WIN_BOTTOMRAIL, 'i')
|
|
SaveRailDelta( nStartProfileId, nBottomRailTot)
|
|
end
|
|
end
|
|
|
|
-- recupero profili end e ne creo copia
|
|
for i = 1, #vNextOutlineId do
|
|
local nOrigEndProfileId = GetOutlineProfileId( abs( vNextOutlineId[i]), nProfileType == WIN_PRF.SPLIT)
|
|
local nEndProfileId = EgtCopy( nOrigEndProfileId, nProfileLayerId)
|
|
local sEndProfileType = EgtGetName( nEndProfileId)
|
|
EgtSetInfo( nEndProfileId, WIN_PRF_TYPE, sEndProfileType)
|
|
EgtSetName( nEndProfileId, WIN_PRF_END)
|
|
if sEndProfileType == WIN_FILL_RAIL then
|
|
local nBottomRailTot = EgtGetInfo( abs( vNextOutlineId[i]), WIN_BOTTOMRAIL, 'i')
|
|
SaveRailDelta( nEndProfileId, nBottomRailTot)
|
|
end
|
|
end
|
|
|
|
-- recupero le info di pinzaggio dal profilo di estrusione
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_OFFY_1, 0)
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_OFFZ_1, 0)
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_OFFY_2, 0)
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_OFFZ_2, 0)
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_CLAMPV_1, 0)
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_CLAMPV_2, 0)
|
|
|
|
return nProfileLayerId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetDeltaProfile( nProfileId, sCtrIn)
|
|
|
|
local dCPDelta = 0
|
|
local nSectionFrId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frSectionFrame = EgtFR( nSectionFrId, GDB_ID.ROOT)
|
|
local nCPId = EgtGetFirstNameInGroup( nProfileId, sCtrIn)
|
|
local b3CP = EgtGetBBoxRef( nCPId, GDB_BB.STANDARD, frSectionFrame)
|
|
if sCtrIn == WIN_CTRIN .. 1 then
|
|
dCPDelta = abs( b3CP:getMin():getX())
|
|
else
|
|
dCPDelta = abs( b3CP:getMax():getX())
|
|
end
|
|
-- se bottomrail considero anche scostamento dall'outline
|
|
local sProfileType = EgtGetInfo( nProfileId, WIN_PRF_TYPE)
|
|
if sProfileType == WIN_FILL_RAIL then
|
|
local dDelta = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd')
|
|
dCPDelta = dCPDelta + dDelta
|
|
end
|
|
return dCPDelta
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea le curve del geo
|
|
local function CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStartPartJointType, nEndPartJointType, nGeoLayerId, nProfileLayerId)
|
|
|
|
local nCurrProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
|
-- calcolo spostamento della curva iniziale dovuto a posizione riferimento
|
|
local b3CurrProfileFrame = GetProfileLocalBox( nCurrProfileId)
|
|
local dCurrOffset = b3CurrProfileFrame:getMax():getX()
|
|
local sProfileType = EgtGetInfo( nCurrProfileId, WIN_PRF_TYPE)
|
|
if sProfileType == WIN_FILL_RAIL or sProfileType == WIN_RAIL then
|
|
-- scostamento extra legato al bottomrail
|
|
local dDelta = EgtGetInfo( nCurrProfileId, WIN_RAILDELTA, 'd')
|
|
dCurrOffset = dCurrOffset - dDelta
|
|
end
|
|
|
|
-- creo copie degli outline e le offsetto opportunamente
|
|
-- curva out
|
|
local nOutId = EgtCopy( nOutlineId, nGeoLayerId)
|
|
EgtOffsetCurve( nOutId, dCurrOffset)
|
|
EgtSetName( nOutId, WIN_GEO_OUT)
|
|
local nSemiProfileOut = EgtGetFirstNameInGroup( nCurrProfileId, WIN_OUT) or EgtGetFirstNameInGroup( nCurrProfileId, WIN_IN .. '1')
|
|
EgtSetInfo( nOutId, WIN_SEMI_PROFILE, nSemiProfileOut)
|
|
EgtSetInfo( nOutId, WIN_REF_OUTLINE, nOutlineId)
|
|
|
|
-- curva in
|
|
local nInId = EgtCopy( nOutlineId, nGeoLayerId)
|
|
EgtOffsetCurve( nInId, dCurrOffset - b3CurrProfileFrame:getDimX())
|
|
EgtInvertCurve( nInId)
|
|
EgtSetName( nInId, WIN_GEO_IN)
|
|
local nSemiProfileIn = EgtGetFirstNameInGroup( nCurrProfileId, WIN_IN) or EgtGetFirstNameInGroup( nCurrProfileId, WIN_IN .. '2') or EgtGetFirstNameInGroup( nCurrProfileId, WIN_MIXED_COMMON .. WIN_IN)
|
|
EgtSetInfo( nInId, WIN_SEMI_PROFILE, nSemiProfileIn)
|
|
EgtSetInfo( nInId, WIN_REF_OUTLINE, nOutlineId)
|
|
|
|
-- curve left
|
|
local vPrevProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_START)
|
|
for i = 1, #vPrevOutlineId do
|
|
local nPrevCurveId
|
|
local nPrevSemiProfile
|
|
if nStartPartJointType == WIN_PART_JNT.ANGLED then
|
|
-- calcolo la bisettrice
|
|
local vtMedia = ( ( EgtSV( nOutlineId) - EgtEV( abs( vPrevOutlineId[i]))) / 2)
|
|
if not vtMedia:normalize() then
|
|
vtMedia = EgtSV( nOutlineId)
|
|
vtMedia:rotate( Z_AX(), 90)
|
|
end
|
|
nPrevCurveId = EgtLinePVL( nGeoLayerId, EgtSP( nOutlineId), vtMedia, 3 * b3CurrProfileFrame:getDimX())
|
|
EgtInvertCurve( nPrevCurveId)
|
|
else
|
|
nPrevCurveId = EgtCopy( abs( vPrevOutlineId[i]), nGeoLayerId)
|
|
if vPrevOutlineId[i] < 0 then
|
|
EgtInvertCurve( nPrevCurveId)
|
|
end
|
|
if nStartPartJointType == WIN_PART_JNT.SHORT then
|
|
local sCtrIn = GetProfileCtrIn( abs( vPrevOutlineId[i]), nOutlineId, vPrevProfileId[i])
|
|
local dCPDelta = GetDeltaProfile( vPrevProfileId[i], sCtrIn)
|
|
EgtOffsetCurve( nPrevCurveId, - dCPDelta)
|
|
-- ricavo il semiprofilo associato
|
|
nPrevSemiProfile = EgtGetFirstNameInGroup( vPrevProfileId[i], sCtrIn)
|
|
else
|
|
nPrevSemiProfile = EgtGetFirstNameInGroup( vPrevProfileId[i], WIN_OUT)
|
|
end
|
|
end
|
|
EgtSetName( nPrevCurveId, WIN_GEO_LEFT)
|
|
EgtSetInfo( nPrevCurveId, WIN_SEMI_PROFILE, nPrevSemiProfile)
|
|
EgtSetInfo( nPrevCurveId, WIN_REF_OUTLINE, vPrevOutlineId[i])
|
|
EgtRelocateGlob( nPrevCurveId, nGeoLayerId, GDB_IN.LAST_SON)
|
|
end
|
|
|
|
-- curve right
|
|
local vNextProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_END)
|
|
for i = 1, #vNextOutlineId do
|
|
local nNextCurveId
|
|
local nNextSemiProfile
|
|
if nEndPartJointType == WIN_PART_JNT.ANGLED then
|
|
-- calcolo la bisettrice
|
|
local vtMedia = ( ( EgtSV( abs( vNextOutlineId[i])) - EgtEV( nOutlineId)) / 2)
|
|
if not vtMedia:normalize() then
|
|
vtMedia = EgtEV( nOutlineId)
|
|
vtMedia:rotate( Z_AX(), 90)
|
|
end
|
|
nNextCurveId = EgtLinePVL( nGeoLayerId, EgtEP( nOutlineId), vtMedia, 3 * b3CurrProfileFrame:getDimX())
|
|
else
|
|
nNextCurveId = EgtCopy( abs( vNextOutlineId[i]), nGeoLayerId)
|
|
if vNextOutlineId[i] < 0 then
|
|
EgtInvertCurve( nNextCurveId)
|
|
end
|
|
if nEndPartJointType == WIN_PART_JNT.SHORT then
|
|
local sCtrIn = GetProfileCtrIn( abs( vNextOutlineId[i]), nOutlineId, vNextProfileId[i])
|
|
local dCPDelta = GetDeltaProfile( vNextProfileId[i], sCtrIn)
|
|
EgtOffsetCurve( nNextCurveId, - dCPDelta)
|
|
-- ricavo il semiprofilo associato
|
|
nNextSemiProfile = EgtGetFirstNameInGroup( vNextProfileId[i], sCtrIn)
|
|
else
|
|
nNextSemiProfile = EgtGetFirstNameInGroup( vNextProfileId[i], WIN_OUT)
|
|
end
|
|
end
|
|
EgtSetName( nNextCurveId, WIN_GEO_RIGHT)
|
|
EgtSetInfo( nNextCurveId, WIN_SEMI_PROFILE, nNextSemiProfile)
|
|
EgtSetInfo( nNextCurveId, WIN_REF_OUTLINE, vNextOutlineId[i])
|
|
EgtRelocateGlob( nNextCurveId, nInId, GDB_IN.BEFORE)
|
|
end
|
|
|
|
-- trim delle curve
|
|
local vIds = EgtGetAllInGroup( nGeoLayerId)
|
|
local vMainCrvs = TrimOrderedCurves( vIds, 2)
|
|
|
|
-- costruisco la regione
|
|
local nCompoId = EgtCurveCompo( nGeoLayerId, vMainCrvs, false)
|
|
local nAreaId = EgtSurfFlatRegion( nGeoLayerId, nCompoId)
|
|
EgtSetName( nAreaId, WIN_GEO_SURF)
|
|
EgtSetStatus( nAreaId, GDB_ST.OFF)
|
|
EgtErase( nCompoId)
|
|
|
|
-- assegno spessore
|
|
local dGeoH = b3CurrProfileFrame:getDimY()
|
|
EgtModifyCurveThickness( vIds, - dGeoH)
|
|
|
|
-- salvo spessore serramento nel gruppo
|
|
local dGeoWidth = b3CurrProfileFrame:getDimX()
|
|
EgtSetInfo( nGeoLayerId, WIN_GEOWIDTH, dGeoWidth)
|
|
EgtSetInfo( nGeoLayerId, WIN_GEOHEIGHT, dGeoH)
|
|
|
|
-- calcolo lunghezza se pezzo lineare ( se arco verrà gestito nel calcolo dei tronchetti)
|
|
if EgtGetType( nOutlineId) == GDB_TY.CRV_LINE then
|
|
local vtS = EgtSV( nOutlineId)
|
|
local frRef = Frame3d( ORIG(), vtS, Z_AX() ^ vtS, Z_AX())
|
|
local b3Ref = EgtGetBBoxRef( nAreaId, GDB_BB.STANDARD, frRef)
|
|
EgtSetInfo( nGeoLayerId, WIN_GEOLEN, b3Ref:getDimX())
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola l'ingombro dei pezzi del telaio
|
|
local function CalcFrameGeo( nPartId, nOutlineId, nOutlineCrvNbr, nOutlineLayerId, nProfileType, nBottomRail)
|
|
|
|
-- creo layer per ingombro
|
|
local nGeoLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nGeoLayerId, WIN_GEO)
|
|
|
|
-- recupero outline precedenti e successivi ( solo nel caso di split possono essere più di uno)
|
|
local vPrevOutlineId, vNextOutlineId = GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId)
|
|
EgtSetInfo( nOutlineId, WIN_PREV_OUTLINES, vPrevOutlineId)
|
|
EgtSetInfo( nOutlineId, WIN_NEXT_OUTLINES, vNextOutlineId)
|
|
|
|
-- recupero il tipo di giunzioni
|
|
local nStartJointType
|
|
local nEndJointType
|
|
local nProfileTypeS = nProfileType
|
|
local nProfileTypeE = nProfileType
|
|
if nProfileType == WIN_PRF.SPLIT or nProfileType == WIN_PRF.BOTTOMRAIL or nProfileType == WIN_PRF.BOTTOMRAIL_FINAL then
|
|
-- non serve settare dei valori per StartJointType ed EndJointType perchè in CalcPartJointType la loro giunzione viene settata a short
|
|
else
|
|
-- recupero i joints opportuni dal vettore
|
|
local vJoints = EgtGetInfo( nOutlineLayerId, WIN_JOINTS, 'vi')
|
|
if EgtGetName( nOutlineId) == WIN_BOTTOM then
|
|
nStartJointType = vJoints[1]
|
|
nEndJointType = vJoints[2]
|
|
elseif EgtGetName( nOutlineId) == WIN_RIGHT then
|
|
nStartJointType = vJoints[2]
|
|
nEndJointType = vJoints[3]
|
|
elseif EgtGetName( nOutlineId) == WIN_TOP then
|
|
nStartJointType = vJoints[3]
|
|
nEndJointType = vJoints[4]
|
|
-- correzioni per caso a triangolo
|
|
if EgtGetName( abs( vPrevOutlineId[#vPrevOutlineId])) == WIN_BOTTOM then
|
|
nStartJointType = vJoints[2]
|
|
nEndJointType = vJoints[3]
|
|
-- il lato top deve essere trattato come un left/right nel calcolo della giunzione
|
|
nProfileTypeS = WIN_PRF.LEFT
|
|
end
|
|
if EgtGetName( abs( vNextOutlineId[1])) == WIN_BOTTOM then
|
|
nStartJointType = vJoints[3]
|
|
nEndJointType = vJoints[1]
|
|
nProfileTypeE = WIN_PRF.LEFT
|
|
end
|
|
elseif EgtGetName( nOutlineId) == WIN_LEFT then
|
|
nStartJointType = vJoints[4] or vJoints[3] -- ( vJoints[3] per gestire caso a triangolo)
|
|
nEndJointType = vJoints[1]
|
|
end
|
|
|
|
-- se giunzione diversa da bisettrice e arco a tutto sesto oppure elementi entrambi dello stesso tipo, forzo il tipo a bisettrice
|
|
if nStartJointType ~= WIN_JNT.ANGLED and ( AreSameVectorApprox( EgtEV( abs( vPrevOutlineId[1])), EgtSV( nOutlineId)) or EgtGetName( nOutlineId) == EgtGetName( abs( vPrevOutlineId[1]))) then
|
|
nStartJointType = WIN_JNT.ANGLED
|
|
end
|
|
if nEndJointType ~= WIN_JNT.ANGLED and ( AreSameVectorApprox( EgtEV( nOutlineId), EgtSV( abs( vNextOutlineId[1]))) or EgtGetName( nOutlineId) == EgtGetName( abs( vNextOutlineId[1]))) then
|
|
nEndJointType = WIN_JNT.ANGLED
|
|
end
|
|
end
|
|
|
|
-- calcolo il tipo di giunzione per la parte
|
|
local nStartPartJointType = CalcPartJointType( nProfileTypeS, nStartJointType)
|
|
local nEndPartJointType = CalcPartJointType( nProfileTypeE, nEndJointType)
|
|
-- nel caso di incontro con soglia la giunzione deve essere full
|
|
if EgtGetInfo( abs( vPrevOutlineId[1]), WIN_THRESHOLD, 'b') then
|
|
nStartPartJointType = WIN_JNT.FULL
|
|
end
|
|
if EgtGetInfo( abs( vNextOutlineId[1]), WIN_THRESHOLD, 'b') then
|
|
nEndPartJointType = WIN_JNT.FULL
|
|
end
|
|
|
|
-- salvo il valore dei joints su outline
|
|
-- se bottomrail è sicuramente short quindi non salvo il valore che sovrascriverebbe quello del pezzo bottom ( che potrebbe essere short o full)
|
|
if nProfileType ~= WIN_PRF.BOTTOMRAIL and nProfileType ~= WIN_PRF.BOTTOMRAIL_FINAL then
|
|
EgtSetInfo( nOutlineId, WIN_STARTJOINT, nStartPartJointType)
|
|
EgtSetInfo( nOutlineId, WIN_ENDJOINT, nEndPartJointType)
|
|
end
|
|
|
|
-- creo il gruppo con i profili del pezzo
|
|
local nProfileLayerId = CalcProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutlineId, nProfileType, nBottomRail)
|
|
|
|
-- creo lati dell'outline
|
|
CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStartPartJointType, nEndPartJointType, nGeoLayerId, nProfileLayerId)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola l'ingombro del fill
|
|
local function CalcFillGeo( nPartId, nOutlineLayerId)
|
|
|
|
-- creo layer per ingombro
|
|
local nGeoLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nGeoLayerId, WIN_GEO)
|
|
-- copio lati da Outline
|
|
local vOutlineIds = EgtGetAllInGroup( nOutlineLayerId)
|
|
for i = 1, #vOutlineIds do
|
|
local nCrv = EgtCopy( vOutlineIds[i], nGeoLayerId)
|
|
EgtSetInfo( nCrv, WIN_REF_OUTLINE, vOutlineIds[i])
|
|
end
|
|
|
|
-- recupero e salvo spessore vetro
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nSashProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
|
|
local dGlassThickness = EgtGetInfo( nSashProfileId, WIN_GLASSTHICKNESS, 'd')
|
|
EgtSetInfo( nGeoLayerId, WIN_GLASSTHICKNESS, dGlassThickness)
|
|
|
|
-- verifico forma e salvataggio info associate
|
|
local nCompo = EgtCurveCompo( nGeoLayerId, EgtGetAllInGroup( nGeoLayerId), false)
|
|
local bRect, ptTest, vtEdge1, vtEdge2 = EgtCurveIsARectangle( nCompo)
|
|
EgtSetInfo( nGeoLayerId, WIN_GLASS_RECT, bRect)
|
|
if bRect then
|
|
EgtSetInfo( nGeoLayerId, WIN_GEOWIDTH, vtEdge1:len())
|
|
EgtSetInfo( nGeoLayerId, WIN_GEOHEIGHT, vtEdge2:len())
|
|
else
|
|
-- se non è rettangolare salvo le dimensioni del suo box orientato in modo ottimale
|
|
local _, dDim1, dDim2 = EgtCurveMinAreaRectangleXY( nCompo)
|
|
EgtSetInfo( nGeoLayerId, WIN_GEOWIDTH, dDim1)
|
|
EgtSetInfo( nGeoLayerId, WIN_GEOHEIGHT, dDim2)
|
|
end
|
|
EgtErase( nCompo)
|
|
|
|
return nGeoLayerId
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
----------------------- CURVE AUX PER CAMBIO PROFILO -----------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che individua e crea i diversi tratti uniformi della curva di outline
|
|
local function CalcMixedOutlines( nPartId, nOutlineId)
|
|
|
|
-- creo gruppo dove salvare i sottotratti
|
|
local nGrp = EgtGroup( nPartId)
|
|
EgtSetName( nGrp, WIN_MIXED_OUTLINES)
|
|
EgtSetStatus( nGrp, GDB_ST.OFF)
|
|
|
|
-- recupero i tratti di tipo sash e li concateno
|
|
local vSashChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi')
|
|
local vSash = {}
|
|
for i = 1, #vSashChildren do
|
|
local nCrv = EgtCopyGlob( vSashChildren[i], nGrp)
|
|
table.insert( vSash, nCrv)
|
|
end
|
|
local nCrvS, nCntS = EgtCurveCompoByReorder( nGrp, vSash, EgtSP( nOutlineId))
|
|
for nId = nCrvS, nCrvS + nCntS - 1 do
|
|
-- da curva compo ricavo la curva linea/arco corrispondente
|
|
EgtMergeCurvesInCurveCompo( nId)
|
|
local nNewId = EgtExplodeCurveCompo( nId)
|
|
EgtSetName( nNewId, WIN_SASH)
|
|
end
|
|
|
|
-- recupero i tratti di tipo fill e li concateno
|
|
local vFillChildren = EgtGetInfo( nOutlineId, WIN_FILL_CHILDREN, 'vi')
|
|
local vFill = {}
|
|
for i = 1, #vFillChildren do
|
|
local nCrv = EgtCopyGlob( vFillChildren[i], nGrp)
|
|
table.insert( vFill, nCrv)
|
|
end
|
|
local nCrvF, nCntF = EgtCurveCompoByReorder( nGrp, vFill, EgtSP( nOutlineId))
|
|
for nId = nCrvF, nCrvF + nCntF - 1 do
|
|
EgtMergeCurvesInCurveCompo( nId)
|
|
local nNewId = EgtExplodeCurveCompo( nId)
|
|
EgtSetName( nNewId, WIN_FILL)
|
|
end
|
|
|
|
-- riordino le curve nel gruppo per ricostruire l'outline
|
|
EgtReorderCurvesInGroup( nGrp, EgtSP( nOutlineId))
|
|
|
|
-- creo associazione tra le sottocurve di outline e gli split che le separano :
|
|
-- recupero tutti gli split coinvolti
|
|
local nBaseOutline = EgtGetInfo( nOutlineId, WIN_COPY, 'i')
|
|
local vStack = { nBaseOutline}
|
|
local vSplitIds = {}
|
|
local i = 1
|
|
while vStack[i] do
|
|
-- recupero il tipo di area
|
|
local nAreaId = EgtGetParent( EgtGetParent( vStack[i]))
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
if nAreaType ~= WIN_AREATYPES.SASH and nAreaType ~= WIN_AREATYPES.FILL then
|
|
-- salvo i suo eventuali split mixed
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT)
|
|
if nSplitLayerId then
|
|
local vCurrSplits = EgtGetAllInGroup( nSplitLayerId)
|
|
for j = 1, #vCurrSplits do
|
|
if EgtGetInfo( vCurrSplits[j], WIN_SPLITTYPE, 'i') == WIN_SPLITTYPES.MIXED then
|
|
table.insert( vSplitIds, vCurrSplits[j])
|
|
end
|
|
end
|
|
end
|
|
-- analizzo eventuali figli
|
|
local vChildren = EgtGetInfo( vStack[i], WIN_CHILD, 'vi') or {}
|
|
vStack = EgtJoinTables( vStack, vChildren)
|
|
end
|
|
i = i + 1
|
|
end
|
|
|
|
-- associo le curve con lo split che le taglia nel loro punto finale
|
|
local vCrvs = EgtGetAllInGroup( nGrp)
|
|
for i = 1, #vSplitIds do
|
|
local ptS = EgtSP( vSplitIds[i])
|
|
local ptE = EgtEP( vSplitIds[i])
|
|
for j = 1, #vCrvs - 1 do
|
|
local ptTest = EgtEP( vCrvs[j])
|
|
if AreSamePointApprox( ptS, ptTest) then
|
|
EgtSetInfo( vSplitIds[i], WIN_MIXED_REF_START, vCrvs[j])
|
|
EgtSetInfo( vCrvs[j], WIN_MIXED_SPLIT_REF, vSplitIds[i])
|
|
break
|
|
elseif AreSamePointApprox( ptE, ptTest) then
|
|
EgtSetInfo( vSplitIds[i], WIN_MIXED_REF_END, vCrvs[j])
|
|
EgtSetInfo( vCrvs[j], WIN_MIXED_SPLIT_REF, vSplitIds[i])
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
return nGrp
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea la curva di riferimento sulla giunzione tra il pezzo di split e il pezzo di telaio con cambio profilo
|
|
local function CalcMixedIntersections( nPartId, nOutline, vOutlines)
|
|
|
|
local nGrp = EgtGroup( nPartId)
|
|
EgtSetName( nGrp, WIN_MIXED_INTERSECTIONS)
|
|
EgtSetStatus( nGrp, GDB_ST.OFF)
|
|
|
|
-- recupero il profilo dell'outline
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
|
|
|
for i = 1, #vOutlines - 1 do
|
|
|
|
-- recupero la curva di split che separa i due tratti di outline
|
|
local nSplitId = EgtGetInfo( vOutlines[i], WIN_MIXED_SPLIT_REF, 'i')
|
|
local nSplitProfileId = GetOutlineProfileId( nSplitId, false)
|
|
|
|
-- verifico ordinamento
|
|
local bSashFill = ( EgtGetName( vOutlines[i]) == WIN_SASH)
|
|
|
|
-- ricavo il punto di incontro tra le due parti dei profili che vanno contro il vetro
|
|
local nCrv1 = EgtCopyGlob( nSplitId, nGrp)
|
|
local dDeltaFixedSplit = EgtGetInfo( nSplitProfileId, WIN_FIXED_REF, 'd')
|
|
EgtOffsetCurve( nCrv1, dDeltaFixedSplit)
|
|
local nCrv2 = EgtCopyGlob( nOutline, nGrp)
|
|
local dDeltaFixedFrame = EgtGetInfo( nMainProfileId, WIN_FIXED_REF, 'd')
|
|
EgtOffsetCurve( nCrv2, - dDeltaFixedFrame)
|
|
local ptRef1 = EgtIP( nCrv1, nCrv2, ORIG())
|
|
|
|
-- ricavo il punto di incontro tra il taglio a 45° e la parte del telaio contro anta
|
|
-- TO DO : capire come gestire correttamente la rotazione nel caso di arco
|
|
local dParRef = EgtCurveParamAtPoint( nCrv2, ptRef1)
|
|
local vtDir45 = EgtUV( nCrv2, dParRef, -1)
|
|
vtDir45:rotate( Z_AX(), EgtIf( bSashFill, 225, -45))
|
|
local nCrv3 = EgtLinePVL( nGrp, ptRef1, vtDir45, 100)
|
|
local nCrv4 = EgtCopyGlob( nOutline, nGrp)
|
|
local dDeltaSashFrame = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '1', 'd')
|
|
EgtOffsetCurve( nCrv4, - dDeltaSashFrame)
|
|
local ptRef2 = EgtIP( nCrv3, nCrv4, ORIG())
|
|
|
|
-- curva di intersezione da usare come riferimento per i conti successivi
|
|
local nCrv = EgtCurveCompoFromPoints( nGrp, { ptRef1, ptRef2})
|
|
|
|
-- calcolo il raccordo
|
|
local dRad = EgtGetInfo( nMainProfileId, WIN_RAD_REF .. '1', 'd')
|
|
local dParFillet = EgtCurveParamAtPoint( nCrv4, ptRef2)
|
|
dParFillet = dParFillet + EgtIf( bSashFill, -10, 10) * GEO.EPS_SMALL
|
|
local nFillet = EgtCurveFillet( nGrp, nCrv, EgtUP( nCrv1, 0.9), nCrv4, EgtUP( nCrv4, dParFillet), dRad, true) or GDB_ID.NULL
|
|
EgtAddCurveCompoCurve( nCrv, nFillet)
|
|
|
|
-- cancello curve di costruzione
|
|
EgtErase( { nCrv1, nCrv2, nCrv3, nCrv4})
|
|
|
|
-- assegno riferimento
|
|
EgtSetInfo( vOutlines[i], WIN_MIXED_INTERS_REF, nCrv)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola curve ausiliarie per la gestione del cambio profilo
|
|
local function CalcMixedFrameCurves( nPartId, nOutlineId)
|
|
-- calcolo i sottotratti uniformi della curva di outline
|
|
local nOutlinesGrp = CalcMixedOutlines( nPartId, nOutlineId)
|
|
local vCrvs = EgtGetAllInGroup( nOutlinesGrp)
|
|
-- calcolo le curve di intersezione con gli split
|
|
CalcMixedIntersections( nPartId, nOutlineId, vCrvs)
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
--------------------------- PROFILING PROCESSINGS --------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che copia sulla curva di lavorazione le informazioni prese dal semiprofilo corrispondente
|
|
local function GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile)
|
|
|
|
if nSemiProfile then
|
|
-- setto info di lavorazione
|
|
EgtSetInfo( nCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
|
-- setto info con il tipo di profiling
|
|
local sName = EgtGetName( nCrv)
|
|
if sName == WIN_GEO_LEFT or sName == WIN_GEO_RIGHT then
|
|
EgtSetInfo( nCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.HEAD)
|
|
else
|
|
EgtSetInfo( nCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.LONGITUDINAL)
|
|
end
|
|
-- recupero le info di lavorazione dal semiprofilo
|
|
if sName == WIN_GEO_OUT or sName == WIN_GEO_IN then
|
|
-- recupero la fase solo se si tratta di in o out
|
|
CopyInfo( nCrv, nSemiProfile, WIN_PRC_PHASE)
|
|
end
|
|
local nTools = EgtGetInfo( nSemiProfile, WIN_PRC_NTOOLS , 'i') or 0
|
|
EgtSetInfo( nCrv, WIN_PRC_NTOOLS, nTools)
|
|
for j = 1, nTools do
|
|
CopyInfo( nCrv, nSemiProfile, WIN_PRC_TOOL_NAME .. '_' .. tostring(j))
|
|
CopyInfo( nCrv, nSemiProfile, WIN_PRC_OFFL .. '_' .. tostring(j))
|
|
CopyInfo( nCrv, nSemiProfile, WIN_PRC_OFFR .. '_' .. tostring(j))
|
|
end
|
|
else
|
|
-- se non ha semiprofilo associato è un taglio
|
|
EgtSetInfo( nCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.CUT)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola la prima lavorazione per l'innesto dello split sul telaio nel caso di cambio profilo
|
|
local function CalcMixedFrameMilling1( nIntersCrv, nOutlineId, nMainProfileId, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId)
|
|
|
|
local dOffs = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '1', 'd')
|
|
local dDepth = EgtGetInfo( nMainProfileId, WIN_SASH_DEPTH .. '1', 'd')
|
|
local dFilletRad = EgtGetInfo( nMainProfileId, WIN_RAD_REF .. '1', 'd')
|
|
|
|
-- primo tratto : taglio a 45° e fillet
|
|
local nCrv1 = EgtCopyGlob( nIntersCrv, nProcLayerId)
|
|
EgtExtendCurveStartByLen( nCrv1, 100)
|
|
|
|
-- calcolo il tratto di outline
|
|
local nCrv2 = EgtCopyGlob( nOutlineId, nProcLayerId)
|
|
EgtOffsetCurve( nCrv2, - dOffs)
|
|
if bSashFill then
|
|
EgtInvertCurve( nCrv2)
|
|
end
|
|
local dParS = EgtCurveParamAtPoint( nCrv2, EgtEP( nCrv1))
|
|
local ptEnd = EgtIP( nCrv2, nSplitRef, ORIG())
|
|
local dParE = EgtCurveParamAtPoint( nCrv2, ptEnd)
|
|
EgtTrimCurveStartEndAtParam( nCrv2, dParS, dParE)
|
|
|
|
-- tratto di uscita a 45°
|
|
local vtDir2 = EgtEV( nCrv2)
|
|
vtDir2:rotate( Z_AX(), EgtIf( bSashFill, - 45, 45))
|
|
local nCrv3 = EgtLinePVL( nProcLayerId, ptEnd, vtDir2, 100)
|
|
|
|
-- creo fillet
|
|
local nFillet = EgtCurveFillet( nProcLayerId, nCrv2, EgtUP( nCrv2, 0.9), nCrv3, EgtUP( nCrv3, 0.1), dFilletRad, true)
|
|
|
|
-- creo curva di lavorazione
|
|
local nMillingCrv = EgtCurveCompo( nProcLayerId, {nCrv1, nCrv2, nFillet, nCrv3})
|
|
if bSashFill then
|
|
EgtInvertCurve( nMillingCrv)
|
|
end
|
|
EgtModifyCurveThickness( nMillingCrv, - dDepth)
|
|
-- setto info di lavorazione
|
|
EgtSetInfo( nMillingCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
|
EgtSetInfo( nMillingCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC)
|
|
EgtSetInfo( nMillingCrv, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.IN)
|
|
EgtTrimCurveWithRegion( nMillingCrv, nSurfGeoId, true, false)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola la seconda lavorazione per l'innesto dello split sul telaio nel caso di cambio profilo
|
|
local function CalcMixedFrameMilling2( nIntersCrv, nOutlineId, nMainProfileId, nSplitProfileId, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId)
|
|
|
|
local dOffs = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '2', 'd')
|
|
local dDepth = EgtGetInfo( nMainProfileId, WIN_SASH_DEPTH .. '2', 'd')
|
|
local dFilletRad = EgtGetInfo( nMainProfileId, WIN_RAD_REF .. '2', 'd')
|
|
local dExtraDist = EgtGetInfo( nMainProfileId, WIN_EXTRA_DIST, 'd')
|
|
|
|
local nCrv1 = EgtCopyGlob( nIntersCrv, nProcLayerId)
|
|
EgtExtendCurveStartByLen( nCrv1, 100)
|
|
|
|
-- calcolo il primo tratto di outline
|
|
local nCrv2 = EgtCopyGlob( nOutlineId, nProcLayerId)
|
|
EgtOffsetCurve( nCrv2, - dOffs + dExtraDist)
|
|
if bSashFill then
|
|
EgtInvertCurve( nCrv2)
|
|
end
|
|
|
|
-- taglio i due tratti per unirli
|
|
local pt1 = EgtIP( nCrv1, nCrv2, ORIG())
|
|
local dParE1 = EgtCurveParamAtPoint( nCrv1, pt1)
|
|
EgtTrimCurveEndAtParam( nCrv1, dParE1)
|
|
local dParS2 = EgtCurveParamAtPoint( nCrv2, pt1)
|
|
EgtTrimCurveStartAtParam( nCrv2, dParS2)
|
|
|
|
-- calcolo fillet
|
|
local nFillet1 = EgtCurveFillet( nProcLayerId, nCrv1, EgtUP( nCrv1, 0.9), nCrv2, EgtUP( nCrv2, 0.1), dFilletRad, true)
|
|
|
|
-- calcolo il secondo tratto di outline
|
|
local nCrv3 = EgtCopyGlob( nOutlineId, nProcLayerId)
|
|
EgtOffsetCurve( nCrv3, - dOffs)
|
|
if bSashFill then
|
|
EgtInvertCurve( nCrv3)
|
|
end
|
|
local nSplitRef2 = EgtCopyGlob( nSplitRef, nProcLayerId)
|
|
local dOffs1 = EgtGetInfo( nSplitProfileId, WIN_SASH_REF .. '1', 'd')
|
|
local dOffs2 = EgtGetInfo( nSplitProfileId, WIN_SASH_REF .. '2', 'd')
|
|
EgtOffsetCurve( nSplitRef2, dOffs2 - dOffs1)
|
|
local pt2 = EgtIP( nCrv3, nSplitRef2, ORIG())
|
|
local pt3 = EgtIP( nCrv3, nSplitRef, ORIG())
|
|
local dParS3 = EgtCurveParamAtPoint( nCrv3, pt2)
|
|
local dParE3 = EgtCurveParamAtPoint( nCrv3, pt3)
|
|
EgtTrimCurveStartEndAtParam( nCrv3, dParS3, dParE3)
|
|
EgtErase( nSplitRef2)
|
|
|
|
-- calcolo il raccordo tra i due tratti di outline : è arco di raggio dFilletRad, tangente a nCrv2 e con punto finale pt2
|
|
-- calcolo il centro dell'arco
|
|
local nCircleTmp = EgtCircle( nProcLayerId, pt2, dFilletRad)
|
|
local nCrvTmp = EgtCopyGlob( nOutlineId, nProcLayerId)
|
|
EgtOffsetCurve( nCrvTmp, - dOffs + dExtraDist - dFilletRad)
|
|
local ptC = EgtIP( nCircleTmp, nCrvTmp, EgtIf( bSashFill, EgtEP( nCrvTmp), EgtSP( nCrvTmp)))
|
|
EgtErase( {nCircleTmp, nCrvTmp})
|
|
local nFillet2 = EgtArcC2PEx( nProcLayerId, ptC, EgtSP( nCrv2), GDB_PT.TG, nCrv2, pt2)
|
|
|
|
-- taglio il primo tratto di outline per collegarlo al raccordo
|
|
local dParE2 = EgtCurveParamAtPoint( nCrv2, EgtSP( nFillet2))
|
|
EgtTrimCurveEndAtParam( nCrv2, dParE2)
|
|
|
|
-- tratto di uscita a 45°
|
|
local vtDir2 = EgtEV( nCrv3)
|
|
vtDir2:rotate( Z_AX(), EgtIf( bSashFill, - 45, 45))
|
|
local nCrv4 = EgtLinePVL( nProcLayerId, EgtEP( nCrv3), vtDir2, 100)
|
|
|
|
-- creo fillet
|
|
local nFillet3 = EgtCurveFillet( nProcLayerId, nCrv3, EgtUP( nCrv3, 0.9), nCrv4, EgtUP( nCrv4, 0.1), dFilletRad, true) or GDB_ID.NULL
|
|
|
|
-- creo curva di lavorazione
|
|
local nMillingCrv = EgtCurveCompo( nProcLayerId, {nCrv1, nFillet1, nCrv2, nFillet2, nCrv3, nFillet3, nCrv4})
|
|
if bSashFill then
|
|
EgtInvertCurve( nMillingCrv)
|
|
end
|
|
EgtModifyCurveThickness( nMillingCrv, - dDepth)
|
|
-- setto info di lavorazione
|
|
EgtSetInfo( nMillingCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
|
EgtSetInfo( nMillingCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC)
|
|
EgtSetInfo( nMillingCrv, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.IN)
|
|
EgtTrimCurveWithRegion( nMillingCrv, nSurfGeoId, true, false)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola le lavorazioni di profiling per un pezzo di telaio con cambio profilo
|
|
local function CalcMixedFrameProfilingProcessings( nPartId, nProcLayerId, nGeoLayerId, nMainProfileId, nSurfGeoId)
|
|
|
|
-- a) lavorazioni profili
|
|
-- per le lavorazioni dei profili out, left, right e in comune si usano le corrispondenti curve del geo
|
|
local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId)
|
|
for i = 1, #vGeoCrvs - 1 do
|
|
-- copio curva
|
|
local nCrv = EgtCopyGlob( vGeoCrvs[i], nProcLayerId)
|
|
EgtModifyCurveThickness( nCrv, 0)
|
|
-- recupero il semiprofilo associato
|
|
local nSemiProfile = EgtGetInfo( nCrv, WIN_SEMI_PROFILE, 'i')
|
|
GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile)
|
|
end
|
|
|
|
-- lavorazioni dei sottotratti in di sash e fill
|
|
local nOutlinesGrp = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_OUTLINES)
|
|
local vCrvs = EgtGetAllInGroup( nOutlinesGrp)
|
|
local b3Profile = GetProfileLocalBox( nMainProfileId)
|
|
local dOffs = b3Profile:getMin():getX()
|
|
for i = #vCrvs, 1, -1 do
|
|
-- calcolo la curva di lavorazione
|
|
local nCrv = EgtCopyGlob( vCrvs[i], nProcLayerId)
|
|
EgtOffsetCurve( nCrv, dOffs)
|
|
EgtInvertCurve( nCrv)
|
|
nCrv = EgtTrimCurveWithRegion( nCrv, nSurfGeoId, true, true)
|
|
-- setto le info di lavorazione dal semiprofilo
|
|
local nSemiProfile = EgtGetFirstNameInGroup( nMainProfileId, EgtGetName( vCrvs[i]) .. WIN_IN)
|
|
GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile)
|
|
-- sistemo info di lavorazione
|
|
EgtSetInfo( nCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.MIXED)
|
|
EgtSetInfo( nCrv, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.IN)
|
|
-- TO DO : calcolo di AddLen ?
|
|
end
|
|
|
|
-- b) lavorazioni sulle intersezioni con gli split
|
|
local nIntersGrp = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_INTERSECTIONS)
|
|
local vInters = EgtGetAllInGroup( nIntersGrp)
|
|
local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
|
for i = 1, #vInters do
|
|
|
|
local bSashFill = ( EgtGetName( vCrvs[i]) == WIN_SASH)
|
|
-- recupero lo split associato e creo la curva di riferimento per le fresature
|
|
local nSplitId = EgtGetInfo( vCrvs[i], WIN_MIXED_SPLIT_REF, 'i')
|
|
local nSplitProfileId = GetOutlineProfileId( nSplitId, false)
|
|
local dRefSplit = EgtGetInfo( nSplitProfileId, WIN_SASH_REF .. '2', 'd')
|
|
local nSplitRef = EgtCopyGlob( nSplitId, nProcLayerId)
|
|
EgtOffsetCurve( nSplitRef, - dRefSplit)
|
|
|
|
-- Fresatura 1
|
|
CalcMixedFrameMilling1( vInters[i], nOutlineId, nMainProfileId, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId)
|
|
-- Fresatura 2
|
|
CalcMixedFrameMilling2( vInters[i], nOutlineId, nMainProfileId, nSplitProfileId, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId)
|
|
|
|
EgtErase( nSplitRef)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola le lavorazioni di profiling nel caso di uno split coinvolto da cambio profilo
|
|
local function CalcMixedSplitProfilingProcessings( nSplitId, nProcLayerId, nGeoLayerId)
|
|
|
|
-- a) lavorazione dei profili
|
|
local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId)
|
|
for i = 1, #vGeoCrvs - 1 do
|
|
-- copio la curva
|
|
local nCrvId = EgtCopyGlob( vGeoCrvs[i], nProcLayerId)
|
|
EgtModifyCurveThickness( nCrvId, 0)
|
|
-- recupero il semiprofilo associato ( per left e right è stato salvato il profilo di tipo sash)
|
|
local nSemiProfileId = EgtGetInfo( nCrvId, WIN_SEMI_PROFILE, 'i')
|
|
-- setto le info dal semiprofilo
|
|
GetProcessingInfoFromSemiProfile( nCrvId, nSemiProfileId)
|
|
end
|
|
|
|
-- b) tagli a 45°
|
|
-- left
|
|
local nMixedLeft = EgtGetInfo( nSplitId, WIN_MIXED_REF_START, 'i')
|
|
local nIntersLeft = EgtGetInfo( nMixedLeft, WIN_MIXED_INTERS_REF, 'i')
|
|
local nMillingLeft = EgtCopyGlob( nIntersLeft, nProcLayerId)
|
|
-- recupero profondità
|
|
local vOutlineLeft = EgtGetInfo( nSplitId, WIN_PREV_OUTLINES, 'vi')
|
|
local nProfileLeft = GetOutlineProfileId( abs( vOutlineLeft[1]), false)
|
|
local dDepthLeft = EgtGetInfo( nProfileLeft, WIN_SASH_DEPTH .. '2', 'd')
|
|
EgtModifyCurveThickness( nMillingLeft, - dDepthLeft)
|
|
-- setto info di lavorazione
|
|
EgtSetInfo( nMillingLeft, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
|
EgtSetInfo( nMillingLeft, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC)
|
|
EgtSetInfo( nMillingLeft, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.LEFT)
|
|
|
|
-- right
|
|
local nMixedRight = EgtGetInfo( nSplitId, WIN_MIXED_REF_END, 'i')
|
|
local nIntersRight = EgtGetInfo( nMixedRight, WIN_MIXED_INTERS_REF, 'i')
|
|
local nMillingRight = EgtCopyGlob( nIntersRight, nProcLayerId)
|
|
-- recupero profondità
|
|
local vOutlineRight = EgtGetInfo( nSplitId, WIN_NEXT_OUTLINES, 'vi')
|
|
local nProfileRight = GetOutlineProfileId( abs( vOutlineRight[1]), false)
|
|
local dDepthRight = EgtGetInfo( nProfileRight, WIN_SASH_DEPTH .. '2', 'd')
|
|
EgtModifyCurveThickness( nMillingRight, - dDepthRight)
|
|
EgtInvertCurve( nMillingRight)
|
|
-- setto info di lavorazione
|
|
EgtSetInfo( nMillingRight, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
|
EgtSetInfo( nMillingRight, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC)
|
|
EgtSetInfo( nMillingRight, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.RIGHT)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che aggiusta le lunghezze delle lavorazioni per garantire lavorazione completa del profilo
|
|
local function AdjustProcessingLength( nCrvId, nSemiProfileId, nGeoAreaId, nPrevGeo, nNextGeo)
|
|
|
|
-- se giunzione angled non serve allungamento
|
|
if not nSemiProfileId then return end
|
|
|
|
-- calcolo la curva di lavorazione interna
|
|
local nProfileId = EgtGetParent( nSemiProfileId)
|
|
local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frFrame = EgtFR( nFrameId, GDB_ID.ROOT)
|
|
local b3SemiProfile = EgtGetBBoxRef( nSemiProfileId, GDB_BB.STANDARD, frFrame, GDB_RT.GLOB)
|
|
local dOffs = b3SemiProfile:getDimX()
|
|
local nInnerProcId = EgtCopyGlob( nCrvId, EgtGetParent( nCrvId))
|
|
EgtOffsetCurve( nInnerProcId, - dOffs)
|
|
|
|
-- adatto la curva di lavorazione interna al pezzo
|
|
if EgtGetType( nInnerProcId) == GDB_TY.CRV_LINE then
|
|
EgtExtendCurveStartByLen( nInnerProcId, 10000)
|
|
EgtExtendCurveEndByLen( nInnerProcId, 10000)
|
|
else
|
|
local dAng = EgtArcAngCenter( nInnerProcId)
|
|
EgtModifyArcAngCenter( nInnerProcId, EgtIf( dAng > 0, 1, -1) * 360)
|
|
end
|
|
local nNewId, nCnt = EgtTrimCurveWithRegion( nInnerProcId, nGeoAreaId, true, false)
|
|
|
|
if nCnt == 0 then
|
|
return
|
|
end
|
|
|
|
if nCnt > 1 then
|
|
-- nel caso di archi possono generarsi più intersezioni quindi va conservata solo quella corretta
|
|
-- TODO può capitare anche nel caso in/out?
|
|
if AreSamePointApprox( EgtSP( nNewId), EgtEP( nNewId + nCnt - 1)) then
|
|
EgtModifyCurveStartPoint( nNewId, EgtSP( nNewId + nCnt - 1))
|
|
EgtErase( nNewId + nCnt - 1)
|
|
nCnt = nCnt - 1
|
|
end
|
|
local nPrcOutId = EgtGetFirstNameInGroup( EgtGetParent( nGeoAreaId), WIN_GEO_OUT)
|
|
local ptRef = EgtIf( EgtGetName( nCrvId) == WIN_LEFT, EgtSP( nPrcOutId), EgtEP( nPrcOutId))
|
|
local nIdRef
|
|
local dSqMinDist = GEO.INFINITO
|
|
for nId = nNewId, nNewId + nCnt - 1 do
|
|
local ptTest = EgtIf( EgtGetName( nCrvId) == WIN_LEFT, EgtEP( nId), EgtSP( nId))
|
|
local dSqDist = sqdist( ptTest, ptRef)
|
|
if dSqDist < dSqMinDist then
|
|
dSqMinDist = dSqDist
|
|
nIdRef = nId
|
|
end
|
|
end
|
|
|
|
for nId = nNewId, nNewId + nCnt - 1 do
|
|
if nId ~= nIdRef then
|
|
EgtErase( nId)
|
|
end
|
|
end
|
|
nNewId = nIdRef
|
|
end
|
|
|
|
-- la allineo alla curva di lavoro
|
|
EgtOffsetCurve( nNewId, dOffs)
|
|
|
|
-- aggiusto la curva di lavoro
|
|
local ptS = EgtSP( nNewId)
|
|
local ptE = EgtEP( nNewId)
|
|
local bExtra = EgtGetInfo( nCrvId, WIN_GEO_EXTRA, 'b') or false
|
|
if bExtra then
|
|
-- se è una curva speciale del geo va modificata su entrambi gli estremi
|
|
EgtModifyCurveStartPoint( nCrvId, ptS)
|
|
EgtModifyCurveEndPoint( nCrvId, ptE)
|
|
else
|
|
-- se è una curva standard va modificata solo in allungamento se non è in tangenza con quella vicina
|
|
local dParS = EgtCurveParamAtPoint( nCrvId, ptS)
|
|
local bTang = AreSameVectorApprox( EgtSV( nCrvId), EgtEV( nPrevGeo))
|
|
if not dParS and not bTang then
|
|
EgtModifyCurveStartPoint( nCrvId, ptS)
|
|
end
|
|
bTang = AreSameVectorApprox( EgtEV( nCrvId), EgtSV( nNextGeo))
|
|
local dParE = EgtCurveParamAtPoint( nCrvId, ptE)
|
|
if not dParE and not bTang then
|
|
EgtModifyCurveEndPoint( nCrvId, ptE)
|
|
end
|
|
end
|
|
|
|
EgtErase( nNewId)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola le lavorazioni di profiling
|
|
local function CalcProfilingProcessings( nPartId, nOutlineId)
|
|
|
|
-- creo gruppo delle lavorazioni
|
|
local nProcLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nProcLayerId, WIN_PRC)
|
|
EgtSetStatus( nProcLayerId, GDB_ST.OFF)
|
|
|
|
-- recupero il geo e creo la superficie associata per limitare le lavorazioni
|
|
local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local nSurfGeo = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_SURF)
|
|
|
|
-- recupero il gruppo dei profili
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
|
|
|
-- recupero le info di sovramateriale dal profilo
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_OVERMAT_IN, 0)
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_OVERMAT_OUT, 0)
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_OVERMAT_LEFT, 0)
|
|
CopyInfo( nPartId, nMainProfileId, WIN_PRC_OVERMAT_RIGHT, 0)
|
|
|
|
-- calcolo lavorazioni dei profili
|
|
local bChangeProfile = EgtGetInfo( nOutlineId, WIN_PRF_CHANGE, 'b') or false
|
|
if bChangeProfile then
|
|
-- 1) caso cambio profilo : telaio o split
|
|
if EgtGetName( nOutlineId) == WIN_SPLIT then
|
|
CalcMixedSplitProfilingProcessings( nOutlineId, nProcLayerId, nGeoLayerId)
|
|
else
|
|
CalcMixedFrameProfilingProcessings( nPartId, nProcLayerId, nGeoLayerId, nMainProfileId, nSurfGeo)
|
|
end
|
|
else
|
|
-- 2) caso standard
|
|
-- recupero tutte le curve del geo e le copio nel gruppo processings
|
|
local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId)
|
|
for i = 1, #vGeoCrvs - 1 do
|
|
-- copio curva
|
|
local nCrvId = EgtCopyGlob( vGeoCrvs[i], nProcLayerId)
|
|
EgtModifyCurveThickness( nCrvId, 0)
|
|
-- recupero il semiprofilo associato
|
|
local nSemiProfileId = EgtGetInfo( nCrvId, WIN_SEMI_PROFILE, 'i')
|
|
-- aggiusto la lunghezza della lavorazione
|
|
local nPrevIdx = EgtIf( i == 1, #vGeoCrvs - 1, i - 1)
|
|
local nNextIdx = EgtIf( i == #vGeoCrvs - 1, 1, i + 1)
|
|
AdjustProcessingLength( nCrvId, nSemiProfileId, nSurfGeo, vGeoCrvs[nPrevIdx], vGeoCrvs[nNextIdx])
|
|
-- setto le info dal semiprofilo
|
|
GetProcessingInfoFromSemiProfile( nCrvId, nSemiProfileId)
|
|
end
|
|
end
|
|
|
|
-- calcolo eventuali lavorazioni per strip
|
|
local vStripDist = EgtGetInfo( nMainProfileId, WIN_STRIP_DIST, 'vi') or {}
|
|
for i = 1, #vStripDist do
|
|
local nStripCut = EgtCopyGlob( nOutlineId, nProcLayerId)
|
|
EgtOffsetCurve( nStripCut, vStripDist[i])
|
|
-- modifico la curva in modo che sia a filo del geo
|
|
EgtExtendCurveStartByLen( nStripCut, 1000)
|
|
EgtExtendCurveEndByLen( nStripCut, 1000)
|
|
nStripCut = EgtTrimCurveWithRegion( nStripCut, nSurfGeo, true, false)
|
|
-- aggiusto orientamento per essere coerente con il geo corrispondente
|
|
if vStripDist[i] < 0 then
|
|
EgtInvertCurve( nStripCut)
|
|
end
|
|
-- setto info di lavorazione
|
|
EgtSetName( nStripCut, WIN_PRC_TYPE.STRIP_CUT)
|
|
EgtSetInfo( nStripCut, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.STRIP_CUT)
|
|
end
|
|
|
|
-- verifico se anta ricevente ( info necessaria per ottimizzazione lavorazioni)
|
|
local nAreaId = EgtGetParent( EgtGetParent( nOutlineId))
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
if nAreaType == WIN_AREATYPES.SASH then
|
|
local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i')
|
|
if nSashType == WIN_SASHTYPES.INACTIVE or nSashType == WIN_SASHTYPES.INACTIVE_IN then
|
|
local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i')
|
|
local bOnFrenchSplit = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b')
|
|
if bOnFrenchSplit then
|
|
EgtSetInfo( nPartId, WIN_SASHTYPE, WIN_INACTIVE)
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola gli elementi ausiliari per la creazione del grezzo nell'automatismo delle lavorazioni
|
|
local function CalcGeoRaw( nPartId)
|
|
|
|
local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local nGeoRawLayerId = EgtCopyGlob( nGeoLayerId, nPartId)
|
|
EgtErase( EgtGetLastInGroup( nGeoRawLayerId)) -- elimino la regione
|
|
EgtSetName( nGeoRawLayerId, WIN_GEO_RAW)
|
|
EgtSetStatus( nGeoRawLayerId, GDB_ST.OFF)
|
|
|
|
-- recupero i sovramateriali da applicare alle curve
|
|
local dOvermatOut = EgtGetInfo( nPartId, WIN_PRC_OVERMAT_OUT, 'd')
|
|
local dOvermatRight = EgtGetInfo( nPartId, WIN_PRC_OVERMAT_RIGHT, 'd')
|
|
local dOvermatIn = EgtGetInfo( nPartId, WIN_PRC_OVERMAT_IN, 'd')
|
|
local dOvermatLeft = EgtGetInfo( nPartId, WIN_PRC_OVERMAT_LEFT, 'd')
|
|
|
|
-- recupero le curve del raw e applico i sovramateriali
|
|
local nOut = EgtGetFirstNameInGroup( nGeoRawLayerId, WIN_GEO_OUT)
|
|
if not EgtOffsetCurve( nOut, dOvermatOut) then
|
|
EgtErase( nOut)
|
|
end
|
|
local nIn = EgtGetFirstNameInGroup( nGeoRawLayerId, WIN_GEO_IN)
|
|
if not EgtOffsetCurve( nIn, dOvermatIn) then
|
|
EgtErase( nIn)
|
|
end
|
|
local vRight = EgtGetNameInGroup( nGeoRawLayerId, WIN_GEO_RIGHT)
|
|
for i = 1, #vRight do
|
|
local bExtra = EgtGetInfo( vRight[i], WIN_GEO_EXTRA, 'b') or false
|
|
if bExtra then
|
|
EgtErase( vRight[i])
|
|
else
|
|
if not EgtOffsetCurve( vRight[i], dOvermatRight) then
|
|
EgtErase( vRight[i])
|
|
end
|
|
end
|
|
end
|
|
local vLeft = EgtGetNameInGroup( nGeoRawLayerId, WIN_GEO_LEFT)
|
|
for i = 1, #vLeft do
|
|
local bExtra = EgtGetInfo( vLeft[i], WIN_GEO_EXTRA, 'b') or false
|
|
if bExtra then
|
|
EgtErase( vLeft[i])
|
|
else
|
|
if not EgtOffsetCurve( vLeft[i], dOvermatLeft) then
|
|
EgtErase( vLeft[i])
|
|
end
|
|
end
|
|
end
|
|
|
|
-- creo la composita del grezzo a partire dalle curve
|
|
local vCrvs = EgtGetAllInGroup( nGeoRawLayerId)
|
|
vCrvs = TrimOrderedCurves( vCrvs)
|
|
local nCompo = EgtCurveCompo( nGeoRawLayerId, vCrvs)
|
|
-- aggiungo spessore
|
|
local dDimH = EgtGetInfo( nGeoLayerId, WIN_GEOHEIGHT, 'd')
|
|
EgtModifyCurveThickness( nCompo, - dDimH)
|
|
|
|
-- creo frame ausiliario
|
|
local vtX = EgtSV( nCompo)
|
|
local frGeo = Frame3d( EgtSP( nCompo), vtX, Z_AX() ^ vtX, Z_AX())
|
|
local nFrameId = EgtFrame( nGeoRawLayerId, frGeo)
|
|
EgtSetName( nFrameId, WIN_PRC_FRAME)
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
---------------------------------- SOLIDO ----------------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che crea la superficie di trim per il solido
|
|
local function CreateTrimSurf( nGeoId, nOutlineId, dGeoWidth, nLayerId)
|
|
|
|
-- recupero profilo di riferimento dalla curva geo
|
|
local nOrigTrimProfileId = EgtGetInfo( nGeoId, WIN_SEMI_PROFILE, 'i')
|
|
|
|
-- 1) minizinken
|
|
if not nOrigTrimProfileId then
|
|
|
|
local nGuideId = EgtCopy( nGeoId, nLayerId)
|
|
EgtExtendCurveStartByLen( nGuideId, 4 * dGeoWidth)
|
|
EgtExtendCurveEndByLen( nGuideId, 4 * dGeoWidth)
|
|
EgtMove( nGuideId, Z_AX())
|
|
local nTrimSurf = EgtSurfTmByExtrusion( nLayerId, nGuideId, - Z_AX() * dGeoWidth * 2, WIN_SURF_APPROX)
|
|
EgtInvertSurf( nTrimSurf)
|
|
EgtErase( nGuideId)
|
|
return nTrimSurf
|
|
|
|
-- 2) controprofilo
|
|
else
|
|
-- recupero il controprofilo da estrudere
|
|
local sTrimProfileName = EgtGetName( nOrigTrimProfileId)
|
|
sTrimProfileName = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_OFST .. sTrimProfileName
|
|
-- calcolo la superficie di estrusione
|
|
return CreateProfileSurf( nOutlineId, EgtGetParent( nOrigTrimProfileId), sTrimProfileName, 4 * dGeoWidth, nLayerId)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea le superfici di trim per uno split coinvolto da cambio profilo ( controprofilo della parte sash del telaio e taglio a 45°)
|
|
local function CreateMixedSplitTrimSurf( nMixedOutlineId, nProfileId, dExtraLen, nLayerId)
|
|
|
|
-- estrudo il controprofilo di tipo sash
|
|
local nPartId = EgtGetParent( EgtGetParent( nMixedOutlineId))
|
|
local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
|
local sTrimProfile = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_OFST .. WIN_SASH .. WIN_CTRIN
|
|
local nTrimStmId = CreateProfileSurf( nOutlineId, nProfileId, sTrimProfile, dExtraLen, nLayerId)
|
|
|
|
-- creo il solido da intersecare con il controprofilo per il taglio a 45°
|
|
local nIntersCrvId = EgtGetInfo( nMixedOutlineId, WIN_MIXED_INTERS_REF, 'i')
|
|
local nGuideId = EgtCopyGlob( nIntersCrvId, nLayerId)
|
|
local bSashFill = ( EgtGetName( nMixedOutlineId) ~= WIN_SASH)
|
|
local vtDirH = EgtSV( nGuideId)
|
|
vtDirH:rotate( Z_AX(), EgtIf( bSashFill, -135, 135))
|
|
local vtDirV = EgtSV( nGuideId)
|
|
vtDirV:rotate( Z_AX(), EgtIf( bSashFill, -45, 45))
|
|
EgtAddCurveCompoLine( nGuideId, EgtEP( nGuideId) + dExtraLen * vtDirV)
|
|
EgtAddCurveCompoLine( nGuideId, EgtSP( nGuideId) + dExtraLen * vtDirH, false)
|
|
EgtAddCurveCompoLine( nGuideId, EgtSP( nGuideId) + dExtraLen * vtDirV, false)
|
|
EgtCloseCurveCompo( nGuideId)
|
|
EgtMove( nGuideId, 0.01 * Z_AX())
|
|
if bSashFill then
|
|
EgtInvertCurve( nGuideId)
|
|
end
|
|
local dDepth = EgtGetInfo( nProfileId, WIN_SASH_DEPTH .. '2', 'd')
|
|
local nCutStmId = EgtSurfTmByRegionExtrusion( nLayerId, nGuideId, - ( dDepth + 2) * Z_AX())
|
|
|
|
-- creo una superficie di trim unica
|
|
EgtSurfTmSubtract( nTrimStmId, nCutStmId)
|
|
|
|
EgtErase( { nGuideId, nCutStmId})
|
|
|
|
return nTrimStmId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea il solido di estrusione principale
|
|
local function CreateMainSurf( nOutlineId, dExtraLen, nProfileId, sSectionName, nLayerId)
|
|
|
|
-- curva guida
|
|
local nGuideId = EgtCopy( nOutlineId, nLayerId)
|
|
EgtSetName( nGuideId, WIN_MAINGUIDE)
|
|
EgtSetStatus( nGuideId, GDB_ST.OFF)
|
|
EgtExtendCurveStartByLen( nGuideId, dExtraLen)
|
|
EgtExtendCurveEndByLen( nGuideId, dExtraLen)
|
|
|
|
-- se bottomrail sposto opportunamente l'outline
|
|
local sProfileType = EgtGetInfo( nProfileId, WIN_PRF_TYPE)
|
|
if sProfileType == WIN_RAIL or sProfileType == WIN_FILL_RAIL then
|
|
local dOffs = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd')
|
|
EgtOffsetCurve( nGuideId, -dOffs)
|
|
end
|
|
|
|
-- posiziono il profilo sulla curva guida :
|
|
-- recupero il frame del profilo
|
|
local nProfileFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frInvert = EgtFR( nProfileFrameId)
|
|
frInvert:invert()
|
|
-- lo applico a tutte le geometrie del profilo
|
|
EgtTransform( EgtGetAllInGroup( nProfileId), frInvert)
|
|
-- assegno come riferimento del profilo il punto start dell'outline
|
|
EgtChangeGroupFrame( nProfileId, Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId)))
|
|
|
|
-- recupero outline del profilo Main e lo estrudo
|
|
local nSectionId = EgtGetFirstNameInGroup( nProfileId, sSectionName)
|
|
local nMainExtrusionId = EgtSurfTmSwept( nLayerId, nSectionId, nGuideId, false, WIN_SURF_APPROX)
|
|
EgtSetName( nMainExtrusionId, WIN_SRF_MAIN)
|
|
|
|
return nMainExtrusionId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea il solido di un pezzo di telaio con cambio profilo
|
|
local function CalcMixedFrameSolid( nOutlineId, nSolidLayerId, nProfileLayerId, nGeoLayerId, dGeoWidth)
|
|
|
|
-- a) SOLIDO PRINCIPALE
|
|
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
|
-- creo i solidi corrispondenti ai diversi sottotratti uniformi del pezzo
|
|
local nMixedOutlinesGrp = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_MIXED_OUTLINES)
|
|
local vMixedOutlines = EgtGetAllInGroup( nMixedOutlinesGrp)
|
|
local vMainExtrusions = {}
|
|
for i = 1, #vMixedOutlines do
|
|
local sSection = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. EgtGetName( vMixedOutlines[i]) .. WIN_SECTION
|
|
local nMainExtrusionId = CreateMainSurf( vMixedOutlines[i], 2 * dGeoWidth, nMainProfileId, sSection, nSolidLayerId)
|
|
table.insert( vMainExtrusions, nMainExtrusionId)
|
|
end
|
|
|
|
-- taglio i sottopezzi nei punti di intersezione per unirli
|
|
local nMixedIntersectionsGrp = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_MIXED_INTERSECTIONS)
|
|
local vIntersections = EgtGetAllInGroup( nMixedIntersectionsGrp)
|
|
for i = 1, #vIntersections do
|
|
-- creo la superficie di separazione tra i due sottopezzi
|
|
local bSashFill = ( EgtGetName( vMixedOutlines[i]) == WIN_SASH)
|
|
local vtDirS = EgtSV( vIntersections[i])
|
|
vtDirS:rotate( Z_AX(), EgtIf( bSashFill, -135, 135))
|
|
local vtDirE = EgtSV( vIntersections[i])
|
|
vtDirE:rotate( Z_AX(), EgtIf( bSashFill, 45, -45))
|
|
local nCrvTrim = EgtCurveCompo( nSolidLayerId, vIntersections[i], false)
|
|
EgtAddCurveCompoLine( nCrvTrim, EgtSP( nCrvTrim) + dGeoWidth * vtDirS, false)
|
|
EgtAddCurveCompoLine( nCrvTrim, EgtEP( nCrvTrim) + dGeoWidth * vtDirE)
|
|
EgtMove( nCrvTrim, Z_AX())
|
|
local nStmTrim = EgtSurfTmByExtrusion( nSolidLayerId, nCrvTrim, - 2 * dGeoWidth * Z_AX())
|
|
|
|
-- taglio i due sottopezzi
|
|
EgtSurfTmSubtract( vMainExtrusions[i+1], nStmTrim)
|
|
EgtInvertSurf( nStmTrim)
|
|
EgtSurfTmSubtract( vMainExtrusions[i], nStmTrim)
|
|
|
|
EgtErase( nCrvTrim)
|
|
EgtErase( nStmTrim)
|
|
end
|
|
|
|
-- unisco i sottopezzi in una sola superficie
|
|
for i = 2, #vMainExtrusions do
|
|
EgtSurfTmAdd( vMainExtrusions[1], vMainExtrusions[i])
|
|
EgtErase( vMainExtrusions[i])
|
|
end
|
|
|
|
-- creo una copia dell'estrusione principale ( usata per ferramenta)
|
|
local nOrigMainExtrusionId = EgtCopy( vMainExtrusions[1], nSolidLayerId)
|
|
EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN)
|
|
EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF)
|
|
|
|
-- come guida tengo solo una copia della curva di outline
|
|
local vMainGuideIds = EgtGetNameInGroup( nSolidLayerId, WIN_MAINGUIDE)
|
|
EgtErase( vMainGuideIds)
|
|
local nMainGuideId = EgtCopyGlob( nOutlineId, nSolidLayerId)
|
|
EgtSetName( nMainGuideId, WIN_MAINGUIDE)
|
|
EgtSetStatus( nMainGuideId, GDB_ST.OFF)
|
|
|
|
-- b) TRIM START
|
|
local nPrevGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
|
|
local nStartOutlineId = EgtGetInfo( nPrevGeoId, WIN_REF_OUTLINE, 'i')
|
|
local nTrimSurfStart = CreateTrimSurf( nPrevGeoId, nStartOutlineId, dGeoWidth, nSolidLayerId)
|
|
EgtSetStatus( nTrimSurfStart, GDB_ST.OFF)
|
|
EgtSurfTmIntersect( vMainExtrusions[1], nTrimSurfStart)
|
|
EgtSetInfo( nPrevGeoId, WIN_REF_SURF, nTrimSurfStart)
|
|
|
|
-- c) TRIM END
|
|
local nNextGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
|
|
local nEndOutlineId = EgtGetInfo( nNextGeoId, WIN_REF_OUTLINE, 'i')
|
|
local nTrimSurfEnd = CreateTrimSurf( nNextGeoId, nEndOutlineId, dGeoWidth, nSolidLayerId)
|
|
EgtSetStatus( nTrimSurfEnd, GDB_ST.OFF)
|
|
EgtSurfTmIntersect( vMainExtrusions[1], nTrimSurfEnd)
|
|
EgtSetInfo( nNextGeoId, WIN_REF_SURF, nTrimSurfEnd)
|
|
|
|
return vMainExtrusions[1]
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea il solido di un pezzo di split coinvolto da cambio profilo
|
|
local function CalcMixedSplitSolid( nOutlineId, nSolidLayerId, nProfileLayerId, dGeoWidth)
|
|
|
|
-- a) creo il solido di estrusione principale
|
|
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
|
local sSection = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_SECTION
|
|
local nMainExtrusionId = CreateMainSurf( nOutlineId, 2 * dGeoWidth, nMainProfileId, sSection, nSolidLayerId)
|
|
-- creo una copia
|
|
local nOrigMainExtrusionId = EgtCopy( nMainExtrusionId, nSolidLayerId)
|
|
EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN)
|
|
EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF)
|
|
|
|
-- b) trim start
|
|
local nPrevProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_START)
|
|
local nPrevMixedOutline = EgtGetInfo( nOutlineId, WIN_MIXED_REF_START, 'i')
|
|
local nStmTrimStart = CreateMixedSplitTrimSurf( nPrevMixedOutline, nPrevProfileId, dGeoWidth, nSolidLayerId)
|
|
EgtSetStatus( nStmTrimStart, GDB_ST.OFF)
|
|
EgtSurfTmIntersect( nMainExtrusionId, nStmTrimStart)
|
|
local nGeoLayerId = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_GEO)
|
|
local nPrevGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
|
|
EgtSetInfo( nPrevGeoId, WIN_REF_SURF, nStmTrimStart)
|
|
|
|
-- c) trim end
|
|
local nNextProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END)
|
|
local nNextMixedOutline = EgtGetInfo( nOutlineId, WIN_MIXED_REF_END, 'i')
|
|
local nStmTrimEnd = CreateMixedSplitTrimSurf( nNextMixedOutline, nNextProfileId, dGeoWidth, nSolidLayerId)
|
|
EgtSetStatus( nStmTrimEnd, GDB_ST.OFF)
|
|
EgtSurfTmIntersect( nMainExtrusionId, nStmTrimEnd)
|
|
local nNextGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
|
|
EgtSetInfo( nNextGeoId, WIN_REF_SURF, nStmTrimEnd)
|
|
|
|
return nMainExtrusionId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che verifica se due curve del geo sono concatenabili, ovvero se hanno lo stesso profilo e i corrispondenti outline coincidono o sono in tangenza
|
|
local function CheckChainability( nGeoCrv1, nGeoCrv2)
|
|
|
|
-- verifico profili
|
|
local sProfile1 = EgtGetInfo( nGeoCrv1, WIN_PROFILETYPE)
|
|
local sProfile2 = EgtGetInfo( nGeoCrv2, WIN_PROFILETYPE)
|
|
local nSemiProfileId1 = EgtGetInfo( nGeoCrv1, WIN_SEMI_PROFILE, 'i')
|
|
local nSemiProfileId2 = EgtGetInfo( nGeoCrv2, WIN_SEMI_PROFILE, 'i')
|
|
if sProfile1 == sProfile2 and nSemiProfileId1 and nSemiProfileId2 and EgtGetName( nSemiProfileId1) == EgtGetName( nSemiProfileId2) then
|
|
-- verifico outlines
|
|
local nRefOutline1 = EgtGetInfo( nGeoCrv1, WIN_REF_OUTLINE, 'i')
|
|
local nRefOutline2 = EgtGetInfo( nGeoCrv2, WIN_REF_OUTLINE, 'i')
|
|
if nRefOutline1 == nRefOutline2 or AreSameVectorApprox( EgtEV( nRefOutline1), EgtSV( nRefOutline2)) then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea il solido del pezzo
|
|
local function CalcSolid( nPartId, nOutlineId)
|
|
|
|
-- creo layer per solido
|
|
local nSolidLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nSolidLayerId, WIN_SOLID)
|
|
|
|
-- recupero profilo principale
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
|
|
-- recupero geo e la sua larghezza
|
|
local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local dGeoWidth = EgtGetInfo( nGeoLayerId, WIN_GEOWIDTH, 'd')
|
|
|
|
-- gestione speciale per pezzi con CAMBIO PROFILO
|
|
local bChangeProfile = EgtGetInfo( nOutlineId, WIN_PRF_CHANGE, 'b') or false
|
|
if bChangeProfile then
|
|
if EgtGetName( nOutlineId) == WIN_SPLIT then
|
|
return CalcMixedSplitSolid( nOutlineId, nSolidLayerId, nProfileLayerId, dGeoWidth)
|
|
else
|
|
return CalcMixedFrameSolid( nOutlineId, nSolidLayerId, nProfileLayerId, nGeoLayerId, dGeoWidth)
|
|
end
|
|
end
|
|
|
|
-- a) creo il solido di estrusione principale
|
|
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
|
local sSection = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_SECTION
|
|
local nMainExtrusionId = CreateMainSurf( nOutlineId, 4 * dGeoWidth, nMainProfileId, sSection, nSolidLayerId)
|
|
-- creo una copia ( usata per calcolo ferramenta)
|
|
local nOrigMainExtrusionId = EgtCopy( nMainExtrusionId, nSolidLayerId)
|
|
EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN)
|
|
EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF)
|
|
|
|
-- b) trim con i controprofili su start e su end
|
|
local vGeoId = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
|
|
local vPrevGeoId = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
|
|
EgtJoinTables( vGeoId, vPrevGeoId)
|
|
-- verifico quali curve di trim conviene concatenare per evitare booleane problematiche con tratti sovrapposti
|
|
local vChains = {{ vGeoId[1]}}
|
|
for i = 2, #vGeoId do
|
|
if CheckChainability( vGeoId[i-1], vGeoId[i]) then
|
|
-- aggiugno alla catena corrente
|
|
table.insert( vChains[#vChains], vGeoId[i])
|
|
else
|
|
-- creo una nuova catena
|
|
table.insert( vChains, { vGeoId[i]})
|
|
end
|
|
end
|
|
|
|
-- calcolo le superfici di trim
|
|
for i = 1, #vChains do
|
|
local nTrimSurf
|
|
if #vChains[i] == 1 then
|
|
local nRefOutlineId = EgtGetInfo( vChains[i][1], WIN_REF_OUTLINE, 'i')
|
|
nTrimSurf = CreateTrimSurf( vChains[i][1], abs( nRefOutlineId), dGeoWidth, nSolidLayerId)
|
|
-- assegno alla curva del geo la superficie di trim creata
|
|
EgtSetInfo( vChains[i][1], WIN_REF_SURF, nTrimSurf)
|
|
else
|
|
-- costruisco la guida a partire dagli outlines
|
|
local vRefOutlineIds = {}
|
|
for j = 1, #vChains[i] do
|
|
local nCurrOutline = EgtGetInfo( vChains[i][j], WIN_REF_OUTLINE, 'i')
|
|
-- verifico di non inserire un outline doppio
|
|
if j == 1 or nCurrOutline ~= vRefOutlineIds[#vRefOutlineIds] then
|
|
table.insert( vRefOutlineIds, abs( nCurrOutline))
|
|
end
|
|
end
|
|
local nGuideId = EgtCurveCompo( nSolidLayerId, vRefOutlineIds, false)
|
|
nTrimSurf = CreateTrimSurf( vChains[i][1], nGuideId, dGeoWidth, nSolidLayerId)
|
|
-- assegno ad ogni curva del geo la superficie di trim creata
|
|
for j = 1, #vChains[i] do
|
|
EgtSetInfo( vChains[i][j], WIN_REF_SURF, nTrimSurf)
|
|
end
|
|
EgtErase( nGuideId)
|
|
end
|
|
|
|
EgtSetStatus( nTrimSurf, GDB_ST.OFF)
|
|
EgtSurfTmIntersect( nMainExtrusionId, nTrimSurf)
|
|
end
|
|
|
|
return nMainExtrusionId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea il solido del Fill
|
|
local function CalcFillSolid( nPartId, nGeoLayerId)
|
|
-- creo layer per solido
|
|
local nSolidLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nSolidLayerId, WIN_SOLID)
|
|
-- creo compo dalle curve del geo
|
|
local vGeoList = EgtGetAllInGroup( nGeoLayerId)
|
|
local nCompoOutlineId = EgtCurveCompo( nSolidLayerId, vGeoList, false)
|
|
-- recupero spessore vetro
|
|
local dGlassThickness = EgtGetInfo( nGeoLayerId, WIN_GLASSTHICKNESS, 'd')
|
|
local nSurfId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nCompoOutlineId, Z_AX() * dGlassThickness)
|
|
EgtErase( nCompoOutlineId)
|
|
end
|
|
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che aggiorna il solido principale con quello associato ad una lavorazione partendo dalla sua curva
|
|
local function UpdateSolidWithProcessingSurf( nProcId, nSolidId, nLayerId)
|
|
|
|
if not EgtCurveIsClosed( nProcId) then
|
|
return
|
|
end
|
|
|
|
local vtExtr = EgtCurveExtrusion( nProcId)
|
|
local dThick = EgtCurveThickness( nProcId)
|
|
local nRefCrv = nProcId
|
|
-- se solidi semplificati approssimo in modo grossolano per velocizzare operazioni di subtract ( soprattuto su archi)
|
|
if s_bSimplSolid then
|
|
nRefCrv = EgtCopyGlob( nProcId, nLayerId)
|
|
EgtApproxCurve( nRefCrv, GDB_CA.LINES, s_dSimplSolidApprox)
|
|
end
|
|
local nProcSolidId = EgtSurfTmByRegionExtrusion( nLayerId, nRefCrv, dThick * vtExtr)
|
|
|
|
-- sottraggo al solido
|
|
EgtSurfTmSubtract( nSolidId, nProcSolidId)
|
|
|
|
EgtErase( nProcSolidId)
|
|
if s_bSimplSolid then
|
|
EgtErase( nRefCrv)
|
|
end
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
---------------------------------- DOWELS ----------------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che recupera la lunghezza del dowel
|
|
local function CalcDowelLen( nDowelId, sKey, bFullOrShort)
|
|
|
|
local sDefaultKey = EgtIf( bFullOrShort, WIN_DWL_TOP_PERP_LEN, WIN_DWL_TOP_PARA_LEN)
|
|
local dLen = EgtGetInfo( nDowelId, sKey, 'd') or EgtGetInfo( nDowelId, sDefaultKey, 'd')
|
|
dLen = dLen + s_dDowelTol
|
|
return dLen
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola il riferimento dove posizionare i dowels
|
|
local function CreateDowelFrameDest( nRefProfileType, nPrevGeo, nGeo, nRefOutline, bCurrFullOrShort, bSashOrFrame)
|
|
|
|
-- 1) la direzione z è determinata dal pezzo short
|
|
local vtZ
|
|
if EgtGetType( nRefOutline) == GDB_TY.CRV_LINE then
|
|
vtZ = EgtEV( nRefOutline)
|
|
else
|
|
-- se pezzo ad arco, recupero la direzione dalla curva nel punto estremo del geo
|
|
local nGeoRefCrv
|
|
if bCurrFullOrShort then
|
|
nGeoRefCrv = EgtGetFirstNameInGroup( nPrevGeo, WIN_RIGHT)
|
|
else
|
|
nGeoRefCrv = EgtGetFirstNameInGroup( nGeo, WIN_LEFT)
|
|
end
|
|
local ptInt = EgtIP( nGeoRefCrv, nRefOutline, ORIG())
|
|
local dPar = EgtCurveParamAtPoint( nRefOutline, ptInt, 100 * GEO.EPS_SMALL)
|
|
vtZ = EgtUV( nRefOutline, dPar, -1)
|
|
end
|
|
|
|
local frDest = Frame3d( ORIG(), - vtZ)
|
|
|
|
-- 2) punto di origine
|
|
local nPrevRight = EgtGetFirstNameInGroup( nPrevGeo, WIN_GEO_RIGHT)
|
|
local ptRef1 = EgtIf( bCurrFullOrShort, EgtSP( nPrevRight), EgtEP( nPrevRight))
|
|
local nLeft = EgtGetFirstNameInGroup( nGeo, WIN_GEO_LEFT)
|
|
local ptRef2 = EgtIf( bCurrFullOrShort, EgtSP( nLeft), EgtEP( nLeft))
|
|
-- riporto i punti sulla curva di outline su cui va posizionato il profilo con le spine
|
|
local _, ptInt1 = EgtPointCurveDist( ptRef1, nRefOutline)
|
|
local _, ptInt2 = EgtPointCurveDist( ptRef2, nRefOutline)
|
|
|
|
-- nel caso di telaio conviene tenere il punto più "interno" visto che la correzione sarà fatta verso l'esterno
|
|
-- nel caso di anta conviene tenere quello più "esterno" visto che la correzione sarà fatta verso l'interno
|
|
ptInt1:toLoc( frDest)
|
|
ptInt2:toLoc( frDest)
|
|
local ptInt
|
|
if ptInt1:getX() > ptInt2:getX() then
|
|
ptInt = EgtIf( bSashOrFrame, Point3d( ptInt1), Point3d( ptInt2))
|
|
else
|
|
ptInt = EgtIf( bSashOrFrame, Point3d( ptInt2), Point3d( ptInt1))
|
|
end
|
|
ptInt:toGlob( frDest)
|
|
|
|
-- modifico il punto di origine del frame nel punto individuato
|
|
frDest:move( ptInt - ORIG())
|
|
|
|
return frDest
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che posiziona il dowel tramite i riferimenti
|
|
local function PositionDowel( nDowelId, frOrig, frDest, vtDir, nSurfId)
|
|
|
|
-- posiziono il dowel utilizzando i riferimenti
|
|
EgtTransform( nDowelId, frOrig, GDB_RT.GLOB)
|
|
EgtTransform( nDowelId, frDest, GDB_RT.GLOB)
|
|
EgtMove( nDowelId, 300 * vtDir)
|
|
-- creo il tool corrispondente al dowel
|
|
local dRad = EgtArcRadius( nDowelId)
|
|
|
|
EgtCAvSetStdTool( s_dDowelTol, 2 * dRad, 0)
|
|
-- calcolo spostamento per posizionarlo in corrispondenza della superficie
|
|
local dStart = EgtCAvToolPosStm( EgtCP( nDowelId), - vtDir, nSurfId, - vtDir)
|
|
EgtMove( nDowelId, - dStart * vtDir)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea il dowel e lo sottrae al solido
|
|
local function CreateDowel( nOrigDowelId, nLayerId, frOrig, frDest, vtDir, nTestSurfId, dLen, sDowelSide, nMainExtrusionId)
|
|
|
|
-- vtDir rivolta verso interno del pezzo
|
|
|
|
local nDowelId = EgtCopyGlob( nOrigDowelId, nLayerId)
|
|
EgtSetColor( nDowelId, Color3d( 128, 128, 128))
|
|
|
|
-- posiziono il dowel
|
|
PositionDowel( nDowelId, frOrig, frDest, vtDir, nTestSurfId)
|
|
|
|
-- assegno estrusione e spessore
|
|
EgtModifyCurveExtrusion( nDowelId, - vtDir)
|
|
EgtModifyCurveThickness( nDowelId, - dLen)
|
|
|
|
-- setto info di lavorazione
|
|
EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE)
|
|
EgtSetInfo( nDowelId, WIN_PRC_SIDE, sDowelSide)
|
|
|
|
-- eventuale aggiornamento del solido
|
|
if nMainExtrusionId then
|
|
UpdateSolidWithProcessingSurf( nDowelId, nMainExtrusionId, nLayerId)
|
|
end
|
|
|
|
return nDowelId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola la correzione da applicare al frame dei dowels per evitare che fuoriescano dal pezzo da un lato visibile ( esterno per ante ed interno per telaio)
|
|
local function CalcDowelFrameCorrection( nOutlineId, nPrevOutlineId, nDowelRef, frOrig, frDest, nTestSurfPos, nTestSurfPosPrev, nTestSurf, vtMove, nLayerId, dLen, dPrevLen)
|
|
|
|
local dMove = 0
|
|
-- se le curve sono due linee non serve correzione
|
|
if EgtGetType( nOutlineId) == GDB_TY.CRV_LINE and EgtGetType( nPrevOutlineId) == GDB_TY.CRV_LINE then
|
|
return dMove
|
|
end
|
|
|
|
-- 1) verifico posizione per il pezzo corrente
|
|
-- posiziono il dowel
|
|
local nDowel1 = EgtCopyGlob( nDowelRef, nLayerId)
|
|
PositionDowel( nDowel1, frOrig, frDest, - frDest:getVersZ(), nTestSurfPos)
|
|
-- verifico se la faccia di fondo fuoriesce dalla superficie di test
|
|
local dMove1 = EgtCAvToolPosStm( EgtCP( nDowel1) - frDest:getVersZ() * dLen, frDest:getVersZ(), nTestSurf, vtMove)
|
|
|
|
-- 2) verifico posizione per il pezzo precedente
|
|
-- posiziono il dowel
|
|
local nDowel2 = EgtCopyGlob( nDowelRef, nLayerId)
|
|
PositionDowel( nDowel2, frOrig, frDest, frDest:getVersZ(), nTestSurfPosPrev)
|
|
-- verifico se la faccia di fondo fuoriesce dalla superficie di test
|
|
local dMove2 = EgtCAvToolPosStm( EgtCP( nDowel2) + frDest:getVersZ() * dPrevLen, - frDest:getVersZ(), nTestSurf, vtMove)
|
|
|
|
EgtErase( nDowel1)
|
|
EgtErase( nDowel2)
|
|
|
|
-- calcolo la correzione complessiva
|
|
dMove = max( dMove1, dMove2) + s_dDowelTol
|
|
return dMove
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola i dowels tra due pezzi
|
|
local function CalcDowels( nOrigOutlineId, nOrigPrevOutlineId, bSashOrFrame, nBottomRail)
|
|
|
|
-- se soglia non ci sono dowels
|
|
if EgtGetInfo( nOrigOutlineId, WIN_THRESHOLD, 'b') or EgtGetInfo( nOrigPrevOutlineId, WIN_THRESHOLD, 'b') then
|
|
return
|
|
end
|
|
|
|
-- recupero i pezzi
|
|
local nPart = EgtGetInfo( nOrigOutlineId, WIN_REF_PART, 'i')
|
|
local nPrevPart = EgtGetInfo( nOrigPrevOutlineId, WIN_REF_PART, 'i')
|
|
if nBottomRail then
|
|
if EgtGetName( nOrigOutlineId) == WIN_BOTTOM then
|
|
local vParts = EgtGetInfo( nOrigOutlineId, WIN_REF_BOTTOMRAIL_PART, 'vi')
|
|
nPart = vParts[nBottomRail]
|
|
else
|
|
local vParts = EgtGetInfo( nOrigPrevOutlineId, WIN_REF_BOTTOMRAIL_PART, 'vi')
|
|
nPrevPart = vParts[nBottomRail]
|
|
end
|
|
end
|
|
|
|
-- recupero i layer delle lavorazioni
|
|
local nLayerId = EgtGetFirstNameInGroup( nPart, WIN_PRC)
|
|
local nPrevLayerId = EgtGetFirstNameInGroup( nPrevPart, WIN_PRC)
|
|
|
|
-- recupero i profili
|
|
local nProfileLay = EgtGetFirstNameInGroup( nPart, WIN_PROFILE)
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileLay, WIN_PRF_MAIN)
|
|
local nPrevProfileLay = EgtGetFirstNameInGroup( nPrevPart, WIN_PROFILE)
|
|
local nPrevProfileId = EgtGetFirstNameInGroup( nPrevProfileLay, WIN_PRF_MAIN)
|
|
|
|
-- copio curve outlines
|
|
local nOutlineId = EgtCopyGlob( nOrigOutlineId, nLayerId)
|
|
local nPrevOutlineId = EgtCopyGlob( nOrigPrevOutlineId, nLayerId)
|
|
if nBottomRail then
|
|
-- eventuale offset per bottomrail
|
|
local dOffs
|
|
local nRefCrv
|
|
if EgtGetName( nOutlineId) == WIN_BOTTOM then
|
|
nRefCrv = nOutlineId
|
|
dOffs = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd')
|
|
else
|
|
nRefCrv = nPrevOutlineId
|
|
dOffs = EgtGetInfo( nPrevProfileId, WIN_RAILDELTA, 'd')
|
|
end
|
|
EgtOffsetCurve( nRefCrv, - dOffs)
|
|
end
|
|
|
|
-- recupero i geo
|
|
local nGeo = EgtGetFirstNameInGroup( nPart, WIN_GEO)
|
|
local nPrevGeo = EgtGetFirstNameInGroup( nPrevPart, WIN_GEO)
|
|
|
|
-- recupero i tipi di profilo
|
|
local nPrevProfileType = GetOutlineProfileType( nPrevOutlineId, false, nBottomRail)
|
|
local nProfileType = GetOutlineProfileType( nOutlineId, false, nBottomRail)
|
|
-- caso particolare del triangolo : se lato top contro bottom il top deve essere gestito come un left/right
|
|
if nProfileType == WIN_PRF.TOP and nPrevProfileType == WIN_PRF.BOTTOM then
|
|
nProfileType = WIN_PRF.RIGHT
|
|
elseif nProfileType == WIN_PRF.BOTTOM and nPrevProfileType == WIN_PRF.TOP then
|
|
nPrevProfileType = WIN_PRF.LEFT
|
|
end
|
|
|
|
-- recupero i solidi
|
|
local nPrevSolidId, nSolidId, nPrevSolidLay, nSolidLay
|
|
if s_bCalcSolid then
|
|
nSolidLay = EgtGetFirstNameInGroup( nPart, WIN_SOLID)
|
|
nSolidId = EgtGetFirstNameInGroup( nSolidLay, WIN_SRF_MAIN)
|
|
nPrevSolidLay = EgtGetFirstNameInGroup( nPrevPart, WIN_SOLID)
|
|
nPrevSolidId = EgtGetFirstNameInGroup( nPrevSolidLay, WIN_SRF_MAIN)
|
|
end
|
|
|
|
-- recupero il tipo di giunzione
|
|
local nJointType = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'i')
|
|
if nBottomRail then
|
|
if EgtGetName( nOutlineId) == WIN_BOTTOM then
|
|
nJointType = WIN_PART_JNT.SHORT
|
|
else
|
|
nJointType = WIN_PART_JNT.FULL
|
|
end
|
|
end
|
|
|
|
if nJointType == WIN_PART_JNT.ANGLED then
|
|
-- TO DO
|
|
|
|
elseif nJointType == WIN_PART_JNT.FULL then
|
|
|
|
-- calcolo il riferimento del profilo
|
|
local nFrameProfile = EgtGetFirstNameInGroup( nPrevProfileId, WIN_SECTIONFRAME)
|
|
local frOrig = EgtFR( nFrameProfile, GDB_ID.ROOT)
|
|
frOrig:invert()
|
|
|
|
-- calcolo il riferimento su cui posizionare i dowels
|
|
local frDest = CreateDowelFrameDest( nPrevProfileType, nPrevGeo, nGeo, nPrevOutlineId, true, bSashOrFrame)
|
|
|
|
-- recupero info con la lunghezza ( dipendono dal profilo del pezzo full quindi dal corrente)
|
|
local sLenKey = WIN_DWL_TOP_PERP_LEN
|
|
local sPrevLenKey = WIN_DWL_TOP_PARA_LEN
|
|
if nProfileType == WIN_PRF.BOTTOM then
|
|
sLenKey = WIN_DWL_BOTTOM_PERP_LEN
|
|
sPrevLenKey = WIN_DWL_BOTTOM_PARA_LEN
|
|
elseif EgtExistsInfo( nPart, WIN_SASHTYPE) then
|
|
-- verifico se è inactive sash dalla info settata per lavorazione
|
|
sLenKey = WIN_DWL_INACTIVE_PERP_LEN
|
|
sPrevLenKey = WIN_DWL_INACTIVE_PARA_LEN
|
|
end
|
|
|
|
-- superficie test per il posizionamento dei dowels : è la superficie in del pezzo full
|
|
local nTestSurf
|
|
if not s_bCalcSolid or s_bSimplSolid then
|
|
local sCtrIn = WIN_OFST .. GetProfileCtrIn( nOrigOutlineId, nPrevOutlineId, nProfileId) -- controprofilo in del pezzo corrente
|
|
nTestSurf = CreateProfileSurf( nOrigOutlineId, nProfileId, sCtrIn, 100, nLayerId)
|
|
else
|
|
-- è la superficie che viene utilizzata per trimmare l'end del pezzo prev
|
|
local nGeoCrv = EgtGetFirstNameInGroup( nPrevGeo, WIN_GEO_RIGHT)
|
|
local nOrigSurf = EgtGetInfo( nGeoCrv, WIN_REF_SURF, 'i')
|
|
nTestSurf = EgtCopyGlob( nOrigSurf, nLayerId)
|
|
end
|
|
local nTestSurfInverted = EgtCopyGlob( nTestSurf, nLayerId)
|
|
EgtInvertSurf( nTestSurfInverted)
|
|
|
|
-- superficie test per la traslazione dei dowels
|
|
local nTestSurf2
|
|
if bSashOrFrame then
|
|
-- se anta la superficie da cui non fuoriuscire è quella esterna del pezzo short, ovvero la superficie usata per trimmare lo start del pezzo corrente
|
|
if not s_bCalcSolid or s_bSimplSolid then
|
|
nTestSurf2 = CreateProfileSurf( nOrigPrevOutlineId, nPrevProfileId, WIN_OFST .. WIN_OUT, 100, nLayerId)
|
|
else
|
|
local nGeoCrv = EgtGetFirstNameInGroup( nGeo, WIN_GEO_LEFT)
|
|
local nOrigSurf = EgtGetInfo( nGeoCrv, WIN_REF_SURF, 'i')
|
|
nTestSurf2 = EgtCopyGlob( nOrigSurf, nLayerId)
|
|
end
|
|
EgtInvertSurf( nTestSurf2)
|
|
else
|
|
-- se telaio la superficie da cui non fuoriuscire è quella interna del pezzo short
|
|
local sCtrIn2 = WIN_OFST .. GetProfileCtrIn( nOrigPrevOutlineId, nOutlineId, nPrevProfileId)
|
|
nTestSurf2 = CreateProfileSurf( nOrigPrevOutlineId, nPrevProfileId, sCtrIn2, 100, nLayerId)
|
|
end
|
|
|
|
-- direzione per la traslazione dei dowels
|
|
local vtMove = EgtIf( bSashOrFrame, - frDest:getVersX(), frDest:getVersX())
|
|
|
|
-- analizzo le singole file di dowels
|
|
for k = 0, 3 do
|
|
-- recupero i dowels della fila k-esima
|
|
local vDowels = EgtGetNameInGroup( nPrevProfileId, WIN_DOWEL .. 'Row' .. tostring( k))
|
|
if #vDowels > 0 then
|
|
|
|
-- recupero il dowel nella posizione più problematica ( per le ante è quello più esterno, per il telaio quello più interno)
|
|
local nDowelRef = EgtIf( bSashOrFrame, vDowels[1], vDowels[#vDowels])
|
|
-- calcolo correzione da applicare al frame affinchè i dowels non fuoriescano da un lato visibile ( esterno per ante ed interno per telaio)
|
|
local dLenCurr = CalcDowelLen( nDowelRef, sLenKey, true)
|
|
local dLenPrev = CalcDowelLen( nDowelRef, sPrevLenKey, false)
|
|
local dMove = CalcDowelFrameCorrection( nOutlineId, nPrevOutlineId, nDowelRef, frOrig, frDest, nTestSurfInverted, nTestSurf, nTestSurf2, vtMove, nLayerId, dLenCurr, dLenPrev)
|
|
local frDestDowel = Frame3d( frDest)
|
|
frDestDowel:move( dMove * vtMove)
|
|
|
|
for i = 1, #vDowels do
|
|
-- dowels per pezzo corrente ( full)
|
|
local dLenFull = CalcDowelLen( vDowels[i], sLenKey, true)
|
|
CreateDowel( vDowels[i], nLayerId, frOrig, frDestDowel, - frDestDowel:getVersZ(), nTestSurfInverted, dLenFull, WIN_PRC_SIDETYPE.IN, nSolidId)
|
|
-- dowels per prezzo precedente ( short)
|
|
local dLenShort = CalcDowelLen( vDowels[i], sPrevLenKey, false)
|
|
CreateDowel( vDowels[i], nPrevLayerId, frOrig, frDestDowel, frDestDowel:getVersZ(), nTestSurf, dLenShort, WIN_PRC_SIDETYPE.RIGHT, nPrevSolidId)
|
|
end
|
|
end
|
|
end
|
|
|
|
EgtErase( nTestSurf)
|
|
EgtErase( nTestSurfInverted)
|
|
EgtErase( nTestSurf2)
|
|
|
|
|
|
elseif nJointType == WIN_PART_JNT.SHORT then
|
|
|
|
-- calcolo il riferimento del profilo
|
|
local nFrameProfile = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frOrig = EgtFR( nFrameProfile, GDB_ID.ROOT)
|
|
frOrig:invert()
|
|
|
|
-- calcolo il riferimento su cui posizionare i dowels
|
|
local frDest = CreateDowelFrameDest( nProfileType, nPrevGeo, nGeo, nOutlineId, false, bSashOrFrame)
|
|
|
|
-- recupero info con la lunghezza ( dipendono dal profilo del pezzo full, quindi da prezzo prev)
|
|
local sLenKey = WIN_DWL_TOP_PARA_LEN
|
|
local sPrevLenKey = WIN_DWL_TOP_PERP_LEN
|
|
if nPrevProfileType == WIN_PRF.BOTTOM then
|
|
sLenKey = WIN_DWL_BOTTOM_PARA_LEN
|
|
sPrevLenKey = WIN_DWL_BOTTOM_PERP_LEN
|
|
elseif nPrevProfileType == WIN_PRF.BOTTOMRAIL or nPrevProfileType == WIN_PRF.BOTTOMRAIL_FINAL then
|
|
sLenKey = WIN_DWL_BOTTOMRAIL_PARA_LEN
|
|
sPrevLenKey = WIN_DWL_BOTTOMRAIL_PERP_LEN
|
|
elseif EgtExistsInfo( nPrevPart, WIN_SASHTYPE) then
|
|
-- verifico se è inactive sash dalla info settata per lavorazione
|
|
sLenKey = WIN_DWL_INACTIVE_PARA_LEN
|
|
sPrevLenKey = WIN_DWL_INACTIVE_PERP_LEN
|
|
end
|
|
|
|
-- superficie test per il posizionamento dei dowels
|
|
-- è il controprofilo in del pezzo full quindi è la stessa superficie che viene utilizzata per trimmare lo start del pezzo corrente
|
|
local nTestSurf
|
|
if not s_bCalcSolid or s_bSimplSolid then
|
|
local sCtrIn = WIN_OFST .. GetProfileCtrIn( nOrigPrevOutlineId, nOutlineId, nPrevProfileId) -- controprofilo del pezzo full
|
|
nTestSurf = CreateProfileSurf( nOrigPrevOutlineId, nPrevProfileId, sCtrIn, 100, nLayerId)
|
|
else
|
|
local nGeoCrv = EgtGetFirstNameInGroup( nGeo, WIN_GEO_LEFT)
|
|
local nOrigSurf = EgtGetInfo( nGeoCrv, WIN_REF_SURF, 'i')
|
|
nTestSurf = EgtCopyGlob( nOrigSurf, nLayerId)
|
|
end
|
|
local nTestSurfInverted = EgtCopyGlob( nTestSurf, nLayerId)
|
|
EgtInvertSurf( nTestSurfInverted)
|
|
|
|
-- superficie test per la traslazione dei dowels
|
|
local nTestSurf2
|
|
if bSashOrFrame then
|
|
if not s_bCalcSolid or s_bSimplSolid then
|
|
nTestSurf2 = CreateProfileSurf( nOrigOutlineId, nProfileId, WIN_OFST .. WIN_OUT, 100, nLayerId)
|
|
else
|
|
local nGeoCrv = EgtGetFirstNameInGroup( nPrevGeo, WIN_GEO_RIGHT)
|
|
local nOrigSurf = EgtGetInfo( nGeoCrv, WIN_REF_SURF, 'i')
|
|
nTestSurf2 = EgtCopyGlob( nOrigSurf, nLayerId)
|
|
end
|
|
EgtInvertSurf( nTestSurf2)
|
|
else
|
|
local sCtrIn2 = WIN_OFST .. GetProfileCtrIn( nOutlineId, nPrevOutlineId, nProfileId) -- controprofilo del pezzo short
|
|
nTestSurf2 = CreateProfileSurf( nOrigOutlineId, nProfileId, sCtrIn2, 100, nLayerId)
|
|
end
|
|
|
|
-- direzione per la traslazione dei dowels
|
|
local vtMove = EgtIf( bSashOrFrame, - frDest:getVersX(), frDest:getVersX())
|
|
|
|
-- analizzo le singole file di dowels
|
|
for k = 0, 3 do
|
|
-- recupero i dowels sulla fila k-esima
|
|
local vDowels = EgtGetNameInGroup( nProfileId, WIN_DOWEL .. 'Row' .. tostring(k))
|
|
if #vDowels > 0 then
|
|
|
|
-- recupero il dowel nella posizione più problematica ( per le ante è quello più esterno, per il telaio quello più interno)
|
|
local nDowelRef = EgtIf( bSashOrFrame, vDowels[1], vDowels[#vDowels])
|
|
-- calcolo correzione da applicare al frame affinchè i dowels non fuoriescano da un lato visibile ( esterno per ante ed interno per telaio)
|
|
local dLenCurr = CalcDowelLen( nDowelRef, sLenKey, false)
|
|
local dLenPrev = CalcDowelLen( nDowelRef, sPrevLenKey, true)
|
|
local dMove = CalcDowelFrameCorrection( nOutlineId, nPrevOutlineId, nDowelRef, frOrig, frDest, nTestSurf, nTestSurfInverted, nTestSurf2, vtMove, nLayerId, dLenCurr, dLenPrev)
|
|
local frDestDowel = Frame3d( frDest)
|
|
frDestDowel:move( dMove * vtMove)
|
|
|
|
for i = 1, #vDowels do
|
|
-- dowels per pezzo corrente ( short)
|
|
local dLenShort = CalcDowelLen( vDowels[i], sLenKey, false)
|
|
CreateDowel( vDowels[i], nLayerId, frOrig, frDestDowel, - frDestDowel:getVersZ(), nTestSurf, dLenShort, WIN_PRC_SIDETYPE.LEFT, nSolidId)
|
|
-- dowels per prezzo precedente ( full)
|
|
local dLenFull = CalcDowelLen( vDowels[i], sPrevLenKey, true)
|
|
CreateDowel( vDowels[i], nPrevLayerId, frOrig, frDestDowel, frDestDowel:getVersZ(), nTestSurfInverted, dLenFull, WIN_PRC_SIDETYPE.IN, nPrevSolidId)
|
|
end
|
|
end
|
|
end
|
|
|
|
EgtErase( nTestSurf)
|
|
EgtErase( nTestSurfInverted)
|
|
EgtErase( nTestSurf2)
|
|
end
|
|
|
|
EgtErase( nOutlineId)
|
|
EgtErase( nPrevOutlineId)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola i dowels tra uno split e i pezzi sui cui poggia
|
|
local function CalcSplitDowels( nSplitId, bStartOrEnd)
|
|
|
|
-- TO DO : da gestire incrocio dowels di tre pezzi
|
|
|
|
-- recupero il pezzo dello split
|
|
local nSplitPart = EgtGetInfo( nSplitId, WIN_REF_PART, 'i')
|
|
|
|
-- recupero il profilo originale dello split e il suo frame
|
|
local nSplitProfile = GetOutlineProfileId( nSplitId, false)
|
|
local nSplitProfileFrameId = EgtGetFirstNameInGroup( nSplitProfile, WIN_SECTIONFRAME)
|
|
local frOrig = EgtFR( nSplitProfileFrameId, GDB_ID.ROOT)
|
|
frOrig:invert()
|
|
|
|
-- recupero il gruppo delle lavorazioni
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nSplitPart, WIN_PRC)
|
|
|
|
-- recupero eventuale solido e superifici usate per il suo trim
|
|
local nSplitSolidId
|
|
if s_bCalcSolid then
|
|
local nSplitSolidLayerId = EgtGetFirstNameInGroup( nSplitPart, WIN_SOLID)
|
|
nSplitSolidId = EgtGetFirstNameInGroup( nSplitSolidLayerId, WIN_SRF_MAIN)
|
|
end
|
|
|
|
-- indviduo il lato su cui andranno i dowels
|
|
local sSplitDowelSide = WIN_PRC_SIDETYPE.RIGHT
|
|
if bStartOrEnd then
|
|
sSplitDowelSide = WIN_PRC_SIDETYPE.LEFT
|
|
end
|
|
|
|
-- recupero la superficie del pezzo per verificare se dowel interno
|
|
local nSplitGeo = EgtGetFirstNameInGroup( nSplitPart, WIN_GEO)
|
|
local nSplitSurf = EgtGetFirstNameInGroup( nSplitGeo, WIN_GEO_SURF)
|
|
|
|
local vGeoCrvs = EgtGetNameInGroup( nSplitGeo, EgtIf( bStartOrEnd, WIN_LEFT, WIN_RIGHT))
|
|
local ptRef = EgtIf( bStartOrEnd, EgtSP( nSplitId), EgtEP( nSplitId))
|
|
|
|
for i = 1, #vGeoCrvs do
|
|
|
|
local nOrigOutline = abs( EgtGetInfo( vGeoCrvs[i], WIN_REF_OUTLINE, 'i'))
|
|
-- verifico se soglia ( in quel caso non ci sono dowels quindi va ignorato)
|
|
local bThreshold = EgtGetInfo( nOrigOutline, WIN_THRESHOLD, 'b') or false
|
|
|
|
if not bThreshold then
|
|
|
|
-- recupero il pezzo associato e il suo outline di riferimento
|
|
local nPartId = FindAssociatedPart( nOrigOutline, true)
|
|
local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
|
local nProfileType = GetOutlineProfileType( nOutlineId, true)
|
|
|
|
-- calcolo il frame di destinazione
|
|
-- trovo intersezione dello split con lato In o Out del geo
|
|
local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local nGeoCrvId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN)
|
|
local ptInters = EgtIP( nGeoCrvId, nSplitId, ptRef)
|
|
local sDowelSide = WIN_PRC_SIDETYPE.IN
|
|
if not ptInters and nProfileType == WIN_PRF.SPLIT then
|
|
nGeoCrvId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT)
|
|
ptInters = EgtIP( nGeoCrvId, nSplitId, ptRef)
|
|
sDowelSide = WIN_PRC_SIDETYPE.OUT
|
|
end
|
|
-- se non trovo intersezione passo al successivo
|
|
if ptInters then
|
|
|
|
-- TO DO : gestione split non lineare
|
|
local frDest = Frame3d( ptInters, - EgtSV( nSplitId))
|
|
|
|
-- recupero il layer con le lavorazioni
|
|
local nLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PRC)
|
|
|
|
-- nel layer dei profili del pezzo aggiungo il profilo dello split posizionato correttamente
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nSplitProfileCopyId = EgtCopy( nSplitProfile, nProfileLayerId)
|
|
local sSplitProfileType = EgtGetName( nSplitProfile)
|
|
EgtSetInfo( nSplitProfileCopyId, WIN_PRF_TYPE, sSplitProfileType)
|
|
EgtSetName( nSplitProfileCopyId, WIN_PRF_SPLIT)
|
|
-- posiziono il profilo sulla curva di split
|
|
EgtTransform( EgtGetAllInGroup( nSplitProfileCopyId), frOrig, GDB_RT.GLOB)
|
|
EgtChangeGroupFrame( nSplitProfileCopyId, frDest, GDB_RT.GLOB)
|
|
|
|
-- recupero eventuale solido
|
|
local nSolidId
|
|
if s_bCalcSolid then
|
|
local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID)
|
|
nSolidId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_SRF_MAIN)
|
|
end
|
|
|
|
-- recupero le chiavi delle lunghezze ( dipendono dal profilo del pezzo su cui poggia lo split)
|
|
local sSplitLenKey = WIN_DWL_TOP_PARA_LEN
|
|
local sLenKey = WIN_DWL_TOP_PERP_LEN
|
|
if nProfileType == WIN_PRF.BOTTOM then
|
|
sSplitLenKey = WIN_DWL_BOTTOM_PARA_LEN
|
|
sLenKey = WIN_DWL_BOTTOM_PERP_LEN
|
|
elseif nProfileType == WIN_PRF.BOTTOMRAIL_FINAL then
|
|
sSplitLenKey = WIN_DWL_RAILBOTTOM_PARA_LEN
|
|
sLenKey = WIN_DWL_RAILBOTTOM_PERP_LEN
|
|
elseif nProfileType == WIN_PRF.SPLIT then
|
|
sSplitLenKey = WIN_DWL_SPLIT_PARA_LEN
|
|
sLenKey = WIN_DWL_SPLIT_PERP_LEN
|
|
end
|
|
|
|
-- creo la superficie di test per il posizionamento dei dowels
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
|
local nTestSurf
|
|
if not s_bCalcSolid or s_bSimplSolid then
|
|
local bChangeProfile = EgtGetInfo( nSplitId, WIN_PRF_CHANGE, 'b') or false
|
|
if bChangeProfile then
|
|
local nMixedOutline = EgtGetInfo( nSplitId, EgtIf( bStartOrEnd, WIN_MIXED_REF_START, WIN_MIXED_REF_END), 'i')
|
|
nTestSurf = CreateMixedSplitTrimSurf( nMixedOutline, nProfileId, 100, nLayerId)
|
|
else
|
|
local sCtr = WIN_OFST .. GetProfileCtrIn( nOutlineId, nSplitId, nProfileId)
|
|
nTestSurf = CreateProfileSurf( nOutlineId, nProfileId, sCtr, 100, nLayerId)
|
|
end
|
|
else
|
|
-- è la stessa superficie utilizzata per il trim del solido
|
|
local nTrimSurf = EgtGetInfo( vGeoCrvs[i], WIN_REF_SURF, 'i')
|
|
nTestSurf = EgtCopyGlob( nTrimSurf, nSplitLayerId)
|
|
end
|
|
local nTestSurfInverted = EgtCopyGlob( nTestSurf, nSplitLayerId)
|
|
EgtInvertSurf( nTestSurfInverted)
|
|
|
|
-- calcolo le direzioni entranti nei pezzi
|
|
local vtSplitDir = EgtIf( bStartOrEnd, - frDest:getVersZ(), frDest:getVersZ())
|
|
local vtDir = frDest:getVersZ()
|
|
local _, _, nSide = EgtPointCurveDistSide( ptInters + vtDir, nGeoCrvId, Z_AX())
|
|
if nSide == 1 then
|
|
-- se a destra della curva significa che la direzione è uscente dal pezzo e va invertita
|
|
vtDir = - vtDir
|
|
end
|
|
|
|
-- recupero la superficie del pezzo per verificare se dowel interno
|
|
local nGeo = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local nSurf = EgtGetFirstNameInGroup( nGeo, WIN_GEO_SURF)
|
|
|
|
-- aggiungo i dowels
|
|
local vDowels = EgtGetNameInGroup( nSplitProfile, WIN_DOWEL .. '*') or {}
|
|
for i = 1, #vDowels do
|
|
-- split
|
|
local dLen1 = CalcDowelLen( vDowels[i], sSplitLenKey, false)
|
|
local nDowel1 = CreateDowel( vDowels[i], nSplitLayerId, frOrig, frDest, vtSplitDir, nTestSurf, dLen1, sSplitDowelSide, nSplitSolidId)
|
|
-- verifico se dowel è interno al pezzo ( TO DO : da migliorare!)
|
|
local ptTest = EgtCP( nDowel1) - vtSplitDir * EgtCurveThickness( nDowel1)
|
|
local nTestPoint = EgtPoint( nSplitLayerId, ptTest)
|
|
if EgtSurfFrTestExternal( nSplitSurf, nTestPoint) then
|
|
EgtErase( nDowel1)
|
|
end
|
|
EgtErase( nTestPoint)
|
|
|
|
-- pezzo
|
|
local dLen2 = CalcDowelLen( vDowels[i], sLenKey, true)
|
|
local nDowel2 = CreateDowel( vDowels[i], nLayerId, frOrig, frDest, vtDir, nTestSurfInverted, dLen2, sDowelSide, nSolidId)
|
|
ptTest = EgtCP( nDowel2) - vtDir * EgtCurveThickness( nDowel2)
|
|
nTestPoint = EgtPoint( nLayerId, ptTest)
|
|
if EgtSurfFrTestExternal( nSurf, nTestPoint) then
|
|
EgtErase( nDowel2)
|
|
end
|
|
EgtErase( nTestPoint)
|
|
|
|
end
|
|
|
|
EgtErase( nTestSurf)
|
|
EgtErase( nTestSurfInverted)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola le spine
|
|
local function CalculateAreaDowels( nAreaId)
|
|
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then
|
|
-- verifico se presente bottomrail
|
|
local nBottomRails = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0
|
|
-- aggiungo le spine sui pezzi dell'area
|
|
local nOutline = EgtGetFirstInGroup( nOutlineLayerId)
|
|
local nPrevOutline = EgtGetLastInGroup( nOutlineLayerId)
|
|
while nOutline do
|
|
-- aggiungo spine su nOutline e nPrevOutline nel loro punto di giunzione
|
|
CalcDowels( nOutline, nPrevOutline, nAreaType == WIN_AREATYPES.SASH)
|
|
-- bottomrail
|
|
if nBottomRails > 0 and ( EgtGetName( nOutline) == WIN_BOTTOM or EgtGetName( nPrevOutline) == WIN_BOTTOM) then
|
|
for j = 1, nBottomRails do
|
|
CalcDowels( nOutline, nPrevOutline, false, j)
|
|
end
|
|
end
|
|
-- aggiorno per iterazione successiva
|
|
nPrevOutline = nOutline
|
|
nOutline = EgtGetNext( nOutline)
|
|
end
|
|
|
|
elseif nAreaType == WIN_AREATYPES.SPLIT then
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT)
|
|
local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL
|
|
-- se split non è di tipo french ha un pezzo associato per il quale vanno calcolate le spine
|
|
if nSplitType ~= WIN_SPLITTYPES.FRENCH then
|
|
local vSplitIds = EgtGetAllInGroup( nSplitLayerId)
|
|
for i = 1, #vSplitIds do
|
|
-- start
|
|
CalcSplitDowels( vSplitIds[i], true)
|
|
-- end
|
|
CalcSplitDowels( vSplitIds[i], false)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- calcolo le spine delle sottoaree
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
CalculateAreaDowels( nChildAreaId)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
--------------------------------- STRIP ----------------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che restitutisce lo Strip piu' vicino
|
|
local function GetStripNearestToOutline( nProfileId, nOutlineId)
|
|
|
|
local sStripName = WIN_STRIP
|
|
-- gestione particolare del caso di profilo di split ( devo capire il lato corretto)
|
|
if not EgtGetFirstNameInGroup( nProfileId, sStripName) then
|
|
local bInverted = EgtGetInfo( nOutlineId, WIN_INV_SPLIT, 'b') or false
|
|
if bInverted then
|
|
sStripName = WIN_STRIP .. '1'
|
|
else
|
|
sStripName = WIN_STRIP .. '2'
|
|
end
|
|
end
|
|
|
|
if s_bSimplSolid then
|
|
sStripName = WIN_SIMPLIFIED .. sStripName
|
|
end
|
|
|
|
local nStripId = EgtGetFirstNameInGroup( nProfileId, sStripName)
|
|
return nStripId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function CreateStripGuideLines( nOutlineId, nRefOutlineId, nStripId, nProfileId, nSolidLayerId)
|
|
-- restutuisco le curve ordinate in modo che la prima sia quella più esterna e la seconda quella più interna
|
|
|
|
-- recupero il box dello strip nel frame del profilo
|
|
local nProfileFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frProfile = EgtFR( nProfileFrameId, GDB_ID.ROOT)
|
|
local b3MainStrip = EgtGetBBoxRef( nStripId, GDB_BB.STANDARD, frProfile, GDB_RT.GLOB)
|
|
|
|
-- calcolo offset per strip
|
|
local dDelta = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd') or 0
|
|
local dMinOffs = b3MainStrip:getMin():getX() - dDelta
|
|
local dMaxOffs = b3MainStrip:getMax():getX() - dDelta
|
|
|
|
local nMinOffsetId = EgtCopy( nOutlineId, nSolidLayerId)
|
|
EgtOffsetCurve( nMinOffsetId, dMinOffs)
|
|
local nMaxOffsetId = EgtCopy( nOutlineId, nSolidLayerId)
|
|
EgtOffsetCurve( nMaxOffsetId, dMaxOffs)
|
|
|
|
-- verifico se le curve vanno invertite nel caso di split
|
|
local bInverted = EgtGetInfo( nRefOutlineId, WIN_INV_SPLIT, 'b') or false
|
|
if bInverted then
|
|
EgtInvertCurve( nMinOffsetId)
|
|
EgtInvertCurve( nMaxOffsetId)
|
|
return nMaxOffsetId, nMinOffsetId
|
|
end
|
|
|
|
return nMinOffsetId, nMaxOffsetId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function TrimStripSurfByPoints( pt1, pt2, nStripSurfId, nSolidLayerId)
|
|
|
|
-- creo la superficie di trim
|
|
local nTrimGuideId = EgtLine( nSolidLayerId, pt1, pt2)
|
|
EgtExtendCurveStartByLen( nTrimGuideId, 100)
|
|
EgtExtendCurveEndByLen( nTrimGuideId, 100)
|
|
EgtMove( nTrimGuideId, Z_AX())
|
|
local dDim = 100
|
|
local nTrimSurfId = EgtSurfTmByExtrusion( nSolidLayerId, nTrimGuideId, - Z_AX() * dDim, WIN_SURF_APPROX)
|
|
|
|
-- intersezione con strip
|
|
EgtSurfTmIntersect( nStripSurfId, nTrimSurfId)
|
|
|
|
EgtErase( nTrimGuideId)
|
|
EgtErase( nTrimSurfId)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function TrimStripSurfByCurve( nCrvId, nStripSurfId, nSolidLayerId, bPrev)
|
|
|
|
-- estendo la guida in tangenza
|
|
local nTrimGuideId = EgtCopyGlob( nCrvId, nSolidLayerId)
|
|
local dExtraLen = 100
|
|
if EgtGetType( nTrimGuideId) == GDB_TY.CRV_LINE then
|
|
EgtExtendCurveStartByLen( nTrimGuideId, dExtraLen)
|
|
EgtExtendCurveEndByLen( nTrimGuideId, dExtraLen)
|
|
else
|
|
nTrimGuideId = EgtCurveCompo( nSolidLayerId, nTrimGuideId)
|
|
EgtAddCurveCompoLineTg( nTrimGuideId, dExtraLen)
|
|
EgtAddCurveCompoLineTg( nTrimGuideId, dExtraLen, false)
|
|
end
|
|
EgtMove( nTrimGuideId, Z_AX())
|
|
EgtInvertCurve( nTrimGuideId)
|
|
|
|
-- creo la superficie di trim
|
|
local dDim = 100
|
|
local nTrimSurfId = EgtSurfTmByExtrusion( nSolidLayerId, nTrimGuideId, - Z_AX() * dDim, WIN_SURF_APPROX)
|
|
|
|
-- intersezione con strip
|
|
EgtSurfTmIntersect( nStripSurfId, nTrimSurfId)
|
|
|
|
EgtErase( nTrimGuideId)
|
|
EgtErase( nTrimSurfId)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function CalcAreaStrip( nGeoFillId)
|
|
|
|
if not s_bCalcSolid then return end
|
|
|
|
-- gruppi temporanei per i conti
|
|
local nGrp = EgtGroup( GDB_ID.ROOT)
|
|
local nGrp1 = EgtGroup( GDB_ID.ROOT)
|
|
local nGrp2 = EgtGroup( GDB_ID.ROOT)
|
|
EgtSetStatus( nGrp, GDB_ST.OFF)
|
|
EgtSetStatus( nGrp1, GDB_ST.OFF)
|
|
EgtSetStatus( nGrp2, GDB_ST.OFF)
|
|
|
|
-- estrudo i fermavetri e calcolo le curve che li limitano ( Offs1 sono quelli più lontani dal pezzo, Offs2 quelli più vicini)
|
|
local vGeoCrvs = EgtGetAllInGroup( nGeoFillId)
|
|
local tabStrip = {}
|
|
for i = 1, #vGeoCrvs do
|
|
|
|
local nCrvId = abs( EgtGetInfo( vGeoCrvs[i], WIN_REF_OUTLINE, 'i'))
|
|
local nOutlineId = abs( EgtGetInfo( nCrvId, WIN_REF_OUTLINE, 'i'))
|
|
local nPartId = FindAssociatedPart( nOutlineId, true)
|
|
|
|
-- recupero profilo
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
|
local nStripId = GetStripNearestToOutline( nProfileId, nCrvId)
|
|
|
|
-- recupero layer per solido
|
|
local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID)
|
|
|
|
-- estrusione del fermavetro :
|
|
-- creazione della giuda
|
|
local nGuideId = EgtCurveCompo( nSolidLayerId, nOutlineId, false)
|
|
local sProfileType = EgtGetInfo( nProfileId, WIN_PRF_TYPE)
|
|
if sProfileType == WIN_FILL_RAIL then
|
|
local dOffs = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd')
|
|
EgtOffsetCurve( nGuideId, - dOffs)
|
|
end
|
|
-- estensione : se in tangenza con le vicine estensione in tangenza altrimenti estensione standard
|
|
local nPrev = EgtGetPrev( vGeoCrvs[i]) or EgtGetLastInGroup( nGeoFillId)
|
|
local nNext = EgtGetNext( vGeoCrvs[i]) or EgtGetLastInGroup( nGeoFillId)
|
|
if AreSameVectorApprox( EgtEV( nPrev), EgtSV( nGuideId)) then
|
|
EgtAddCurveCompoLineTg( nGuideId, 100, false)
|
|
else
|
|
EgtExtendCurveStartByLen( nGuideId, 100)
|
|
end
|
|
if AreSameVectorApprox( EgtEV( nGuideId), EgtSV( nNext)) then
|
|
EgtAddCurveCompoLineTg( nGuideId, 100)
|
|
else
|
|
EgtExtendCurveEndByLen( nGuideId, 100)
|
|
end
|
|
-- sistemo il profilo da estrudere
|
|
local nSectionId = EgtCopyGlob( nStripId, nSolidLayerId)
|
|
local nFrameProfileId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frOrig = EgtFR( nFrameProfileId, GDB_ID.ROOT)
|
|
frOrig:invert()
|
|
local frDest = Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId))
|
|
EgtTransform( nSectionId, frOrig)
|
|
EgtTransform( nSectionId, frDest)
|
|
local nStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nSectionId, nGuideId, false, WIN_SURF_APPROX)
|
|
EgtSetName( nStripExtrusionId, WIN_SRF_STRIP)
|
|
EgtErase( nSectionId)
|
|
EgtErase( nGuideId)
|
|
|
|
-- curve limite del fermavetro
|
|
local nOffs1, nOffs2 = CreateStripGuideLines( nOutlineId, nCrvId, nStripId, nProfileId, nGrp)
|
|
EgtSetInfo( nOffs1, WIN_REF_GEO, vGeoCrvs[i])
|
|
EgtSetInfo( nOffs2, WIN_REF_GEO, vGeoCrvs[i])
|
|
|
|
tabStrip[vGeoCrvs[i]] = { OrigOffs1 = nOffs1, OrigOffs2 = nOffs2, Offs1 = GDB_ID.NULL, Offs2 = GDB_ID.NULL, StripId = nStripExtrusionId}
|
|
EgtCopyGlob( nOffs1, nGrp1)
|
|
EgtCopyGlob( nOffs2, nGrp2)
|
|
end
|
|
|
|
-- taglio le curve limite dei fermavetri per individuare correttamente i pezzi con cui verranno tagliati
|
|
TrimOrderedCurves( EgtGetAllInGroup( nGrp1))
|
|
TrimOrderedCurves( EgtGetAllInGroup( nGrp2))
|
|
|
|
-- associo le curve trimmate alle curve geo corrispondenti
|
|
local nCrvId = EgtGetFirstInGroup( nGrp1)
|
|
while nCrvId do
|
|
local nGeoRef = EgtGetInfo( nCrvId, WIN_REF_GEO, 'i')
|
|
tabStrip[nGeoRef].Offs1 = nCrvId
|
|
nCrvId = EgtGetNext( nCrvId)
|
|
end
|
|
nCrvId = EgtGetFirstInGroup( nGrp2)
|
|
while nCrvId do
|
|
local nGeoRef = EgtGetInfo( nCrvId, WIN_REF_GEO, 'i')
|
|
tabStrip[nGeoRef].Offs2 = nCrvId
|
|
nCrvId = EgtGetNext( nCrvId)
|
|
end
|
|
|
|
-- trim dei solidi fermavetro
|
|
for i = 1, #vGeoCrvs do
|
|
|
|
-- recupero solido del fermavetro
|
|
local nGeoCrv = vGeoCrvs[i]
|
|
local nStripId = tabStrip[nGeoCrv].StripId
|
|
local nSolidLayerId = EgtGetParent( nStripId)
|
|
|
|
-- recupero le corrispondenti curve limite trimmate
|
|
local nCrvOffs1 = tabStrip[nGeoCrv].Offs1
|
|
local nCrvOffs2 = tabStrip[nGeoCrv].Offs2
|
|
|
|
-- se entrambe le curve valide
|
|
if nCrvOffs1 ~= GDB_ID.NULL and nCrvOffs2 ~= GDB_ID.NULL then
|
|
-- a) trim start
|
|
-- recupero le precedenti della curva 1 e 2
|
|
local nPrev1 = EgtGetPrev( nCrvOffs1) or EgtGetLastInGroup( nGrp1)
|
|
local nPrev2 = EgtGetPrev( nCrvOffs2) or EgtGetLastInGroup( nGrp2)
|
|
local nPrevCrv1 = EgtGetInfo( nPrev1, WIN_REF_GEO, 'i')
|
|
local nPrevCrv2 = EgtGetInfo( nPrev2, WIN_REF_GEO, 'i')
|
|
|
|
if nPrevCrv1 == nPrevCrv2 then
|
|
-- se le precedenti coincidono taglio basandomi solo sui riferimenti dello strip corrente
|
|
TrimStripSurfByPoints( EgtSP( nCrvOffs2), EgtSP( nCrvOffs1), nStripId, nSolidLayerId, true)
|
|
else
|
|
-- ci sono dei pezzi che scompaiono quindi vanno effettuati due tagli: uno per ricreare il bordo 2 dei pezzi che scompaiono e uno per
|
|
-- separare il pezzo corrente e il pezzo 1
|
|
|
|
-- a) recupero i pezzi che scompaiono
|
|
local nStartCrv = tabStrip[nPrevCrv1].Offs2
|
|
nStartCrv = EgtGetNext( nStartCrv) or EgtGetFirstInGroup( EgtGetParent( nStartCrv))
|
|
local vIds = {}
|
|
while nStartCrv ~= nCrvOffs2 do
|
|
table.insert( vIds, nStartCrv)
|
|
nStartCrv = EgtGetNext( nStartCrv) or EgtGetFirstInGroup( EgtGetParent( nStartCrv))
|
|
end
|
|
local nCrvRef2 = EgtCurveCompo( nGrp, vIds, false)
|
|
-- taglio
|
|
TrimStripSurfByCurve( nCrvRef2, nStripId, nSolidLayerId)
|
|
|
|
-- b) taglio che separa da pezzo 1
|
|
TrimStripSurfByPoints( EgtCP( nCrvRef2), EgtSP( nCrvOffs1), nStripId, nSolidLayerId, true)
|
|
EgtErase( nCrvRef2)
|
|
end
|
|
|
|
-- b) trim end
|
|
-- recupero le successive per le curve 1 e 2
|
|
local nNext1 = EgtGetNext( nCrvOffs1) or EgtGetFirstInGroup( nGrp1)
|
|
local nNext2 = EgtGetNext( nCrvOffs2) or EgtGetFirstInGroup( nGrp2)
|
|
local nNextCrv1 = EgtGetInfo( nNext1, WIN_REF_GEO, 'i')
|
|
local nNextCrv2 = EgtGetInfo( nNext2, WIN_REF_GEO, 'i')
|
|
|
|
if nNextCrv1 == nNextCrv2 then
|
|
TrimStripSurfByPoints( EgtEP( nCrvOffs1), EgtEP( nCrvOffs2), nStripId, nSolidLayerId)
|
|
else
|
|
local nStartCrv = nCrvOffs2
|
|
nStartCrv = EgtGetNext( nStartCrv) or EgtGetFirstInGroup( EgtGetParent( nStartCrv))
|
|
local vIds = {}
|
|
while nStartCrv ~= tabStrip[nNextCrv1].Offs2 do
|
|
table.insert( vIds, nStartCrv)
|
|
nStartCrv = EgtGetNext( nStartCrv) or EgtGetFirstInGroup( EgtGetParent( nStartCrv))
|
|
end
|
|
local nCrvRef2 = EgtCurveCompo( nGrp, vIds, false)
|
|
TrimStripSurfByCurve( nCrvRef2, nStripId, nSolidLayerId)
|
|
|
|
TrimStripSurfByPoints( EgtEP( nCrvOffs1), EgtCP( nCrvRef2), nStripId, nSolidLayerId)
|
|
EgtErase( nCrvRef2)
|
|
end
|
|
|
|
else
|
|
-- il pezzo scompare
|
|
EgtErase( nStripId)
|
|
end
|
|
end
|
|
|
|
EgtErase( nGrp)
|
|
EgtErase( nGrp1)
|
|
EgtErase( nGrp2)
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
----------------------------- CALCOLO PEZZI ------------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che stabilisce il nome del pezzo
|
|
local function CalcPartName( nAreaId, nAreaType)
|
|
|
|
local sName = ''
|
|
if nAreaType == WIN_AREATYPES.FRAME then
|
|
sName = WIN_FRAME
|
|
EgtSetInfo( nAreaId, WIN_AREA_NAME, sName)
|
|
elseif nAreaType == WIN_AREATYPES.SASH then
|
|
s_nSashNbr = s_nSashNbr + 1
|
|
sName = WIN_SASH .. '_'.. tostring( s_nSashNbr)
|
|
EgtSetInfo( nAreaId, WIN_AREA_NAME, sName)
|
|
else
|
|
-- per split o riempimento devo ricavare il nome del parent che lo contiene
|
|
local nParentId = EgtGetParent( nAreaId)
|
|
local nParentType = EgtGetInfo( nParentId, WIN_AREATYPE, 'i')
|
|
while nParentType ~= WIN_AREATYPES.FRAME and nParentType ~= WIN_AREATYPES.SASH do
|
|
nParentId = EgtGetParent( nParentId)
|
|
nParentType = EgtGetInfo( nParentId, WIN_AREATYPE, 'i')
|
|
end
|
|
sName = EgtGetInfo( nParentId, WIN_AREA_NAME, sName)
|
|
end
|
|
|
|
return sName
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che disegna l'apertura dell'anta
|
|
local function DrawOpening( nAreaId)
|
|
|
|
local nOpeningType = EgtGetInfo( nAreaId, WIN_OPENING_TYPE, 'i')
|
|
if nOpeningType == WIN_OPENING_TYPES.NULL then
|
|
return
|
|
end
|
|
|
|
-- creo gruppo per aperture
|
|
local nOpeningLayId = EgtGroup( nAreaId)
|
|
EgtSetName( nOpeningLayId, WIN_SASH_OPENING)
|
|
|
|
-- verifico se anta ricevente per impostare tratteggio
|
|
local nFactor = 7
|
|
local nPattern = 0xAAAA
|
|
local nType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i')
|
|
local bStippled = ( nType == WIN_SASHTYPES.INACTIVE or nType == WIN_SASHTYPES.INACTIVE_IN or nType == WIN_SASHTYPES.INACTIVE_OUT)
|
|
|
|
-- calcolo la curva di riferimento per il disegno dell'apertura
|
|
local nOutlineLayId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local vOutlines = EgtGetAllInGroup( nOutlineLayId)
|
|
-- TODO gestire caso di triangolo
|
|
if #vOutlines == 3 then
|
|
return
|
|
end
|
|
local vCrvs = {}
|
|
for i = 1, #vOutlines do
|
|
local nCrv = EgtCopyGlob( vOutlines[i], nOpeningLayId)
|
|
table.insert( vCrvs, nCrv)
|
|
local nProfileId = GetOutlineProfileId( vCrvs[i], true)
|
|
local b3FrameProfile = GetProfileLocalBox( nProfileId)
|
|
local dOffs = b3FrameProfile:getMin():getX()
|
|
local nBottomRail = EgtGetInfo( nCrv, WIN_BOTTOMRAIL, 'i') or 0
|
|
if nBottomRail > 0 then
|
|
-- aggiusto offset per bottomrail
|
|
local dDelta1 = EgtGetInfo( nProfileId, WIN_RAILDELTA .. '1', 'd')
|
|
local dDelta2 = EgtGetInfo( nProfileId, WIN_RAILDELTA .. '2', 'd')
|
|
dOffs = dOffs - dDelta1 - ( nBottomRail - 1) * dDelta2
|
|
end
|
|
EgtOffsetCurve( nCrv, dOffs)
|
|
end
|
|
vCrvs = TrimOrderedCurves( vCrvs)
|
|
local nGuideId = EgtCurveCompo( nOpeningLayId, vCrvs)
|
|
local _, dParE = EgtCurveDomain( nGuideId)
|
|
|
|
-- ribalta
|
|
if nOpeningType == WIN_OPENING_TYPES.TILTONLY_TOP or nOpeningType == WIN_OPENING_TYPES.TILTTURN_LEFT or nOpeningType == WIN_OPENING_TYPES.TILTTURN_RIGHT then
|
|
-- ricavo il punto sul top
|
|
local ptMid = EgtUP( nGuideId, 2.5)
|
|
if not EgtCurveIsARectangle( nGuideId) then
|
|
-- per maggiore simmetria ricavo il punto sul top in corrispondenza del punto medio del bottom
|
|
local ptTest = EgtUP( nGuideId, 0.5)
|
|
local nLineTest = EgtLinePVL( nOpeningLayId, ptTest + Y_AX(), Y_AX(), 10000)
|
|
ptMid = EgtIP( nGuideId, nLineTest, ORIG())
|
|
EgtErase( nLineTest)
|
|
end
|
|
EgtCurveCompoFromPoints( nOpeningLayId, { EgtSP( nGuideId), ptMid, EgtUP( nGuideId, 1)})
|
|
elseif nOpeningType == WIN_OPENING_TYPES.TILTONLY_BOTTOM then
|
|
-- ricavo il punto sul bottom
|
|
local ptMid = EgtUP( nGuideId, 0.5)
|
|
EgtCurveCompoFromPoints( nOpeningLayId, { EgtUP( nGuideId, 2), ptMid, EgtUP( nGuideId, dParE - 1)})
|
|
end
|
|
|
|
-- altre tipologie
|
|
if nOpeningType == WIN_OPENING_TYPES.TILTTURN_LEFT or nOpeningType == WIN_OPENING_TYPES.TURNONLY_LEFT then
|
|
-- battente sx
|
|
local dLenRight = EgtCurveCompoLength( nGuideId, 1)
|
|
local dLenLeft = EgtCurveCompoLength( nGuideId, dParE - 1)
|
|
local dParMid = 1.5
|
|
-- se lato sinistro è il più corto, prendo sul destro il corrispondente del suo punto medio
|
|
if dLenLeft < dLenRight - GEO.EPS_SMALL then
|
|
dParMid = EgtCurveParamAtLength( nGuideId, EgtCurveCompoLength( nGuideId, 0) + dLenLeft * 0.5)
|
|
end
|
|
local nCrv = EgtCurveCompoFromPoints( nOpeningLayId, { EgtSP( nGuideId), EgtUP( nGuideId, dParMid), EgtUP( nGuideId, dParE - 1)})
|
|
-- tratteggio
|
|
if bStippled then
|
|
EgtSetStipple( nCrv, nFactor, nPattern)
|
|
end
|
|
|
|
elseif nOpeningType == WIN_OPENING_TYPES.TILTTURN_RIGHT or nOpeningType == WIN_OPENING_TYPES.TURNONLY_RIGHT then
|
|
-- battente dx
|
|
local dLenRight = EgtCurveCompoLength( nGuideId, 1)
|
|
local dLenLeft = EgtCurveCompoLength( nGuideId, dParE - 1)
|
|
local dParMid = dParE - 0.5
|
|
-- se lato destro è il più corto, prendo sul sinistro il corrispondente del suo punto medio
|
|
if dLenRight < dLenLeft - GEO.EPS_SMALL then
|
|
dParMid = EgtCurveParamAtLength( nGuideId, EgtCurveLength( nGuideId) - dLenRight * 0.5)
|
|
end
|
|
local nCrv = EgtCurveCompoFromPoints( nOpeningLayId, { EgtUP( nGuideId, 1), EgtUP( nGuideId, dParMid), EgtUP( nGuideId, 2)})
|
|
-- tratteggio
|
|
if bStippled then
|
|
EgtSetStipple( nCrv, nFactor, nPattern)
|
|
end
|
|
|
|
elseif nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_LEFT or nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT or
|
|
nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_LEFT or nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_RIGHT then
|
|
-- scorrevole e alzante scorrevole ( solo forma rettangolare)
|
|
local bRight = ( nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT or nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_RIGHT)
|
|
local dLen0 = EgtCurveCompoLength( nGuideId, 0)
|
|
local dLen1 = EgtCurveCompoLength( nGuideId, 1)
|
|
local dCoeff = 0.15
|
|
local ptS = EgtUP( nGuideId, 1.5) - dCoeff * dLen0 * X_AX()
|
|
local ptE = EgtUP( nGuideId, dParE - 0.5) + dCoeff * dLen0 * X_AX()
|
|
if bRight then
|
|
ptS, ptE = ptE, ptS
|
|
end
|
|
local nCompo = EgtCurveCompoFromPoints( nOpeningLayId, { ptS, ptE})
|
|
if nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_LEFT or nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT then
|
|
EgtAddCurveCompoLine( nCompo, ptS - dCoeff * dLen1 * Y_AX(), false)
|
|
end
|
|
local dAng = EgtIf( bRight, 135, 45)
|
|
EgtLinePDL( nOpeningLayId, ptE, dAng, dCoeff * dLen0)
|
|
EgtLinePDL( nOpeningLayId, ptE, - dAng, dCoeff * dLen0)
|
|
|
|
elseif nOpeningType == WIN_OPENING_TYPES.FIXED then
|
|
-- nessun disegno
|
|
|
|
elseif nOpeningType == WIN_OPENING_TYPES.PIVOT then
|
|
-- bilico rettangolare
|
|
local nCompo = EgtCurveCompoFromPoints( nOpeningLayId, { EgtUP( nGuideId, 0.5), EgtUP( nGuideId, 1.5), EgtUP( nGuideId, 2.5), EgtUP( nGuideId, 3.5)})
|
|
EgtCloseCurveCompo( nCompo)
|
|
-- TODO oblò
|
|
end
|
|
|
|
EgtErase( nGuideId)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola l'ingombro dei pezzi del telaio e i loro solidi
|
|
local function CreatePartFromOutline( nAreaLayerId, sName, nOutlineId, nOutlineCrvNbr, nBottomRail)
|
|
|
|
-- se soglia ignoro
|
|
local bThreshold = EgtGetInfo( nOutlineId or GDB_ID.NULL, WIN_THRESHOLD, 'b') or false
|
|
if bThreshold then
|
|
return
|
|
end
|
|
|
|
-- creo pezzo
|
|
local nPartId = EgtGroup( GDB_ID.ROOT)
|
|
-- inserisco riferimento alla sua area
|
|
EgtSetInfo( nPartId, WIN_AREA, nAreaLayerId)
|
|
|
|
local nAreaType = EgtGetInfo( nAreaLayerId, WIN_AREATYPE, 'i')
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaLayerId, WIN_OUTLINE)
|
|
|
|
-- a) Telaio, anta o split
|
|
if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH or nAreaType == WIN_AREATYPES.SPLIT then
|
|
|
|
-- creo riferimenti tra pezzo e outline
|
|
EgtSetInfo( nPartId, WIN_REF_OUTLINE, nOutlineId)
|
|
if nBottomRail then
|
|
-- aggiorno i riferimenti del bottomrail
|
|
local vBottomRailParts = EgtGetInfo( nOutlineId, WIN_REF_BOTTOMRAIL_PART, 'vi') or {}
|
|
table.insert( vBottomRailParts, nPartId)
|
|
EgtSetInfo( nOutlineId, WIN_REF_BOTTOMRAIL_PART, vBottomRailParts)
|
|
EgtSetInfo( nPartId, WIN_PART_TYPE, WIN_PART_TYPES.BOTTOMRAIL)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_REF_PART, nPartId)
|
|
end
|
|
|
|
-- imposto nome del pezzo
|
|
local sOutlineName = EgtIf( nBottomRail, WIN_BOTTOMRAIL .. '_' .. tostring( nBottomRail), EgtGetName( nOutlineId))
|
|
local sPartName = sName .. '_' .. sOutlineName
|
|
EgtSetName( nPartId, sPartName)
|
|
|
|
-- imposto il colore
|
|
if sOutlineName == WIN_BOTTOM or sOutlineName == WIN_TOP or nBottomRail then
|
|
EgtSetColor( nPartId, Color3d( 204, 102, 0))
|
|
elseif sOutlineName == WIN_RIGHT or sOutlineName == WIN_LEFT then
|
|
EgtSetColor( nPartId, Color3d( 251, 128, 4))
|
|
else
|
|
EgtSetColor( nPartId, Color3d( 255, 159, 57))
|
|
end
|
|
|
|
-- ricavo il tipo di profilo
|
|
local nProfileType = GetOutlineProfileType( nOutlineId, false, nBottomRail)
|
|
-- disegno ingombro
|
|
CalcFrameGeo( nPartId, nOutlineId, nOutlineCrvNbr, nOutlineLayerId, nProfileType, nBottomRail)
|
|
-- calcolo eventuali curve ausiliarie per cambio profilo
|
|
local bChangeProfile = EgtGetInfo( nOutlineId, WIN_PRF_CHANGE, 'b') or false
|
|
if bChangeProfile and nProfileType ~= WIN_PRF.SPLIT then
|
|
CalcMixedFrameCurves( nPartId, nOutlineId)
|
|
end
|
|
-- calcolo le lavorazioni associate ai profili
|
|
CalcProfilingProcessings( nPartId, nOutlineId)
|
|
-- calcolo il georaw per automatismo lavorazioni
|
|
CalcGeoRaw( nPartId)
|
|
-- disegno solido
|
|
if s_bCalcSolid then
|
|
CalcSolid( nPartId, nOutlineId)
|
|
end
|
|
|
|
-- b) Fill
|
|
elseif nAreaType == WIN_AREATYPES.FILL then
|
|
-- imposto nome del pezzo
|
|
EgtSetName( nPartId, sName .. '_' .. WIN_FILL)
|
|
EgtSetInfo( nPartId, WIN_PART_TYPE, WIN_PART_TYPES.FILL)
|
|
-- ricavo tipo
|
|
local nFillType = EgtGetInfo( nAreaLayerId, WIN_FILLTYPE, 'i')
|
|
|
|
-- imposto colore e tipologia di riempimento
|
|
if nFillType == WIN_FILLTYPES.GLASS then
|
|
EgtSetColor( nPartId, Color3d( 71, 161, 255))
|
|
EgtSetAlpha( nPartId, 30)
|
|
EgtSetInfo( nPartId, WIN_FILLTYPE, WIN_GLASS)
|
|
elseif nFillType == WIN_FILLTYPES.WOOD then
|
|
EgtSetColor( nPartId, Color3d( 194, 148, 103))
|
|
EgtSetInfo( nPartId, WIN_FILLTYPE, WIN_WOOD)
|
|
end
|
|
|
|
-- disegno ingombro
|
|
local nGeoLayerId = CalcFillGeo( nPartId, nOutlineLayerId)
|
|
-- disegno solido
|
|
if s_bCalcSolid then
|
|
CalcFillSolid( nPartId, nGeoLayerId)
|
|
end
|
|
-- calcolo fermavetro
|
|
CalcAreaStrip( nGeoLayerId)
|
|
end
|
|
return nPartId
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che cicla ricorsivamente su aree e sottoaree per calcolare i pezzi
|
|
local function CalculateAreaParts( nAreaId)
|
|
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
-- recupero nome dei pezzi in quest'area
|
|
local sName = CalcPartName( nAreaId, nAreaType)
|
|
if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then
|
|
-- creo pezzi per ogni outline
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local vOutlines = EgtGetAllInGroup( nOutlineLayerId)
|
|
for i = 1, #vOutlines do
|
|
-- creo pezzo
|
|
CreatePartFromOutline( nAreaId, sName, vOutlines[i], i)
|
|
-- se di tipo bottom verifico se ha bottomrail
|
|
if EgtGetName( vOutlines[i]) == WIN_BOTTOM then
|
|
local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0
|
|
for j = 1, nBottomRail do
|
|
CreatePartFromOutline( nAreaId, sName, vOutlines[i], i, j)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se anta disegno apertura
|
|
if nAreaType == WIN_AREATYPES.SASH then
|
|
DrawOpening( nAreaId)
|
|
end
|
|
|
|
elseif nAreaType == WIN_AREATYPES.FILL then
|
|
-- creo riempimento
|
|
CreatePartFromOutline( nAreaId, sName)
|
|
|
|
elseif nAreaType == WIN_AREATYPES.SPLIT then
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT)
|
|
local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL
|
|
-- se split non è di tipo french ha un pezzo associato
|
|
if nSplitType ~= WIN_SPLITTYPES.FRENCH then
|
|
-- creo gruppo per area di selezione per programma
|
|
local nSelectionLayerId = EgtGroup( nAreaId)
|
|
EgtSetName( nSelectionLayerId, WIN_SPLITSELECTION)
|
|
EgtSetStatus( nSelectionLayerId, GDB_ST.OFF)
|
|
EgtSetColor( nSelectionLayerId, 'YELLOW')
|
|
EgtSetAlpha( nSelectionLayerId, 10)
|
|
local nSelectionArea
|
|
|
|
local vSplitIds = EgtGetAllInGroup( nSplitLayerId)
|
|
for i = 1, #vSplitIds do
|
|
-- creo pezzo split
|
|
local nSplitPartId = CreatePartFromOutline( nAreaId, sName, vSplitIds[i])
|
|
|
|
-- aggiorno area di selezione
|
|
local nSplitPartGeoId = EgtGetFirstNameInGroup( nSplitPartId, WIN_GEO)
|
|
local nSplitArea = EgtGetFirstNameInGroup( nSplitPartGeoId, WIN_GEO_SURF)
|
|
if not nSelectionArea then
|
|
nSelectionArea = EgtCopyGlob( nSplitArea, nSelectionLayerId)
|
|
EgtSetStatus( nSelectionArea, GDB_ST.ON)
|
|
else
|
|
EgtSurfFrAdd( nSelectionArea, nSplitArea)
|
|
end
|
|
end
|
|
EgtMove( nSelectionArea, 10 * Z_AX())
|
|
end
|
|
end
|
|
|
|
-- disegno area di selezione per programma
|
|
local nSelectionLayerId = EgtGroup( nAreaId)
|
|
EgtSetName( nSelectionLayerId, WIN_SELECTION)
|
|
EgtSetStatus( nSelectionLayerId, GDB_ST.OFF)
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local vOutlineList = EgtGetAllInGroup( nOutlineLayerId)
|
|
local nCompoId = EgtCurveCompo( nSelectionLayerId, vOutlineList, false)
|
|
local nSelectionArea = EgtSurfFlatRegion( nSelectionLayerId, nCompoId)
|
|
EgtSetColor( nSelectionArea, 'YELLOW')
|
|
EgtSetAlpha( nSelectionArea, 10)
|
|
EgtMove( nSelectionArea, 10 * Z_AX())
|
|
EgtErase( nCompoId)
|
|
|
|
-- calcolo i pezzi delle sottoaree
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
CalculateAreaParts( nChildAreaId)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
---------------------------------- TRONCHETTI ----------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che spezza l'anta in corrispondenza dei tronchetti del telaio
|
|
local function SplitArcByAlignment( nGeoIn, nGrp)
|
|
|
|
-- recupero il pezzo del telaio corrispondente
|
|
local nPartId = EgtGetParent( EgtGetParent( nGeoIn))
|
|
local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
|
local nSouId = EgtGetInfo( nOutlineId, WIN_COPY, 'i')
|
|
local nAreaType = WIN_AREATYPES.NULL
|
|
while nSouId and nAreaType ~= WIN_AREATYPES.FRAME do
|
|
nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') or GDB_ID.NULL
|
|
local nParentArea = EgtGetParent( EgtGetParent( nSouId)) or GDB_ID.NULL
|
|
nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i')
|
|
end
|
|
if not nSouId then return end
|
|
local nFrameOutlineId = EgtGetInfo( nSouId, WIN_COPY, 'i')
|
|
local nFramePartId = EgtGetInfo( nFrameOutlineId, WIN_REF_PART, 'i')
|
|
|
|
-- recupero le parti in cui era stato diviso l'arco del telaio
|
|
local nFrameLogsLayer = EgtGetFirstNameInGroup( nFramePartId, WIN_LOGS)
|
|
local vFrameLogs = EgtGetNameInGroup( nFrameLogsLayer, WIN_GEO_IN)
|
|
local ptC = EgtCP( vFrameLogs[1])
|
|
|
|
local nCurrCrvId = EgtCopyGlob( nGeoIn, nGrp)
|
|
local bInters = false
|
|
for i = 1, #vFrameLogs - 1 do
|
|
-- ricavo il punto di split sull'arco dell'anta
|
|
local ptFrame = EgtEP( vFrameLogs[i])
|
|
local vtDir = ptFrame - ptC
|
|
local nLineSplit = EgtLinePVL( nGrp, ptC, vtDir, vtDir:len() + 1000)
|
|
local ptInt = EgtIP( nCurrCrvId, nLineSplit, ORIG())
|
|
EgtErase( nLineSplit)
|
|
if ptInt then
|
|
nCurrCrvId = EgtSplitCurveAtPoint( nCurrCrvId, ptInt) or GDB_ID.NULL
|
|
bInters = true
|
|
elseif bInters then
|
|
-- se non ci sono più intersezioni esco
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che spezza l'arco in base al numero di pezzi
|
|
local function SplitArcByNumber( nLogsNbr, nGeoIn, nGrp)
|
|
local nCopy = EgtCopyGlob( nGeoIn, nGrp)
|
|
EgtSplitCurve( nCopy, nLogsNbr)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che spezza gli archi per i tronchetti
|
|
local function SplitArc( nLogsNbr, vSections, bAlign, dOverMatTot, nGeoIn, nGeoOut, nGrp)
|
|
|
|
-- per allineamento con telaio
|
|
if bAlign then
|
|
return SplitArcByAlignment( nGeoIn, nGrp)
|
|
|
|
-- per sezione
|
|
elseif #vSections == 1 and nLogsNbr == 0 then
|
|
-- dalla sezione ricavo il numero minimo di pezzi
|
|
local dSection = vSections[1] - dOverMatTot
|
|
local dROut = EgtArcRadius( nGeoOut)
|
|
local dRIn = EgtArcRadius( nGeoIn)
|
|
local dAng = abs( EgtArcAngCenter( nGeoIn))
|
|
local nParts
|
|
if dSection < dROut - dRIn + GEO.EPS_SMALL then
|
|
-- sezione troppo piccola
|
|
-- TO DO : gestione errore
|
|
EgtOutBox( 'Sezione tronchetto troppo piccola', '')
|
|
elseif dSection > dROut + dRIn - GEO.EPS_SMALL then
|
|
-- la sezione comprende già l'intero pezzo
|
|
nParts = 1
|
|
else
|
|
nParts = dAng / 2 / acos( ( dROut - dSection) / dRIn)
|
|
nParts = ceil( nParts)
|
|
end
|
|
return SplitArcByNumber( nParts, nGeoIn, nGrp)
|
|
|
|
-- per numero di pezzi
|
|
else
|
|
return SplitArcByNumber( nLogsNbr, nGeoIn, nGrp)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola la sezione dei tronchetti
|
|
local function CalcLogsSection( nLogsNbr, vSections, bAlign, dOverMatTot, nGeoIn, nGeoOut, nGrp)
|
|
|
|
-- se richiesta una sezione specifica senza vincoli sul numero di pezzi
|
|
if not bAlign and #vSections == 1 and nLogsNbr == 0 then
|
|
return vSections[1]
|
|
end
|
|
|
|
-- calcolo la sezione necessaria per la suddivisione scelta
|
|
local dMySection = 0
|
|
local dROut = EgtArcRadius( nGeoOut)
|
|
local dRIn = EgtArcRadius( nGeoIn)
|
|
if bAlign then
|
|
-- calcolo la massima sezione dai tronchetti ottenuti
|
|
local vSplits = EgtGetAllInGroup( nGrp)
|
|
for i = 1, #vSplits do
|
|
local dAng = abs( EgtArcAngCenter( vSplits[i]))
|
|
local dCurrSection = dROut - dRIn * cos( dAng / 2)
|
|
if dCurrSection > dMySection then
|
|
dMySection = dCurrSection
|
|
end
|
|
end
|
|
dMySection = dMySection + dOverMatTot
|
|
|
|
else
|
|
-- ricavo la sezione dal numero di pezzi
|
|
local dAng = abs( EgtArcAngCenter( nGeoIn))
|
|
dMySection = dROut - dRIn * cos( dAng / nLogsNbr / 2) + dOverMatTot
|
|
end
|
|
|
|
if #vSections == 0 then
|
|
-- se no vincoli sulla sezione
|
|
return dMySection
|
|
else
|
|
-- cerco la sezione più adatta dalla lista di sezioni disponibili
|
|
table.sort( vSections)
|
|
for i = 1, #vSections do
|
|
if vSections[i] > dMySection - GEO.EPS_SMALL then
|
|
return vSections[i]
|
|
end
|
|
end
|
|
-- se non ho trovato la sezione errore
|
|
EgtOutBox( 'Sezioni tronchetti troppo piccole per suddivisione richiesta', '')
|
|
return nil
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function CalcLogs( nGrp, nGeoOut, dOverMatIn, dOverMatOut, dOverMatExt, dOverMatInt, dRefSection, bCutExtremities)
|
|
|
|
-- recupero tutti i tratti dell'arco
|
|
local vCrvsIn = EgtGetAllInGroup( nGrp)
|
|
local ptC = EgtCP( vCrvsIn[1])
|
|
|
|
-- calcolo i tronchetti
|
|
local dLenTot = 0
|
|
for i = 1, #vCrvsIn do
|
|
|
|
local ptSIn = EgtSP( vCrvsIn[i])
|
|
local ptEIn = EgtEP( vCrvsIn[i])
|
|
|
|
-- recupero il tratto corrispondente sulla curva out
|
|
local ptSOut, dParSOut, ptEOut, dParEOut
|
|
if i == 1 then
|
|
-- forzo a coincidere con l'estremo della curva out
|
|
ptEOut = EgtEP( nGeoOut)
|
|
dParEOut = 1
|
|
else
|
|
_, ptEOut, dParEOut = EgtPointCurveDist( ptSIn, nGeoOut)
|
|
end
|
|
if i == #vCrvsIn then
|
|
-- forzo a coincidere con l'estremo della curva out
|
|
ptSOut = EgtSP( nGeoOut)
|
|
dParSOut = 0
|
|
else
|
|
_, ptSOut, dParSOut = EgtPointCurveDist( ptEIn, nGeoOut)
|
|
end
|
|
local nOut = EgtCopyGlob( nGeoOut, nGrp)
|
|
EgtTrimCurveStartEndAtParam( nOut, dParSOut, dParEOut)
|
|
|
|
-- creo composita corrispondente al pezzo
|
|
local nCompo = EgtCurveCompo( nGrp, {vCrvsIn[i]}, false)
|
|
EgtAddCurveCompoLine( nCompo, ptSOut)
|
|
EgtAddCurveCompoCurve( nCompo, nOut, false)
|
|
EgtCloseCurveCompo( nCompo)
|
|
|
|
-- calcolo il frame per il tronchetto
|
|
local ptM = EgtMP( vCrvsIn[i])
|
|
local vtRad = ptM - ptC
|
|
local frRef = Frame3d( ptM, vtRad ^ Z_AX(), vtRad, Z_AX())
|
|
|
|
-- calcolo il box locale al frame
|
|
local b3Ref = EgtGetBBoxRef( nCompo, GDB_BB.STANDARD, frRef)
|
|
local ptMax = b3Ref:getMax()
|
|
local ptMin = b3Ref:getMin()
|
|
ptMin:setZ( ptMax:getZ()) -- per avere curve sullo stesso piano ( e gestire correttamente le intersezioni)
|
|
|
|
-- verifico se necessario sovramateriale extra per raggiungere la sezione desiderata
|
|
local dExtraSection = max( 0, dRefSection - b3Ref:getDimY() - dOverMatIn - dOverMatOut)
|
|
|
|
-- lato bottom
|
|
local nLineBottom = EgtLinePVL( nGrp, ptMin - ( dOverMatIn + 0.5 * dExtraSection) * Y_AX(), X_AX(), 10000)
|
|
EgtExtendCurveStartByLen( nLineBottom, 10000)
|
|
EgtTransform( nLineBottom, frRef)
|
|
|
|
-- lato top
|
|
local nLineTop = EgtLinePVL( nGrp, ptMax + ( dOverMatOut + 0.5 * dExtraSection) * Y_AX(), - X_AX(), 10000)
|
|
EgtExtendCurveStartByLen( nLineTop, 10000)
|
|
EgtTransform( nLineTop, frRef)
|
|
|
|
-- lato right
|
|
local nLineRight
|
|
if i == 1 and not bCutExtremities then
|
|
nLineRight = EgtLinePVL( nGrp, ptMin, - Y_AX(), 10000)
|
|
EgtTransform( nLineRight, frRef)
|
|
else
|
|
nLineRight = EgtLine( nGrp, ptEOut, ptSIn)
|
|
EgtExtendCurveEndByLen( nLineRight, 10000)
|
|
end
|
|
EgtOffsetCurve( nLineRight, EgtIf( i == 1, dOverMatExt, dOverMatInt))
|
|
EgtExtendCurveStartByLen( nLineRight, 10000)
|
|
|
|
-- lato left
|
|
local nLineLeft
|
|
if i == #vCrvsIn and not bCutExtremities then
|
|
nLineLeft = EgtLinePVL( nGrp, ptMax, Y_AX(), 10000)
|
|
EgtTransform( nLineLeft, frRef)
|
|
else
|
|
nLineLeft = EgtLine( nGrp, ptEIn, ptSOut)
|
|
EgtExtendCurveEndByLen( nLineLeft, 10000)
|
|
end
|
|
EgtOffsetCurve( nLineLeft, EgtIf( i == #vCrvsIn, dOverMatExt, dOverMatInt))
|
|
EgtExtendCurveStartByLen( nLineLeft, 10000)
|
|
|
|
-- taglio le curve nei loro punti di intersezione
|
|
local vCrvs = { nLineTop, nLineRight, nLineBottom, nLineLeft}
|
|
vCrvs = TrimOrderedCurves( vCrvs)
|
|
|
|
-- TO DO : controllo lunghezza minima
|
|
-- local dLenTop = EgtCurveLength( nLineTop)
|
|
|
|
dLenTot = dLenTot + EgtCurveLength( nLineTop)
|
|
|
|
-- creo il tronchetto
|
|
local nLogCrv = EgtCurveCompo( nGrp, vCrvs)
|
|
EgtSetName( nLogCrv, WIN_LOGS)
|
|
EgtSetColor( nLogCrv, EgtStdColor( 'BLUE'))
|
|
|
|
-- salvo i sovramateriali utilizzati nella curva
|
|
EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_IN, dOverMatIn)
|
|
EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_OUT, dOverMatOut)
|
|
EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_LEFT, EgtIf( i == #vCrvsIn, dOverMatExt, dOverMatInt))
|
|
EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_RIGHT, EgtIf( i == 1, dOverMatExt, dOverMatInt))
|
|
|
|
EgtSetStatus( vCrvsIn[i], GDB_ST.OFF)
|
|
EgtSetStatus( nOut, GDB_ST.OFF)
|
|
EgtErase( nCompo)
|
|
end
|
|
|
|
-- salvo i dati della sezione ( analogamente a quanto fatto nel geo per pezzi lineari)
|
|
EgtSetInfo( nGrp, WIN_GEOWIDTH, dRefSection)
|
|
CopyInfo( nGrp, EgtGetParent( nGeoOut), WIN_GEOHEIGHT)
|
|
EgtSetInfo( nGrp, WIN_GEOLEN, dLenTot)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea la spina per tronchetti
|
|
local function CalcLogDowel( nOrigPartId, nCrvOut, bLeftOrRight, nProcLayerId, nProfileId, nInfoGrp, nSolidId)
|
|
|
|
-- creo il frame per il posizionamento del dowel
|
|
local nOutlineRef = EgtGetInfo( nOrigPartId, WIN_REF_OUTLINE, 'i')
|
|
local ptRef = EgtIf( bLeftOrRight, EgtSP( nCrvOut), EgtEP( nCrvOut))
|
|
local _, ptOrig, dParOrig = EgtPointCurveDist( ptRef, nOutlineRef)
|
|
local vtFrame = EgtUV( nOutlineRef, dParOrig, -1)
|
|
local frDest = Frame3d( ptOrig, - vtFrame)
|
|
|
|
-- calcolo direzione verso interno del pezzo
|
|
local vtDir = frDest:getVersZ()
|
|
if bLeftOrRight then
|
|
vtDir = - vtDir
|
|
end
|
|
|
|
-- recupero i dati del dowel
|
|
local dDowelDiam = EgtGetInfo( nInfoGrp, WIN_DWL_DIAM, 'd')
|
|
local dDowelLen = EgtGetInfo( nInfoGrp, WIN_DWL_LOG_LEN, 'd')
|
|
|
|
-- creo il dowel nel riferimento della sezione
|
|
-- TO DO : recupero della sezione corretta nel caso di cambio profilo
|
|
local nSectionId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTION) or EgtGetFirstNameInGroup( nProfileId, WIN_SASH .. WIN_SECTION)
|
|
local nDowelId = EgtCircle( nProcLayerId, EgtGP( nSectionId), 0.5 * dDowelDiam)
|
|
|
|
-- posiziono il dowel usando i riferimenti
|
|
local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frOrig = EgtFR( nFrameId)
|
|
frOrig:invert()
|
|
EgtTransform( nDowelId, frOrig)
|
|
EgtTransform( nDowelId, frDest)
|
|
|
|
local nPartId = EgtGetParent( nProcLayerId)
|
|
local dOverMat = EgtGetInfo( nPartId, EgtIf( bLeftOrRight, WIN_PRC_OVERMAT_LEFT, WIN_PRC_OVERMAT_RIGHT))
|
|
EgtMove( nDowelId, - vtDir * ( s_dDowelTol + dOverMat))
|
|
EgtModifyCurveExtrusion( nDowelId, - vtDir)
|
|
local dLen = dDowelLen + dOverMat + s_dDowelTol
|
|
EgtModifyCurveThickness( nDowelId, - dLen)
|
|
|
|
-- setto info di lavorazione
|
|
EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE)
|
|
EgtSetInfo( nDowelId, WIN_PRC_SIDE, EgtIf( bLeftOrRight, WIN_PRC_SIDETYPE.LEFT, WIN_PRC_SIDETYPE.RIGHT))
|
|
|
|
-- eventuale aggiornamento del solido
|
|
if nSolidId then
|
|
UpdateSolidWithProcessingSurf( nDowelId, nSolidId, nProcLayerId)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea i pezzi dei tronchetti
|
|
local function CalcLogParts( nOrigPartId, bFinishedLogs)
|
|
|
|
local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nInfoGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_INFO_GRP)
|
|
|
|
-- recupero i gruppi dal pezzo ad arco
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_PROFILE)
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
|
|
local nOrigSolidLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_SOLID)
|
|
local nOrigProcLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_PRC)
|
|
|
|
-- recupero dimensione del profilo
|
|
local nGeoLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_GEO)
|
|
local dThick = EgtGetInfo( nGeoLayerId, WIN_GEOHEIGHT, 'd')
|
|
|
|
-- recupero i tronchetti
|
|
local nLogLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_LOGS)
|
|
local vCrvIn = EgtGetNameInGroup( nLogLayerId, WIN_GEO_IN)
|
|
local vCrvOut = EgtGetNameInGroup( nLogLayerId, WIN_GEO_OUT)
|
|
local vLogs = {}
|
|
for i = 1, #vCrvIn do
|
|
-- creo il pezzo per il trochetto
|
|
local nPartId = EgtGroup( GDB_ID.ROOT)
|
|
EgtSetName( nPartId, WIN_LOGS)
|
|
EgtSetColor( nPartId, Color3d( 204, 102, 0))
|
|
EgtSetStatus( nPartId, GDB_ST.OFF)
|
|
table.insert( vLogs, nPartId)
|
|
|
|
local nCrvIn = vCrvIn[i]
|
|
local nCrvOut = vCrvOut[i]
|
|
local nLogCrv = EgtGetNext( nCrvOut)
|
|
|
|
-- setto le info con i sovramateriali corrispondenti
|
|
CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_IN, 0)
|
|
CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_OUT, 0)
|
|
CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_LEFT, 0)
|
|
CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_RIGHT, 0)
|
|
|
|
-- a) GEORAW
|
|
local nGeoRawLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nGeoRawLayerId, WIN_GEO_RAW)
|
|
local nGeoRawCrvId = EgtCopyGlob( nLogCrv, nGeoRawLayerId)
|
|
EgtModifyCurveThickness( nGeoRawCrvId, - dThick)
|
|
-- creo il frame ausiliario
|
|
local vtX = EgtSV( nLogCrv)
|
|
local frGeo = Frame3d( EgtSP( nLogCrv), vtX, Z_AX() ^ vtX, Z_AX())
|
|
local nFrameId = EgtFrame( nGeoRawLayerId, frGeo)
|
|
EgtSetName( nFrameId, WIN_PRC_FRAME)
|
|
|
|
-- b) SOLIDO
|
|
local nSolidId
|
|
if s_bCalcSolid then
|
|
local nSolidLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nSolidLayerId, WIN_SOLID)
|
|
if #vCrvIn == 1 then
|
|
-- essendo singolo pezzo il solido è quello originale
|
|
local nOrigSolidId = EgtGetFirstNameInGroup( nOrigSolidLayerId, WIN_SRF_MAIN)
|
|
EgtCopyGlob( nOrigSolidId, nSolidLayerId)
|
|
elseif bFinishedLogs then
|
|
-- recupero il solido originale e lo taglio opportunamente agli estremi
|
|
local nOrigSolidId = EgtGetFirstNameInGroup( nOrigSolidLayerId, WIN_SRF_MAIN)
|
|
nSolidId = EgtCopyGlob( nOrigSolidId, nSolidLayerId)
|
|
|
|
local bBox = GetProfileLocalBox( nProfileId)
|
|
local dDimY = bBox:getDimY()
|
|
if i ~= 1 then
|
|
local nTrimCrv = EgtLine( nSolidLayerId, EgtUP( nLogCrv, 2), EgtUP( nLogCrv, 1))
|
|
EgtMove( nTrimCrv, Z_AX())
|
|
local nTrimSrf = EgtSurfTmByExtrusion( nSolidLayerId, nTrimCrv, - Z_AX() * ( dDimY + 2), WIN_SURF_APPROX)
|
|
EgtSurfTmIntersect( nSolidId, nTrimSrf)
|
|
EgtErase( { nTrimCrv, nTrimSrf})
|
|
end
|
|
if i ~= #vCrvIn then
|
|
local nTrimCrv = EgtLine( nSolidLayerId, EgtSP( nLogCrv), EgtUP( nLogCrv, 3))
|
|
EgtMove( nTrimCrv, Z_AX())
|
|
local nTrimSrf = EgtSurfTmByExtrusion( nSolidLayerId, nTrimCrv, - Z_AX() * ( dDimY + 2), WIN_SURF_APPROX)
|
|
EgtSurfTmIntersect( nSolidId, nTrimSrf)
|
|
EgtErase( { nTrimCrv, nTrimSrf})
|
|
end
|
|
else
|
|
-- il solido è esattamente il tronchetto
|
|
local bBox = GetProfileLocalBox( nProfileId)
|
|
nSolidId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nLogCrv, - bBox:getDimY() * Z_AX())
|
|
EgtSetName( nSolidId, WIN_SOLID)
|
|
end
|
|
end
|
|
|
|
-- c) LAVORAZIONI
|
|
-- se unico tronchetto le lavorazioni sono quelle del pezzo originale
|
|
if #vCrvIn == 1 then
|
|
EgtRelocateGlob( nOrigProcLayerId, nPartId)
|
|
EgtSetStatus( nOrigProcLayerId, GDB_ST.ON)
|
|
return
|
|
end
|
|
|
|
local nProcLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nProcLayerId, WIN_PRC)
|
|
|
|
-- profili in e out
|
|
if bFinishedLogs then
|
|
local nCrvInCopy = EgtCopyGlob( nCrvIn, nProcLayerId)
|
|
local nSemiProfileInId = EgtGetInfo( nCrvInCopy, WIN_SEMI_PROFILE, 'i')
|
|
GetProcessingInfoFromSemiProfile( nCrvInCopy, nSemiProfileInId)
|
|
EgtSetStatus( nCrvInCopy, GDB_ST.ON)
|
|
local nCrvOutCopy = EgtCopyGlob( nCrvOut, nProcLayerId)
|
|
local nSemiProfileOutId = EgtGetInfo( nCrvOutCopy, WIN_SEMI_PROFILE, 'i')
|
|
GetProcessingInfoFromSemiProfile( nCrvOutCopy, nSemiProfileOutId)
|
|
EgtSetStatus( nCrvOutCopy, GDB_ST.ON)
|
|
end
|
|
|
|
-- profilo left
|
|
if i == #vCrvIn and bFinishedLogs then
|
|
-- recupero la curva di lavorazione dal pezzo originale
|
|
local nLeftPrc = EgtGetFirstNameInGroup( nOrigProcLayerId, WIN_GEO_LEFT)
|
|
EgtRelocateGlob( nLeftPrc, nProcLayerId)
|
|
elseif i ~= #vCrvIn then
|
|
-- minizinken
|
|
local nLeftId = EgtLine( nProcLayerId, EgtUP( nLogCrv, 3), EgtSP( nLogCrv))
|
|
EgtSetName( nLeftId, WIN_LEFT)
|
|
-- assegno le info di lavorazione
|
|
EgtSetInfo( nLeftId, WIN_PRC_NTOOLS, 1)
|
|
local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME)
|
|
EgtSetInfo( nLeftId, WIN_PRC_TOOL_NAME .. '_1', sToolName)
|
|
local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd')
|
|
-- TO DO : verificare valore OffsR
|
|
EgtSetInfo( nLeftId, WIN_PRC_OFFR .. '_1', dOffR)
|
|
local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_1', 'd')
|
|
EgtSetInfo( nLeftId, WIN_PRC_OFFL .. '_1', dOffL)
|
|
end
|
|
|
|
-- profilo right
|
|
if i == 1 and bFinishedLogs then
|
|
-- recupero la curva di lavorazione dal pezzo originale
|
|
local nRightPrc = EgtGetFirstNameInGroup( nOrigProcLayerId, WIN_GEO_RIGHT)
|
|
EgtRelocateGlob( nRightPrc, nProcLayerId)
|
|
elseif i ~= 1 then
|
|
-- minizinken
|
|
local nRightId = EgtLine( nProcLayerId, EgtUP( nLogCrv, 1), EgtUP( nLogCrv, 2))
|
|
EgtSetName( nRightId, WIN_RIGHT)
|
|
-- assegno info di lavorazione
|
|
EgtSetInfo( nRightId, WIN_PRC_NTOOLS, 1)
|
|
local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME)
|
|
EgtSetInfo( nRightId, WIN_PRC_TOOL_NAME .. '_1', sToolName)
|
|
local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd')
|
|
-- TO DO : verificare valore OffsR
|
|
EgtSetInfo( nRightId, WIN_PRC_OFFR .. '_1', dOffR)
|
|
local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_2', 'd')
|
|
EgtSetInfo( nRightId, WIN_PRC_OFFL .. '_1', dOffL)
|
|
end
|
|
|
|
-- dowels per incastro dei tronchetti
|
|
if i ~= 1 then
|
|
CalcLogDowel( nOrigPartId, nCrvOut, false, nProcLayerId, nProfileId, nInfoGrp, nSolidId)
|
|
end
|
|
if i ~= #vCrvIn then
|
|
CalcLogDowel( nOrigPartId, nCrvOut, true, nProcLayerId, nProfileId, nInfoGrp, nSolidId)
|
|
end
|
|
|
|
-- se i tronchetti sono gestiti come pezzi finiti cerco le lavorazioni del pezzo orginale che appartengono al tronchetto
|
|
if bFinishedLogs then
|
|
local vProcessings = EgtGetAllInGroup( nOrigProcLayerId)
|
|
local nSurfTest = EgtSurfFlatRegion( nProcLayerId, nLogCrv)
|
|
for i = 1, #vProcessings do
|
|
local sPrcType = EgtGetInfo( vProcessings[i], WIN_PRC_FEATURE_TYPE)
|
|
-- forature
|
|
if sPrcType == WIN_PRC_TYPE.HOLE then
|
|
local sSide = EgtGetInfo( vProcessings[i], WIN_PRC_SIDE)
|
|
-- se dowel sull'estremo lo assegno direttamente al tronchetto corrispondente
|
|
if ( sSide == WIN_PRC_SIDETYPE.LEFT and i == #vCrvIn) or ( sSide == WIN_PRC_SIDETYPE.RIGHT and i == 1) then
|
|
EgtRelocateGlob( vProcessings[i], nProcLayerId)
|
|
end
|
|
-- altrimenti verifico se interno al tronchetto corrente
|
|
if sSide == WIN_PRC_SIDETYPE.IN then
|
|
local _, _, nSide = EgtPointCurveDistSide( EgtCP( vProcessings[i]), nLogCrv, Z_AX())
|
|
if nSide == -1 then
|
|
-- copio perchè la stessa lavorazione potrebbe coinvolgere più tronchetti
|
|
EgtCopyGlob( vProcessings[i], nProcLayerId)
|
|
else
|
|
-- verifico anche la faccia di fondo
|
|
local vtExtr = EgtCurveExtrusion( vProcessings[i])
|
|
local dThickness = EgtCurveThickness( vProcessings[i])
|
|
_, _, nSide = EgtPointCurveDistSide( EgtCP( vProcessings[i]) + dThickness * vtExtr, nLogCrv, Z_AX())
|
|
if nSide == -1 then
|
|
EgtCopyGlob( vProcessings[i], nProcLayerId)
|
|
end
|
|
end
|
|
end
|
|
-- fermavetro
|
|
elseif sPrcType == WIN_PRC_TYPE.STRIP_CUT then
|
|
-- TO DO da sistemare
|
|
local nStrip = EgtCopyGlob( vProcessings[i], nProcLayerId)
|
|
EgtTrimCurveWithRegion( nStrip, nSurfTest, true, false)
|
|
else
|
|
-- TO DO lavorazioni legate alla ferramenta, cambio profilo
|
|
end
|
|
end
|
|
EgtErase( nSurfTest)
|
|
end
|
|
end
|
|
|
|
-- salvo nel pezzo ad arco i pezzi dei tronchetti associati
|
|
EgtSetInfo( nOrigPartId, WIN_LOGS, vLogs)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che crea gli elementi ausiliari per la creazione del grezzo nell'automatismo delle lavorazioni
|
|
local function CalcGeoRawFromLogs( nPartId)
|
|
|
|
-- svuoto il GeoRaw per ricalcolarlo
|
|
local nGeoRawLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO_RAW)
|
|
EgtEmptyGroup( nGeoRawLayerId)
|
|
|
|
-- recupero i vari tronchetti
|
|
local nLogGrp = EgtGetFirstNameInGroup( nPartId, WIN_LOGS)
|
|
local vLogCrvs = EgtGetNameInGroup( nLogGrp, WIN_LOGS)
|
|
|
|
-- salvo le info di sovramateriale nel pezzo
|
|
CopyInfo( nPartId, vLogCrvs[1], WIN_PRC_OVERMAT_IN, 0)
|
|
CopyInfo( nPartId, vLogCrvs[1], WIN_PRC_OVERMAT_OUT, 0)
|
|
local nOvermatLateral = EgtGetInfo( vLogCrvs[1], WIN_PRC_OVERMAT_RIGHT, 'd')
|
|
EgtSetInfo( nPartId, WIN_PRC_OVERMAT_RIGHT, nOvermatLateral)
|
|
EgtSetInfo( nPartId, WIN_PRC_OVERMAT_LEFT, nOvermatLateral)
|
|
|
|
-- costruisco il grezzo a partire dai tronchetti
|
|
local vCrvs = {}
|
|
local vIdIn = {}
|
|
-- recupero le curve in e out dei tronchetti
|
|
for i = #vLogCrvs, 1, -1 do
|
|
local nLineOut = EgtLine( nGeoRawLayerId, EgtUP( vLogCrvs[i], 0), EgtUP( vLogCrvs[i], 1))
|
|
local nLineIn = EgtLine( nGeoRawLayerId, EgtUP( vLogCrvs[i], 2), EgtUP( vLogCrvs[i], 3))
|
|
table.insert( vCrvs, nLineOut)
|
|
table.insert( vIdIn, nLineIn)
|
|
end
|
|
local nLineR = EgtLine( nGeoRawLayerId, EgtEP( vCrvs[#vCrvs]), EgtSP( vIdIn[#vIdIn]))
|
|
table.insert( vCrvs, nLineR)
|
|
for i = #vIdIn, 1, -1 do
|
|
table.insert( vCrvs, vIdIn[i])
|
|
end
|
|
local nLineL = EgtLine( nGeoRawLayerId, EgtEP( vIdIn[1]), EgtSP( vCrvs[1]))
|
|
table.insert( vCrvs, nLineL)
|
|
|
|
-- taglio le curve nelle intersezioni ( va eliminato il sovramateriale per minizinken)
|
|
local nPrevId = vCrvs[#vCrvs]
|
|
local vPtInters = {}
|
|
for i = 1, #vCrvs do
|
|
vPtInters[i] = FindIntersectionPoint( nPrevId, vCrvs[i], EgtSP( vCrvs[i]))
|
|
nPrevId = vCrvs[i]
|
|
end
|
|
vPtInters[#vPtInters + 1] = vPtInters[1]
|
|
for i = 1, #vCrvs do
|
|
EgtExtendCurveStartByLen( vCrvs[i], 100)
|
|
EgtExtendCurveEndByLen( vCrvs[i], 100)
|
|
local dParS = EgtCurveParamAtPoint( vCrvs[i], vPtInters[i])
|
|
local dParE = EgtCurveParamAtPoint( vCrvs[i], vPtInters[i+1])
|
|
EgtTrimCurveStartEndAtParam( vCrvs[i], dParS, dParE)
|
|
end
|
|
|
|
-- costruisco la compo del grezzo
|
|
local nCompo = EgtCurveCompo( nGeoRawLayerId, vCrvs)
|
|
local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local dDimH = EgtGetInfo( nGeoLayerId, WIN_GEOHEIGHT, 'd')
|
|
EgtModifyCurveThickness( nCompo, - dDimH)
|
|
|
|
-- creo il frame ausiliario
|
|
local vtX = EgtSV( nCompo)
|
|
local frGeo = Frame3d( EgtSP( nCompo), vtX, Z_AX() ^ vtX, Z_AX())
|
|
local nFrameId = EgtFrame( nGeoRawLayerId, frGeo)
|
|
EgtSetName( nFrameId, WIN_PRC_FRAME)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola i tronchetti di un pezzo ad arco
|
|
function WinCalculate.CreateArcLogs( nPartId, nLogsNbr, vSections, bAlign, dOverMatOut, dOverMatIn, dOverMatExt, dOverMatInt, bCutExtremities)
|
|
|
|
-- verifico dati in ingresso
|
|
if bAlign then nLogsNbr = 0 end
|
|
if not bAlign and nLogsNbr == 0 and ( #vSections == 0 or #vSections > 1) then
|
|
return
|
|
end
|
|
|
|
-- recupero o creo il gruppo per i tronchetti
|
|
local nGrp = EgtGetFirstNameInGroup( nPartId, WIN_LOGS)
|
|
if not nGrp then
|
|
nGrp = EgtGroup( nPartId)
|
|
EgtSetName( nGrp, WIN_LOGS)
|
|
else
|
|
EgtEmptyGroup( nGrp)
|
|
end
|
|
|
|
-- recupero il geo del pezzo
|
|
local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local nGeoIn = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN)
|
|
local nGeoOut = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT)
|
|
|
|
-- spezzo l'arco interno
|
|
SplitArc( nLogsNbr, vSections, bAlign, dOverMatOut + dOverMatIn, nGeoIn, nGeoOut, nGrp)
|
|
|
|
-- calcolo la sezione di riferimento per i tronchetti
|
|
local dSection = CalcLogsSection( nLogsNbr, vSections, bAlign, dOverMatOut + dOverMatIn, nGeoIn, nGeoOut, nGrp)
|
|
if not dSection then
|
|
return
|
|
end
|
|
|
|
-- creo i tronchetti
|
|
CalcLogs( nGrp, nGeoOut, dOverMatIn, dOverMatOut, dOverMatExt, dOverMatInt, dSection, bCutExtremities)
|
|
|
|
-- TODO : recupero modalità di lavorazione dei tronchetti
|
|
local bFinishedLogs = false
|
|
|
|
-- creo i pezzi associati ai tronchetti
|
|
local vLogs = EgtGetInfo( nPartId, WIN_LOGS, 'vi') or {}
|
|
EgtErase( vLogs)
|
|
CalcLogParts( nPartId, bFinishedLogs)
|
|
if not bFinishedLogs then
|
|
-- sistemo il Georaw per il pezzo ad arco
|
|
CalcGeoRawFromLogs( nPartId)
|
|
else
|
|
-- TODO segnalare che il pezzo non va lavorato
|
|
end
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
---------------------------------- FERRAMENTA ----------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che disegna le cerniere
|
|
local function DrawHingesStd( nOutlineId, nSolidLayerId)
|
|
|
|
-- dimensioni cerniere
|
|
local dDimH = 16
|
|
local dDimV = 70
|
|
local dFilletRad = 5
|
|
|
|
local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i')
|
|
local dDelta = ( EgtSP( nOutlineId) - EgtSP( nBaseOutlineId)) * Z_AX()
|
|
if dDelta < GEO.EPS_SMALL then
|
|
return
|
|
end
|
|
local vtDir = EgtSV( nOutlineId)
|
|
local vtDirIn = Vector3d( vtDir)
|
|
vtDirIn:rotate( Z_AX(), -90)
|
|
|
|
-- prima cerniera
|
|
local pt1 = EgtSP( nOutlineId) - dDelta * Z_AX()
|
|
local nCompo = EgtCurveCompoFromPoints( nSolidLayerId, { pt1 + dFilletRad * vtDir, pt1 + ( dDimV - dFilletRad) * vtDir})
|
|
EgtAddCurveCompoArcTg( nCompo, pt1 + dDimV * vtDir + dFilletRad * vtDirIn)
|
|
EgtAddCurveCompoLine( nCompo, pt1 + dDimV * vtDir + ( dDimH - dFilletRad) * vtDirIn)
|
|
EgtAddCurveCompoArcTg( nCompo, pt1 + ( dDimV - dFilletRad) * vtDir + dDimH * vtDirIn)
|
|
EgtAddCurveCompoLine( nCompo, pt1 + dFilletRad * vtDir + dDimH * vtDirIn)
|
|
EgtAddCurveCompoArcTg( nCompo, pt1 + ( dDimH - dFilletRad) * vtDirIn)
|
|
EgtAddCurveCompoLine( nCompo, pt1 + dFilletRad * vtDirIn)
|
|
EgtAddCurveCompoArcTg( nCompo, EgtSP( nCompo))
|
|
local nStm1 = EgtSurfTmByRegionExtrusion( nSolidLayerId, nCompo, dDelta * Z_AX())
|
|
EgtSetColor( nStm1, Color3d( 128, 128, 128))
|
|
EgtSetName( nStm1, WIN_HDW_HINGES)
|
|
EgtErase( nCompo)
|
|
|
|
-- seconda cerniera
|
|
local pt2 = EgtEP( nOutlineId) - dDelta * Z_AX() - dDimV * vtDir
|
|
local nStm2 = EgtCopyGlob( nStm1, nSolidLayerId)
|
|
EgtMove( nStm2, pt2 - pt1)
|
|
|
|
-- correzioni per telai non rettangolari
|
|
local nFrameAreaId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*')
|
|
local nFrameType = EgtGetInfo( nFrameAreaId, WIN_FRAME_TYPE, 'i')
|
|
|
|
-- a) arco
|
|
if nFrameType == WIN_FRAME_TYPES.ROUND_ARC or nFrameType == WIN_FRAME_TYPES.SEGMENTAL_ARC then
|
|
local sName = EgtGetName( nOutlineId)
|
|
-- calcolo il delta da applicare ( euristico, calcolato in base ai risultati ferramenta)
|
|
local dDelta = 24 -- caso di arco a tutto sesto
|
|
local dDeltaSegArc = 54.7 -- caso di arco ribassato
|
|
if nFrameType == WIN_FRAME_TYPES.SEGMENTAL_ARC then
|
|
-- nel caso di arco ribassato il delta va calcolato rispetto al frame della ferramenta
|
|
local nAreaId = EgtGetParent( EgtGetParent( nOutlineId))
|
|
local nHdwFramesId = EgtGetFirstNameInGroup( nAreaId, WIN_HDW_FRAME)
|
|
local sFrameName = EgtIf( sName == WIN_LEFT, 'B*', 'C*')
|
|
local nFrameId = EgtGetFirstNameInGroup( nHdwFramesId, sFrameName)
|
|
if sName == WIN_LEFT then
|
|
dDelta = ( EgtSP( nFrameId) - EgtSP( nOutlineId)) * vtDir
|
|
else
|
|
dDelta = ( EgtEP( nOutlineId) - EgtSP( nFrameId)) * vtDir
|
|
end
|
|
dDelta = dDelta + dDeltaSegArc
|
|
end
|
|
|
|
-- traslazione
|
|
if sName == WIN_LEFT then
|
|
EgtMove( nStm1, dDelta * vtDir)
|
|
else
|
|
EgtMove( nStm2, - dDelta * vtDir)
|
|
end
|
|
|
|
-- b) trapezio
|
|
elseif nFrameType == WIN_FRAME_TYPES.CHAMFER_SIDE then
|
|
-- calcolo il delta da applicare. Euristico. Dal calcolo della ferramenta si vede che la cerniera si trova circa nel punto di intersezione tra nOutlineId e una retta inclinata
|
|
-- come il top e passante per il frame della ferramenta
|
|
local sName = EgtGetName( nOutlineId)
|
|
local nOutlineLayId = EgtGetParent( nOutlineId)
|
|
local nAreaId = EgtGetParent( nOutlineLayId)
|
|
local nHdwFramesId = EgtGetFirstNameInGroup( nAreaId, WIN_HDW_FRAME)
|
|
local sFrameName = EgtIf( sName == WIN_LEFT, 'B*', 'C*')
|
|
local nFrameId = EgtGetFirstNameInGroup( nHdwFramesId , sFrameName)
|
|
local nTopId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_TOP)
|
|
local vtTop = EgtSV( nTopId)
|
|
local ptRef = EgtIf( sName == WIN_LEFT, EgtSP( nOutlineId), EgtEP( nOutlineId))
|
|
local vtDist = EgtSP( nFrameId) - ptRef
|
|
local dDelta = ( vtDist ^ vtTop):len() / ( vtTop ^ vtDir):len()
|
|
|
|
if sName == WIN_LEFT then
|
|
EgtMove( nStm1, dDelta * vtDir)
|
|
else
|
|
EgtMove( nStm2, - dDelta * vtDir)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che disegna le cerniere per la preview ( posizionamento più grossolano e disegno 2d)
|
|
local function DrawHingesPreview( nOutlineId, nLayerId)
|
|
|
|
-- dimensioni cerniere
|
|
local dDimL = 80
|
|
local dDimW = 20
|
|
|
|
local vtDir = EgtSV( nOutlineId)
|
|
local vtDirIn = Vector3d( vtDir)
|
|
vtDirIn:rotate( Z_AX(), -90)
|
|
-- alzo leggermente la quota in z per evitare sovrapposizioni problematiche nell'eportazione svg
|
|
local frHinge = Frame3d( EgtSP( nOutlineId) + Z_AX(), vtDir, vtDirIn, - Z_AX())
|
|
|
|
-- prima cerniera
|
|
local nSfr1 = EgtSurfFrStadium( nLayerId, ORIG(), Point3d( dDimL, dDimW, 0))
|
|
EgtSetColor( nSfr1, Color3d( 128, 128, 128))
|
|
EgtTransform( nSfr1, frHinge)
|
|
EgtInvertSurf( nSfr1)
|
|
|
|
-- seconda cerniera
|
|
local pt2 = EgtEP( nOutlineId) - dDimL * vtDir
|
|
local nSfr2 = EgtCopyGlob( nSfr1, nLayerId)
|
|
EgtMove( nSfr2, pt2 - EgtSP( nOutlineId))
|
|
|
|
-- contorni
|
|
local nLoop1 = EgtExtractSurfFrChunkLoops( nSfr1, 0, nLayerId)
|
|
EgtSetColor( nLoop1, EgtStdColor( 'BLACK'))
|
|
local nLoop2 = EgtExtractSurfFrChunkLoops( nSfr2, 0, nLayerId)
|
|
EgtSetColor( nLoop2, EgtStdColor( 'BLACK'))
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function DrawHinges( nOutlineId, nLayerId, bPreview)
|
|
if bPreview then
|
|
DrawHingesPreview( nOutlineId, nLayerId)
|
|
else
|
|
DrawHingesStd( nOutlineId, nLayerId)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che disegna la maniglia
|
|
local function DrawHandleStd( nOutlineId, sHandleSide, dHandleH, nSolidLayerId, bSlide)
|
|
|
|
-- dati della maniglia
|
|
local dBase1T = 40
|
|
local dBase1B = 40
|
|
local dBase2 = 18
|
|
local dH = 9
|
|
local dLen1 = 53
|
|
local dLen2 = 115
|
|
local dRadH = 12.5
|
|
local dFillet = 10
|
|
local dExtraGapDelta = 15
|
|
if bSlide then
|
|
dBase1T = 50
|
|
dBase1B = 100
|
|
dBase2 = 18
|
|
dLen2 = 155
|
|
dRadH = 10
|
|
dExtraGapDelta = 35.5
|
|
end
|
|
|
|
local nPartId = EgtGetInfo( nOutlineId, WIN_REF_PART, 'i')
|
|
local ptRef = EgtIf( sHandleSide == 'Sx', EgtSP( nOutlineId), EgtEP( nOutlineId))
|
|
local vtDir = EgtIf( sHandleSide == 'Sx', EgtSV( nOutlineId), - EgtEV( nOutlineId))
|
|
local vtDirIn = Vector3d( vtDir)
|
|
vtDirIn:rotate( Z_AX(), EgtIf( sHandleSide == 'Sx', 90, -90))
|
|
|
|
-- recupero il riferimento rispetto a cui leggere l'altezza maniglia
|
|
local nProfileLayId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileLayId, EgtIf( sHandleSide == 'Sx', WIN_PRF_START, WIN_PRF_END))
|
|
local dGapHardware = EgtGetInfo( nProfileId, WIN_GAPDELTA, 'd')
|
|
-- recupero di quanto spostare la maniglia rispetto all'outline
|
|
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayId, WIN_PRF_MAIN)
|
|
local dGapDelta = EgtGetInfo( nMainProfileId, WIN_GAPDELTA, 'd')
|
|
local dDeltaIn = dGapDelta + dExtraGapDelta
|
|
|
|
-- punto su cui centrare la maniglia
|
|
local ptC = ptRef + ( dHandleH + dGapHardware) * vtDir + dDeltaIn * vtDirIn
|
|
|
|
local nCrv1 = EgtRectangle2P( nSolidLayerId, ptC - dBase1B * vtDir - dBase2 * vtDirIn, ptC + dBase1T * vtDir + dBase2 * vtDirIn)
|
|
local nStm1 = EgtSurfTmByRegionExtrusion( nSolidLayerId, {nCrv1}, dH * Z_AX())
|
|
|
|
local nCrv2 = EgtLinePVL( nSolidLayerId, ORIG(), X_AX(), dLen1 - dFillet)
|
|
local nCrv4 = EgtLinePVL( nSolidLayerId, Point3d( dLen1, -dFillet, 0), - Y_AX(), dLen2 - dFillet)
|
|
local nCrv3 = EgtArc2PR( nSolidLayerId, EgtEP( nCrv2), EgtSP( nCrv4), dFillet, false)
|
|
local nGuide = EgtCurveCompo( nSolidLayerId, { nCrv2, nCrv3, nCrv4})
|
|
local frTransf = Frame3d( ptC, Z_AX(), vtDir, Z_AX() ^ vtDir)
|
|
EgtTransform( nGuide, frTransf)
|
|
local nSection = EgtCircle( nSolidLayerId, EgtSP( nGuide), dRadH)
|
|
local nStm2 = EgtSurfTmSwept( nSolidLayerId, nSection, nGuide, true)
|
|
|
|
EgtSurfTmAdd( nStm1, nStm2)
|
|
EgtSetName( nStm1, WIN_HDW_HANDLE)
|
|
EgtSetColor( nStm1, Color3d( 128, 128, 128))
|
|
EgtErase( { nCrv1, nGuide, nSection, nStm2})
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- disegno della maniglia per preview
|
|
local function DrawHandlePreview( nOutlineId, sHandleSide, dHandleH, nLayerId, bSlide)
|
|
|
|
-- dati della maniglia
|
|
local dRad = 20
|
|
local dDimW = 20
|
|
local dDimH = 100
|
|
|
|
local ptRef = EgtIf( sHandleSide == 'Sx', EgtSP( nOutlineId), EgtEP( nOutlineId))
|
|
local vtDir = EgtIf( sHandleSide == 'Sx', - EgtSV( nOutlineId), EgtEV( nOutlineId))
|
|
local vtDirIn = Vector3d( vtDir)
|
|
vtDirIn:rotate( Z_AX(), EgtIf( sHandleSide == 'Sx', -90, 90))
|
|
|
|
-- recupero dati del profilo per centrare la maniglia sul pezzo
|
|
local nPartId = EgtGetInfo( nOutlineId, WIN_REF_PART, 'i')
|
|
local nProfileLayId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayId, WIN_PRF_MAIN)
|
|
local b3Profile = GetProfileLocalBox( nMainProfileId)
|
|
local dSide = 0.5 * b3Profile:getDimX()
|
|
|
|
-- punto su cui centrare la maniglia
|
|
local ptC = ptRef - dHandleH * vtDir + dSide * vtDirIn + Z_AX()
|
|
|
|
local nSfr1 = EgtSurfFrDisk( nLayerId, ptC, dRad)
|
|
EgtSetColor( nSfr1, Color3d( 128, 128, 128))
|
|
local nLoop = EgtExtractSurfFrChunkLoops( nSfr1, 0, nLayerId)
|
|
EgtSetColor( nLoop, EgtStdColor( 'BLACK'))
|
|
local nSfr2 = EgtSurfFrStadium( nLayerId, ORIG(), Point3d( dDimH, dDimW, 0))
|
|
local ptFrame = ptC + EgtIf( sHandleSide == 'Sx', 1, -1) * 0.5 * dDimW * vtDirIn + Z_AX()
|
|
local frHandle = Frame3d( ptFrame, vtDir, EgtIf( sHandleSide == 'Sx', - vtDirIn, vtDirIn), Z_AX())
|
|
EgtTransform( nSfr2, frHandle)
|
|
EgtSetColor( nSfr2, Color3d( 128, 128, 128))
|
|
local nLoop2 = EgtExtractSurfFrChunkLoops( nSfr2, 0, nLayerId)
|
|
EgtSetColor( nLoop2, EgtStdColor( 'BLACK'))
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function DrawHandle( nOutlineId, sHandleSide, dHandleH, nLayerId, bSlide, bPreview)
|
|
if bPreview then
|
|
DrawHandlePreview( nOutlineId, sHandleSide, dHandleH, nLayerId, bSlide)
|
|
else
|
|
DrawHandleStd( nOutlineId, sHandleSide, dHandleH, nLayerId, bSlide)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetHandleHeight( nAreaId)
|
|
|
|
-- verifico se è definita tra le opzioni
|
|
local vOptions = EgtGetInfo( nAreaId, WIN_HDW_OPTIONS, 'vs') or {}
|
|
for i = 1, #vOptions do
|
|
local vString = EgtSplitString( vOptions[i], '=')
|
|
if #vString == 2 and vString[1] == WIN_HDW_HANDLE_HEIGHT then
|
|
local dVal = tonumber( vString[2])
|
|
return dVal
|
|
end
|
|
end
|
|
|
|
-- chiedo il file di opzioni dalla ferramenta
|
|
local _, _, tOptions = WinCalculate.AddHardware( nAreaId, false, false, false, true)
|
|
if #tOptions > 0 then
|
|
-- lettura della stringa xml delle opzioni
|
|
local handler = XMLHandler:new()
|
|
local parser = XML.parser( handler)
|
|
parser:parse( tOptions[1])
|
|
local tabOptions = handler.root
|
|
-- cerco parametro altezza maniglia
|
|
for i = 1, #tabOptions['ParametriOpzioni']['Parametri'] do
|
|
if tabOptions['ParametriOpzioni']['Parametri'][i]['NomeParametro'] == WIN_HDW_HANDLE_HEIGHT then
|
|
local sHandleH = tabOptions['ParametriOpzioni']['Parametri'][i]['ValoreCorrente']
|
|
return tonumber( sHandleH)
|
|
end
|
|
end
|
|
end
|
|
|
|
return 500 -- restituisco valore di default
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che disegna la ferramenta
|
|
local function DrawSashHardware( nAreaId, nRefAreaId, nLayerId, bPreview)
|
|
|
|
local nOutlineLayId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local nOpeningType = EgtGetInfo( nAreaId, WIN_OPENING_TYPE, 'i')
|
|
|
|
if nOpeningType == WIN_OPENING_TYPES.NULL or nOpeningType == WIN_OPENING_TYPES.FIXED then
|
|
return
|
|
|
|
-- Vasistas
|
|
elseif nOpeningType == WIN_OPENING_TYPES.TILTONLY_TOP then
|
|
-- cerniere sul pezzo inferiore
|
|
local nBottomId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_BOTTOM)
|
|
DrawHinges( nBottomId, nLayerId, bPreview)
|
|
|
|
-- recupero lato maniglia
|
|
local vOptions = EgtGetInfo( nRefAreaId, WIN_HDW_OPTIONS, 'vs') or {}
|
|
local sHandleSide = 'Sx'
|
|
local nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_RIGHT)
|
|
for i = 1, #vOptions do
|
|
local vString = EgtSplitString( vOptions[i], '=')
|
|
if vString[1] == 'PosizioneManiglia' then
|
|
if vString[2] == 'destra' then
|
|
sHandleSide = 'Dx'
|
|
nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_LEFT)
|
|
elseif vString[2] == 'sopra' then
|
|
nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_TOP)
|
|
end
|
|
break
|
|
end
|
|
end
|
|
-- altezza maniglia è fissata a metà del lato ( con compensazione per frame di riferimento della ferramenta)
|
|
local nPartId = EgtGetInfo( nOutlineId, WIN_REF_PART, 'i')
|
|
local nProfileLayId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileLayId, EgtIf( sHandleSide == 'Sx', WIN_PRF_START, WIN_PRF_END))
|
|
local dGapHardware = EgtGetInfo( nProfileId, WIN_GAPDELTA, 'd')
|
|
local dHandleH = 0.5 * EgtCurveLength( nOutlineId) - dGapHardware
|
|
|
|
-- disegno maniglia
|
|
DrawHandle( nOutlineId, sHandleSide, dHandleH, nLayerId, false, bPreview)
|
|
|
|
-- Alzante scorrevole
|
|
elseif nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_LEFT or nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT or
|
|
nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_LEFT or nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_RIGHT then
|
|
|
|
local bLeftSlide = ( nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_LEFT or nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_LEFT)
|
|
local nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, EgtIf( bLeftSlide, WIN_RIGHT, WIN_LEFT))
|
|
local sHandleSide = EgtIf( bLeftSlide, 'Sx', 'Dx')
|
|
|
|
-- recupero altezza maniglia dalle opzioni
|
|
local dHandleH = GetHandleHeight( nRefAreaId)
|
|
|
|
DrawHandle( nOutlineId, sHandleSide, dHandleH, nLayerId, true, bPreview)
|
|
|
|
-- Standard
|
|
else
|
|
local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL
|
|
|
|
-- recupero pezzi interessati dalla ferramenta
|
|
local nLeftId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_LEFT)
|
|
local nRightId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_RIGHT)
|
|
|
|
-- recupero lato maniglia
|
|
local sHandleSide = EgtGetInfo( nRefAreaId, WIN_HDW_HANDLE)
|
|
|
|
-- cerniere
|
|
if nSashType == WIN_SASHTYPES.INACTIVE or nSashType == WIN_SASHTYPES.INACTIVE_OUT or
|
|
nSashType == WIN_SASHTYPES.ACTIVE or nSashType == WIN_SASHTYPES.ACTIVE_OUT then
|
|
-- le cerniere vanno messe sul lato che poggia sul telaio
|
|
local nBaseOutlineId = EgtGetInfo( nLeftId, WIN_COPY, 'i')
|
|
local bLeftInactive = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b') or false
|
|
DrawHinges( EgtIf( bLeftInactive, nRightId, nLeftId), nLayerId, bPreview)
|
|
|
|
elseif nSashType == WIN_SASHTYPES.NULL then
|
|
-- è il lato senza maniglia
|
|
if sHandleSide == 'Sx' then
|
|
DrawHinges( nLeftId, nLayerId, bPreview)
|
|
else
|
|
DrawHinges( nRightId, nLayerId, bPreview)
|
|
end
|
|
end
|
|
|
|
-- maniglia
|
|
if nSashType == WIN_SASHTYPES.ACTIVE or nSashType == WIN_SASHTYPES.ACTIVE_IN or nSashType == WIN_SASHTYPES.NULL then
|
|
-- recupero altezza maniglia
|
|
local dHandleH = GetHandleHeight( nRefAreaId)
|
|
if sHandleSide == 'Sx' then
|
|
DrawHandle( nRightId, sHandleSide, dHandleH, nLayerId, false, bPreview)
|
|
else
|
|
DrawHandle( nLeftId, sHandleSide, dHandleH, nLayerId, false, bPreview)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola i dati necessari per la ferramenta
|
|
local function SearchSash( nAreaId, SashList)
|
|
-- verifico il tipo
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
if nAreaType == WIN_AREATYPES.SASH then
|
|
|
|
-- creo gruppo temporaneo per i conti
|
|
local nOutlineOffsetLayerId = EgtGroup( nAreaId)
|
|
|
|
-- recupero gruppi dei profili
|
|
local nProfileId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileId, WIN_SASH)
|
|
local nFrameProfileLayerId = EgtGetFirstNameInGroup( nProfileId, WIN_FRAME)
|
|
|
|
-- creo gruppo per i riferimenti della ferramenta per l'anta
|
|
local nHdwSashLayerId = EgtGroup( nAreaId)
|
|
EgtSetName( nHdwSashLayerId, WIN_HDW_FRAME)
|
|
EgtSetStatus( nHdwSashLayerId, GDB_ST.OFF)
|
|
|
|
-- recupero o creo gruppo per i riferimenti della ferramenta per il telaio
|
|
local nFrameAreaId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*')
|
|
local nHdwFrameLayerId = EgtGetFirstNameInGroup( nFrameAreaId, WIN_HDW_FRAME)
|
|
if not nHdwFrameLayerId then
|
|
nHdwFrameLayerId = EgtGroup( nFrameAreaId)
|
|
EgtSetName( nHdwFrameLayerId, WIN_HDW_FRAME)
|
|
EgtSetStatus( nHdwFrameLayerId, GDB_ST.OFF)
|
|
end
|
|
|
|
-- verifico se alzante scorrevole
|
|
local bSlide = EgtGetInfo( nFrameAreaId, WIN_SLIDE_WINDOW, 'b') or false
|
|
|
|
-- ricostruisco gli outlines dell'anta in corrispondenza del canalino della ferramenta ( orgine dei riferimenti)
|
|
local vOutlineCopy = {}
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
local sProfileType = EgtGetInfo( nOutlineId, WIN_PROFILETYPE)
|
|
local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sProfileType)
|
|
local dGapDelta = EgtGetInfo( nSashProfileId, WIN_GAPDELTA, 'd')
|
|
local nOutlineCopyId = EgtCopy( nOutlineId, nOutlineOffsetLayerId)
|
|
EgtOffsetCurve( nOutlineCopyId, - dGapDelta)
|
|
table.insert( vOutlineCopy, nOutlineCopyId)
|
|
-- setto info ausiliarie sulla curva
|
|
EgtSetInfo( nOutlineCopyId, 'ORIG', nOutlineId)
|
|
CopyInfo( nOutlineCopyId, nSashProfileId, WIN_GAPDELTAZ)
|
|
local b3Profile = GetProfileLocalBox( nSashProfileId)
|
|
EgtSetInfo( nOutlineCopyId, WIN_GAPDELTAZ .. 2, b3Profile:getDimY())
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
vOutlineCopy = TrimOrderedCurves( vOutlineCopy)
|
|
|
|
-- costruisco i riferimenti
|
|
local tFrame = {}
|
|
for nIndex = 1, #vOutlineCopy do
|
|
-- 1) Riferimenti ANTA
|
|
local ptOrig = EgtEP( vOutlineCopy[nIndex])
|
|
local sOrigName = string.char( string.byte( 'A') + #vOutlineCopy - nIndex)
|
|
local vtDir = EgtEV( vOutlineCopy[nIndex])
|
|
local nFA1Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig, - vtDir, vtDir ^ Z_AX(), Z_AX()))
|
|
EgtSetName( nFA1Id, sOrigName .. '.FA1')
|
|
local vtIn = Vector3d( vtDir)
|
|
vtIn:rotate( Z_AX(), -90)
|
|
local dGapDeltaZ = EgtGetInfo( vOutlineCopy[nIndex], WIN_GAPDELTAZ, 'd')
|
|
local nFA2Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig - dGapDeltaZ * Z_AX(), - vtDir, vtDir ^ vtIn, vtIn))
|
|
EgtSetName( nFA2Id, sOrigName .. '.FA2')
|
|
local dGapDeltaZ2 = EgtGetInfo( vOutlineCopy[nIndex], WIN_GAPDELTAZ .. 2, 'd')
|
|
local nFA3Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig - dGapDeltaZ2 * Z_AX(), - vtDir, vtDir ^ -Z_AX(), -Z_AX()))
|
|
EgtSetName( nFA3Id, sOrigName .. '.FA3')
|
|
|
|
-- 2) Riferimenti TELAIO
|
|
-- ricavo elemento su cui poggia ( è il primo parent con un profilo associato. Potrebbe essere uno split in sottoarea del telaio o potrebbe non
|
|
-- esistere nel caso di french split)
|
|
local nOrigOutlineId = EgtGetInfo( vOutlineCopy[nIndex], 'ORIG', 'i')
|
|
local nBaseOutlineId = EgtGetInfo( nOrigOutlineId, WIN_COPY, 'i')
|
|
local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i')
|
|
local sProfileFrame = EgtGetInfo( nSouId, WIN_PROFILETYPE)
|
|
while nSouId and not sProfileFrame do
|
|
nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i')
|
|
sProfileFrame = EgtGetInfo( nSouId or GDB_ID.NULL, WIN_PROFILETYPE)
|
|
end
|
|
|
|
if nSouId then
|
|
-- ricavo aria lato telaio
|
|
local nFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileLayerId, sProfileFrame, 'i')
|
|
local dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA, 'd')
|
|
-- se deriva da split verifico il lato
|
|
if EgtGetName( nSouId) == WIN_SPLIT then
|
|
local bSameDir = AreSameVectorApprox( EgtSV( nSouId), EgtSV( nBaseOutlineId))
|
|
-- recupero informazione dal lato corretto ( split orizzontale)
|
|
if not dGapDeltaOut then
|
|
if bSameDir then
|
|
dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '2', 'd')
|
|
else
|
|
dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '1', 'd')
|
|
end
|
|
end
|
|
-- verifico il segno dell'offset
|
|
if not bSameDir then
|
|
dGapDeltaOut = - dGapDeltaOut
|
|
end
|
|
end
|
|
local nOutlineOutId = EgtCopy( nSouId, nOutlineOffsetLayerId)
|
|
EgtOffsetCurve( nOutlineOutId, - dGapDeltaOut)
|
|
-- recupero origine come proiezione sul telaio dell'origine dell'anta
|
|
local _, ptOrigFr = EgtPointCurveDist( ptOrig, nOutlineOutId)
|
|
if bSlide then
|
|
-- nel caso di alzante scorrevole l'origine non è proiettata
|
|
ptOrigFr = EgtEP( nOutlineOutId)
|
|
end
|
|
local nFT1Id = EgtFrame( nHdwFrameLayerId, Frame3d( ptOrigFr, - vtDir, vtDir ^ Z_AX(), Z_AX()))
|
|
EgtSetName( nFT1Id, sOrigName .. '.FT1')
|
|
table.insert( tFrame, nFT1Id)
|
|
local vtFrameIn = Vector3d( vtDir)
|
|
vtFrameIn:rotate( Z_AX(), 90)
|
|
local dFrameGapDeltaZ = EgtGetInfo( nFrameProfileId, WIN_GAPDELTAZ, 'd')
|
|
local nFT2Id = EgtFrame( nHdwFrameLayerId, Frame3d( ptOrigFr - dFrameGapDeltaZ * Z_AX(), - vtDir, vtDir ^ vtFrameIn, vtFrameIn))
|
|
EgtSetName( nFT2Id, sOrigName .. '.FT2')
|
|
table.insert( tFrame, nFT2Id)
|
|
local b3FrameProfile = GetProfileLocalBox( nFrameProfileId)
|
|
local dGapDeltaZ2 = b3FrameProfile:getDimY()
|
|
local nFT3Id = EgtFrame( nHdwFrameLayerId, Frame3d( ptOrigFr - dGapDeltaZ2 * Z_AX(), - vtDir, vtDir ^ -Z_AX(), -Z_AX()))
|
|
EgtSetName( nFT3Id, sOrigName .. '.FT3')
|
|
table.insert( tFrame, nFT3Id)
|
|
end
|
|
end
|
|
|
|
-- preparo tabella per l'anta con i dati necessari per la ferramenta
|
|
local tSash = { nAreaId = nAreaId}
|
|
-- calcolo in centro per ordinamento
|
|
local b3Outline = EgtGetBBox( nOutlineLayerId, GDB_BB.STANDARD)
|
|
tSash.ptCenter = b3Outline:getCenter()
|
|
-- calcolo le dimensioni
|
|
tSash.LHeight = EgtCurveLength( vOutlineCopy[4])
|
|
tSash.RHeight = EgtCurveLength( vOutlineCopy[2])
|
|
tSash.BWidth = EgtCurveLength( vOutlineCopy[1])
|
|
if EgtGetType( vOutlineCopy[3]) == GDB_TY.CRV_ARC then
|
|
-- tSash.BCLength = EgtCurveLength( vOutlineCopy[3]) -- in alternativa a BCArrow, è il parametro LBBA nel file di richiesta
|
|
tSash.BCArrow = dist( EgtMP( vOutlineCopy[3]), 0.5 * ( EgtEP( vOutlineCopy[3]) + EgtSP( vOutlineCopy[3])))
|
|
end
|
|
-- salvo i frame del telaio associati
|
|
tSash.Frame = tFrame
|
|
table.insert( SashList, tSash)
|
|
|
|
EgtErase( nOutlineOffsetLayerId)
|
|
end
|
|
|
|
-- verifico se ci sono sotto-aree
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
-- lancio costruzione pezzi di quell'area
|
|
SearchSash( nChildAreaId, SashList)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola le lavorazioni dell'hardware
|
|
local function CalcHdwMachining( tMachining, SashList)
|
|
local nFrameAreaId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*')
|
|
local nHdwFrameLayerId = EgtGetFirstNameInGroup( nFrameAreaId, WIN_HDW_FRAME)
|
|
for i = 1, #tMachining do
|
|
local sPart = tMachining[i]['WindowPart']
|
|
local nSashIndex = tMachining[i]['SashIndex']
|
|
local sSashPart = tMachining[i]['SashPart']
|
|
local dPosX = tMachining[i]['PosX']
|
|
local dPosY = tMachining[i]['PosY']
|
|
local dPosZ = tMachining[i]['PosZ']
|
|
local sMacro = tMachining[i]['Macro']
|
|
local sSide = tMachining[i]['Side'] -- FT1, FT2, FT3, FA1, FA2, FA3
|
|
local sOrigin = tMachining[i]['Origin'] -- AB, BC, CD, DA
|
|
|
|
local nSashId = SashList[nSashIndex].nAreaId
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nSashId, WIN_OUTLINE)
|
|
local vOutlineIds = EgtGetAllInGroup( nOutlineLayerId)
|
|
local nA = string.byte( 'A')
|
|
local nSashPart = string.byte( sSashPart)
|
|
local nOutlineIndex = #vOutlineIds - ( nSashPart - nA)
|
|
local nOutlineId = vOutlineIds[nOutlineIndex]
|
|
local nPartId = GDB_ID.NULL
|
|
local frHdw
|
|
if sPart == 'TELAIO' then
|
|
local nSashBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i')
|
|
local nSouId = EgtGetInfo( nSashBaseOutlineId, WIN_SOU, 'i')
|
|
local sSouProfile = EgtGetInfo( nSouId, WIN_PROFILETYPE)
|
|
while nSouId and not sSouProfile do
|
|
nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i')
|
|
sSouProfile = EgtGetInfo( nSouId or GDB_ID.NULL, WIN_PROFILETYPE)
|
|
end
|
|
local nFrameOutlineId = EgtGetInfo( nSouId, WIN_COPY, 'i')
|
|
nPartId = EgtGetInfo( nFrameOutlineId, WIN_REF_PART, 'i')
|
|
local nHdwFrameId = EgtGetLastNameInGroup( nHdwFrameLayerId, nSashIndex .. '.' .. sSashPart .. '.' .. sSide)
|
|
frHdw = EgtFR( nHdwFrameId)
|
|
elseif sPart == 'ANTA' then
|
|
nPartId = EgtGetInfo( nOutlineId, WIN_REF_PART, 'i')
|
|
local nHdwFrameLayerId = EgtGetFirstNameInGroup( nSashId, WIN_HDW_FRAME)
|
|
local nHdwFrameId = EgtGetLastNameInGroup( nHdwFrameLayerId, sSashPart .. '.' .. sSide)
|
|
frHdw = EgtFR( nHdwFrameId)
|
|
end
|
|
|
|
local nProcLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PRC)
|
|
|
|
-- recupero solido ( se non calcolato non vengono utilizzate)
|
|
local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) or GDB_ID.NULL
|
|
local nMainExtrusionId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_SRF_MAIN)
|
|
local nOrigMainId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_SRF_ORIGMAIN)
|
|
|
|
-- calcolo il punto centrale della lavorazione
|
|
local ptCenter = Point3d( dPosX, dPosY, dPosZ)
|
|
|
|
-- gestione particolare per traverso superiore ad arco
|
|
if EgtGetType( nOutlineId) == GDB_TY.CRV_ARC then
|
|
local nProfileLayId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileLayId, WIN_PRF_MAIN)
|
|
|
|
-- calcolo outline del telaio sul canalino della ferramenta
|
|
local nRefOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
|
local nOffsetId = EgtCopyGlob( nRefOutlineId, nPartId)
|
|
local dGapDelta = EgtGetInfo( nProfileId, WIN_GAPDELTA, 'd')
|
|
EgtOffsetCurve( nOffsetId, - dGapDelta)
|
|
|
|
-- recupero origine sulla curva di offset a partire dai frame dell'anta
|
|
local nHdwSashLayerId = EgtGetFirstNameInGroup( nSashId, WIN_HDW_FRAME)
|
|
local sHdwName = EgtIf( sOrigin == 'AB', 'B', 'C') .. '.FA1'
|
|
local nHdwSashId = EgtGetLastNameInGroup( nHdwSashLayerId, sHdwName)
|
|
local _, _, dParRef = EgtPointCurveDist( EgtSP( nHdwSashId), nOffsetId)
|
|
local dLen = EgtCurveLengthAtParam( nOffsetId, dParRef)
|
|
dLen = dLen + dPosX
|
|
local dPar = EgtCurveParamAtLength( nOffsetId, dLen)
|
|
local ptOrig = EgtUP( nOffsetId, dPar)
|
|
|
|
-- ricostruisco il frame in base alla nuova origine
|
|
local vtDir = EgtUV( nOffsetId, dPar, -1)
|
|
if sSide == 'FT1' or sSide == 'FA1' then
|
|
frHdw = Frame3d( ptOrig, - vtDir, vtDir ^ Z_AX(), Z_AX())
|
|
elseif sSide == 'FT2' or sSide == 'FA2' then
|
|
local vtDirIn = Vector3d( vtDir)
|
|
vtDirIn:rotate( Z_AX(), 90)
|
|
local dFrameGapDeltaZ = EgtGetInfo( nProfileId, WIN_GAPDELTAZ, 'd')
|
|
frHdw = Frame3d( ptOrig - dFrameGapDeltaZ * Z_AX(), - vtDir, vtDir ^ vtDirIn, vtDirIn)
|
|
elseif sSide == 'FT3' or sSide == 'FA3' then
|
|
local b3FrameProfile = GetProfileLocalBox( nProfileId)
|
|
local dGapDeltaZ2 = b3FrameProfile:getDimY()
|
|
frHdw = Frame3d( ptOrig - dGapDeltaZ2 * Z_AX(), - vtDir, vtDir ^ -Z_AX(), -Z_AX())
|
|
end
|
|
|
|
-- calcolo il centro della lavorazione riferito al nuovo frame
|
|
ptCenter = Point3d( 0, dPosY, dPosZ)
|
|
|
|
EgtErase( nOffsetId)
|
|
end
|
|
|
|
local vMacro = EgtSplitString( sMacro, '_')
|
|
if vMacro[1] == 'FRESATA' then
|
|
elseif vMacro[1] == 'ASOLA' or vMacro[1] == 'MANIGLIA' then
|
|
|
|
local dLength, dWidth, dHeight
|
|
if vMacro[1] == 'ASOLA' then
|
|
dLength = tonumber( vMacro[2])
|
|
dWidth = tonumber( vMacro[3])
|
|
dHeight = tonumber( vMacro[4])
|
|
-- NB in alcune macro ASOLA il secondo parametro non è la width ma la width/2 !
|
|
-- TODO Al momento sembra che questo avvenga solo quando il suo valore è 8. Da verificare
|
|
if abs( dWidth - 8) < GEO.EPS_SMALL then
|
|
dWidth = dWidth * 2
|
|
end
|
|
elseif vMacro[1] == 'MANIGLIA' and vMacro[2] == '160' then
|
|
-- macro speciale che corrisponde ad ASOLA_216_12_56 quindi forzo direttamente i valori
|
|
-- TODO gestione di queste macro non parlanti
|
|
dLength = 216
|
|
dWidth = 12
|
|
dHeight = 56
|
|
elseif vMacro[1] == 'MANIGLIA' then -- and vMacro[2] == '15'
|
|
-- corrisponde ad ASOLA_69_12_30
|
|
dLength = 69
|
|
dWidth = 12
|
|
dHeight = 30
|
|
end
|
|
local ptP1 = ptCenter + ( dLength / 2 - dWidth / 2) * X_AX() + dWidth / 2 * Y_AX()
|
|
local ptP2 = ptCenter - ( dLength / 2 - dWidth / 2) * X_AX() + dWidth / 2 * Y_AX()
|
|
local nPocketOutlineId = EgtCurveCompoFromPoints( nProcLayerId, { ptP1, ptP2})
|
|
EgtAddCurveCompoArcTg( nPocketOutlineId, ptCenter - ( dLength / 2 - dWidth / 2) * X_AX() - dWidth / 2 * Y_AX())
|
|
EgtAddCurveCompoArcTg( nPocketOutlineId, ptCenter + ( dLength / 2 - dWidth / 2) * X_AX() - dWidth / 2 * Y_AX(), false)
|
|
EgtCloseCurveCompo( nPocketOutlineId)
|
|
EgtSetColor( nPocketOutlineId, EgtStdColor( 'GRAY'))
|
|
-- setto info di lavorazione
|
|
EgtSetInfo( nPocketOutlineId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
|
|
EgtSetInfo( nPocketOutlineId, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC)
|
|
EgtSetInfo( nPocketOutlineId, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.IN)
|
|
EgtModifyCurveExtrusion( nPocketOutlineId, Z_AX())
|
|
EgtModifyCurveThickness( nPocketOutlineId, - dHeight)
|
|
-- porto la lavorazione in globale
|
|
EgtTransform( nPocketOutlineId, frHdw)
|
|
-- aggiornamento del solido
|
|
if s_bCalcSolid then
|
|
UpdateSolidWithProcessingSurf( nPocketOutlineId, nMainExtrusionId, nSolidLayerId)
|
|
end
|
|
|
|
elseif vMacro[1] == 'TASCA' then
|
|
elseif vMacro[1] == 'VITE' then
|
|
local dRadius = 1.5
|
|
local dDepth = 2
|
|
if vMacro[2] == 'CANALINO' then
|
|
dRadius = 2
|
|
dDepth = 3
|
|
elseif vMacro[2] == 'ANTA' then
|
|
dRadius = 2.5
|
|
dDepth = 4
|
|
end
|
|
local nHoleId = EgtCircle( nProcLayerId, ptCenter, dRadius)
|
|
EgtMove( nHoleId, Z_AX())
|
|
EgtModifyCurveExtrusion( nHoleId, Z_AX())
|
|
EgtModifyCurveThickness( nHoleId, - ( dDepth + 1))
|
|
EgtTransform( nHoleId, frHdw)
|
|
EgtSetInfo( nHoleId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE)
|
|
|
|
elseif vMacro[1] == 'FORO' then
|
|
local sDiameter = EgtReplaceString( vMacro[2], 'D', '')
|
|
local dRadius = tonumber( sDiameter) / 2
|
|
local nHoleId = EgtCircle( nProcLayerId, ptCenter, dRadius)
|
|
-- setto info di lavorazione
|
|
EgtModifyCurveExtrusion( nHoleId, Z_AX())
|
|
-- TODO : come gestire profondità non definita?
|
|
local dDepth = tonumber(25)
|
|
if #vMacro == 3 then
|
|
dDepth = tonumber( vMacro[3])
|
|
end
|
|
EgtModifyCurveThickness( nHoleId, - dDepth)
|
|
EgtSetColor( nHoleId, EgtStdColor( 'GRAY'))
|
|
EgtSetInfo( nHoleId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE)
|
|
-- porto la lavorazione in globale
|
|
EgtTransform( nHoleId, frHdw)
|
|
-- aggiornamento del solido
|
|
if s_bCalcSolid then
|
|
UpdateSolidWithProcessingSurf( nHoleId, nMainExtrusionId, nSolidLayerId)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che aggiunge l'hardware
|
|
local function AddHardwareForSash( nFrameId, nReturnMode, OutputKitList, OutputPositionList, OutputOptionList)
|
|
-- cerco ed indicizzo ante del serramento
|
|
local SashList = {}
|
|
SearchSash( nFrameId, SashList)
|
|
|
|
-- ordino per X e Y
|
|
local function compareXY(a,b)
|
|
if abs( a.ptCenter:getX() - b.ptCenter:getX()) < GEO.EPS_SMALL then
|
|
return a.ptCenter:getY() < b.ptCenter:getY()
|
|
else
|
|
return a.ptCenter:getX() < b.ptCenter:getX()
|
|
end
|
|
end
|
|
table.sort( SashList, compareXY)
|
|
|
|
-- correggo nomi Frame del telaio in base all'ordinamento delle ante
|
|
for nIndex = 1, #SashList do
|
|
for nFrameIndex = 1, #SashList[nIndex].Frame do
|
|
local nFrameId = SashList[nIndex].Frame[nFrameIndex]
|
|
local sName = EgtGetName( nFrameId)
|
|
EgtSetName( nFrameId, nIndex .. '.' .. sName)
|
|
end
|
|
end
|
|
|
|
-- recupero preferito della ferramenta
|
|
local nFavourite = EgtGetInfo( nFrameId, WIN_HDW_FAVOURITE)
|
|
if not nFavourite or nFavourite == WIN_HDW_NULL then
|
|
EgtOutLog('Warning! No hardware favourite set!')
|
|
return
|
|
end
|
|
local sHandle = EgtGetInfo( nFrameId, WIN_HDW_HANDLE)
|
|
if not sHandle then
|
|
EgtOutLog('Warning! No hardware handle set!')
|
|
return
|
|
end
|
|
|
|
local sText = 'S_NAME=' .. nFavourite .. '\n' ..
|
|
'RECORDID=15A' .. '\n'
|
|
|
|
-- recupero il tipo di apertura
|
|
local nOpeningType = WIN_OPENING_TYPES.NULL
|
|
if #SashList > 0 then
|
|
nOpeningType = EgtGetInfo( SashList[1].nAreaId, WIN_OPENING_TYPE, 'i')
|
|
end
|
|
-- recupero se scorrevole
|
|
local bSlide = EgtGetInfo( nFrameId, WIN_SLIDE_WINDOW, 'b') or false
|
|
|
|
if bSlide then
|
|
-- le dimensioni per alzante scorrevole sono quelle del telaio
|
|
local nOutlineLayId = EgtGetFirstInGroup( nFrameId, WIN_AREAOUTLINE)
|
|
local nBottomId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_BOTTOM)
|
|
local dMet = EgtCurveLength( nBottomId)
|
|
local nLeftId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_LEFT)
|
|
local dHet = EgtCurveLength( nLeftId)
|
|
sText = sText .. 'MET=' .. tostring( dMet) .. '\n'
|
|
sText = sText .. 'HET=' .. tostring( dHet) .. '\n'
|
|
|
|
else
|
|
if #SashList >= 1 and abs( SashList[1].LHeight - SashList[1].RHeight) < GEO.EPS_SMALL then
|
|
sText = sText .. 'HBB=' .. tostring( SashList[1].LHeight) .. '\n'
|
|
else
|
|
for nSashIndex = 1, #SashList do
|
|
if nSashIndex == 1 then
|
|
sText = sText .. 'HBB_sx=' .. tostring( SashList[nSashIndex].LHeight) .. '\n'
|
|
else
|
|
sText = sText .. 'HBB_' .. tostring( nSashIndex - 1) .. 'B=' .. tostring( SashList[nSashIndex].LHeight) .. '\n'
|
|
end
|
|
if nSashIndex == #SashList then
|
|
sText = sText .. 'HBB_dx=' .. tostring( SashList[nSashIndex].RHeight) .. '\n'
|
|
else
|
|
sText = sText .. 'HBB_' .. tostring( nSashIndex) .. '=' .. tostring( SashList[nSashIndex].RHeight) .. '\n'
|
|
end
|
|
end
|
|
end
|
|
|
|
if #SashList == 1 then
|
|
sText = sText .. 'LBB=' .. tostring( SashList[1].BWidth) .. '\n'
|
|
if SashList[1].BCArrow then
|
|
sText = sText .. 'FRECCIA_1=' .. tostring( SashList[1].BCArrow) .. '\n'
|
|
end
|
|
else
|
|
for nSashIndex = 1, #SashList do
|
|
sText = sText .. 'LBB' .. nSashIndex .. '=' .. tostring( SashList[nSashIndex].BWidth) .. '\n'
|
|
if SashList[nSashIndex].BCArrow then
|
|
sText = sText .. 'FRECCIA_' .. nSashIndex .. '=' .. tostring( SashList[nSashIndex].BCArrow) .. '\n'
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
sText = sText .. 'FINESTRAPORTAFINESTRA=Finestra' .. '\n' ..
|
|
'Q=1' .. '\n'
|
|
|
|
-- opzione manoserramento ( non per vasistas altrimenti sovrascrive l'opzione)
|
|
if nOpeningType ~= WIN_OPENING_TYPES.TILTONLY_TOP then
|
|
sText = sText .. 'MANOSERRAMENTO=' .. sHandle .. '\n'
|
|
end
|
|
|
|
local vOptions = EgtGetInfo( nFrameId, WIN_HDW_OPTIONS, 'vs') or {}
|
|
for i = 1, #vOptions do
|
|
sText = sText .. vOptions[i] .. '\n'
|
|
end
|
|
|
|
-- Canali
|
|
local QuestionChannel = "EgwHardwareQuestion"
|
|
local AnswerChannel = "EgwHardwareAnswer" .. os.time()
|
|
|
|
local Question = { nThreadIndex = 0,
|
|
nId = 2,
|
|
ExecEnvironment = 1,
|
|
Args = { UID = 0,
|
|
OutputChannel = AnswerChannel,
|
|
Mode = 3,
|
|
SubMode = 2,
|
|
Manufacturer = 1,
|
|
ReturnMode = nReturnMode,
|
|
Input = sText}}
|
|
|
|
local JsonQuestion = JSON:encode( Question)
|
|
|
|
local bOk = EgtRedisAsyncPublish( s_nRedisConnectionId, QuestionChannel, JsonQuestion)
|
|
local AnswerArgs
|
|
if bOk then
|
|
-- EgtOutLog( 'Messaggio Redis pubblicato:' .. QuestionChannel .. ' ' .. JsonQuestion)
|
|
EgtOutLog( 'Messaggio Redis pubblicato')
|
|
local bOk, Answer = EgtRedisAsyncSubscribeOneMessage( s_nRedisConnectionId, AnswerChannel, 5000)
|
|
if bOk then
|
|
-- EgtOutLog( 'Risposta Redis ricevuta:' .. Answer)
|
|
EgtOutLog( 'Risposta Redis ricevuta')
|
|
local JsonAnswer = JSON:decode( Answer)
|
|
AnswerArgs = JsonAnswer['Args']
|
|
AnswerArgs.OutputChannel = nil
|
|
else
|
|
EgtOutLog( 'Errore! Risposta dal canale calcolo hardware Agb non arrivata!')
|
|
return
|
|
end
|
|
else
|
|
EgtOutLog( 'Errore! Pubblicazione sul canale calcolo hardware Agb fallita!')
|
|
return
|
|
end
|
|
|
|
if ( nReturnMode & WIN_HDW_RETURNMODE.HARDWARELIST) ~= 0 then
|
|
local tHardware = JSON:decode( AnswerArgs.HardwareList)
|
|
table.insert( OutputKitList, tHardware)
|
|
end
|
|
if ( nReturnMode & WIN_HDW_RETURNMODE.POSITIONLIST) ~= 0 then
|
|
local tPosition = JSON:decode( AnswerArgs.PositionList)
|
|
table.insert( OutputPositionList, tPosition)
|
|
end
|
|
if ( nReturnMode & WIN_HDW_RETURNMODE.MACHININGLIST) ~= 0 then
|
|
local tMachining = JSON:decode( AnswerArgs.MachiningList)
|
|
CalcHdwMachining( tMachining, SashList)
|
|
-- disegno la ferramenta
|
|
if s_bCalcSolid then
|
|
-- recupero o creo il gruppo per disegno ferramenta
|
|
local nAuxLayerId = GetAuxLayer()
|
|
for i = 1, #SashList do
|
|
DrawSashHardware( SashList[i].nAreaId, nFrameId, nAuxLayerId)
|
|
end
|
|
end
|
|
end
|
|
if ( nReturnMode & WIN_HDW_RETURNMODE.OPTIONLIST) ~= 0 then
|
|
table.insert( OutputOptionList, AnswerArgs.OptionList)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function AddHardwareRec( nAreaId, nReturnMode, OutputKitList, OutputPositionList, OutputOptionList)
|
|
|
|
local sHardware = EgtGetInfo( nAreaId, WIN_HDW_FAVOURITE)
|
|
if sHardware and sHardware ~= WIN_HDW_NULL then
|
|
-- se area ha un preferito definito allora devo calcolare la ferramenta sulle sue ante
|
|
return AddHardwareForSash( nAreaId, nReturnMode, OutputKitList, OutputPositionList, OutputOptionList)
|
|
else
|
|
-- verifico se ci sono sotto-aree
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
-- lancio verifica di quell'area
|
|
AddHardwareRec( nChildAreaId, nReturnMode, OutputKitList, OutputPositionList, OutputOptionList)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che aggiunge l'hardware
|
|
function WinCalculate.AddHardware( nAreaId, bMachiningList, bHardwareList, bPositionList, bOptionList)
|
|
-- connessione a Redis
|
|
local bRedisConnect = false
|
|
if WDG and WDG.REDISID and WDG.REDISID > 0 then
|
|
-- connessione già creata dall'esterno
|
|
s_nRedisConnectionId = WDG.REDISID
|
|
elseif s_nRedisConnectionId == 0 then
|
|
-- se nessuna connessione la creo
|
|
bRedisConnect, s_nRedisConnectionId = EgtRedisAsyncConnect( 'redis.ufficio:26379, serviceName=devel, DefaultDatabase=6, keepAlive=180, connectTimeout=15000, syncTimeout=15000, asyncTimeout=15000, abortConnect=false, ssl=false, allowAdmin=true')
|
|
if not bRedisConnect then
|
|
EgtOutLog( 'Errore! Impossibile connettersi con il server Redis dal Lua!')
|
|
end
|
|
end
|
|
|
|
-- calcolo codice di ritorno, i.e. tipologie di conti da fare sulla ferramenta ( e.g calcolo lavorazioni, calcolo lista ferramenta, ...)
|
|
local nReturnMode = 0
|
|
if bMachiningList then
|
|
nReturnMode = nReturnMode + WIN_HDW_RETURNMODE.MACHININGLIST
|
|
end
|
|
if bHardwareList then
|
|
nReturnMode = nReturnMode + WIN_HDW_RETURNMODE.HARDWARELIST
|
|
end
|
|
if bPositionList then
|
|
nReturnMode = nReturnMode + WIN_HDW_RETURNMODE.POSITIONLIST
|
|
end
|
|
if bOptionList then
|
|
nReturnMode = nReturnMode + WIN_HDW_RETURNMODE.OPTIONLIST
|
|
end
|
|
|
|
local OutputKitList = {}
|
|
local OutputPositionList = {}
|
|
local OutputOptionList = {}
|
|
AddHardwareRec( nAreaId, nReturnMode, OutputKitList, OutputPositionList, OutputOptionList)
|
|
|
|
-- se la connessione è stata creata in questa funzione la chiudo
|
|
if bRedisConnect then
|
|
EgtRedisAsyncDisconnect( s_nRedisConnectionId)
|
|
s_nRedisConnectionId = 0
|
|
end
|
|
|
|
return OutputKitList, OutputPositionList, OutputOptionList
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che disegna l'hardware
|
|
local function DrawHardware( nAreaId, nAuxLayerId)
|
|
-- verifico il tipo
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
|
|
if nAreaType == WIN_AREATYPES.SASH then
|
|
-- se anta disegno la ferramenta se è stato definito un preferito
|
|
local sFavourite = EgtGetInfo( nAreaId, WIN_HDW_FAVOURITE)
|
|
if sFavourite and sFavourite ~= WIN_HDW_NULL then
|
|
DrawSashHardware( nAreaId, nAreaId, nAuxLayerId)
|
|
end
|
|
return
|
|
|
|
elseif nAreaType == WIN_AREATYPES.SPLIT then
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) or GDB_ID.NULL
|
|
local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL
|
|
if nSplitType == WIN_SPLITTYPES.FRENCH then
|
|
local sHdwFavourite = EgtGetInfo( nAreaId, WIN_HDW_FAVOURITE)
|
|
if sHdwFavourite and sHdwFavourite ~= WIN_HDW_NULL then
|
|
-- disegno ferramenta per tutte le ante avendo come gruppo di riferimento delle info il parent dell'area split french
|
|
local vSashes = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
for j = 1, #vSashes do
|
|
DrawSashHardware( vSashes[j], nAreaId, nAuxLayerId)
|
|
end
|
|
end
|
|
return
|
|
else
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
-- lancio verifica di quell'area
|
|
DrawHardware( nChildAreaId, nAuxLayerId)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
|
|
else
|
|
-- verifico se ci sono sotto-aree
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
-- lancio verifica di quell'area
|
|
DrawHardware( nChildAreaId, nAuxLayerId)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
----------------------------------- ACCESSORI ----------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che individua l'intersezione tra nOutlineId e la curva del geo indicata da sGeoRef del pezzo avente come outline nRefCrvId
|
|
local function GetTrimParamByGeo( nOutlineId, nRefCrvId, sGeoRef)
|
|
|
|
-- recupero la curva di interessa del geo
|
|
local nRefPart = EgtGetInfo( nRefCrvId, WIN_REF_PART, 'i')
|
|
local nRefGeo = EgtGetFirstNameInGroup( nRefPart, WIN_GEO)
|
|
local nGeoCrv = EgtGetFirstNameInGroup( nRefGeo, sGeoRef)
|
|
|
|
-- recupero punto di intersezione ( con eventuale estensione delle curve)
|
|
local ptInt = FindIntersectionPoint( nOutlineId, nGeoCrv, ORIG())
|
|
|
|
-- ricavo il parametro di intersezione sulla curva di outline ( senza estensione)
|
|
local dPar = EgtCurveParamAtPoint( nOutlineId, ptInt)
|
|
return dPar
|
|
end
|
|
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che calcola e disegna la soglia
|
|
local function CalcThreshold( nOutlineId, nAreaId)
|
|
-- recupero il profilo della soglia
|
|
local nProfileId = GetOutlineProfileId( nOutlineId)
|
|
local dLenTot = 0
|
|
|
|
-- disegno
|
|
local nAuxGrp = GetAuxLayer()
|
|
local nStm = CreateProfileSurf( nOutlineId, nProfileId, WIN_SECTION, 0, nAuxGrp)
|
|
if nStm then
|
|
EgtSetColor( nStm, Color3d( 128, 128, 128))
|
|
EgtSetName( nStm, WIN_THRESHOLD)
|
|
dLenTot = EgtCurveLength( nOutlineId)
|
|
end
|
|
|
|
-- se slide window ci sono parti extra da estrudere in corrispondenza delle ante fisse
|
|
local bSlideWindow = EgtGetInfo( nAreaId, WIN_SLIDE_WINDOW, 'b') or false
|
|
if bSlideWindow then
|
|
-- 1) soglia extra per parte mobile
|
|
local nGuideId = EgtCopyGlob( nOutlineId, nAuxGrp)
|
|
-- taglio la curva guida con i pezzi di telaio vicini
|
|
local nPrevCrv = EgtGetLastInGroup( EgtGetParent( nOutlineId))
|
|
local dParS = GetTrimParamByGeo( nGuideId, nPrevCrv, WIN_GEO_IN)
|
|
local nNextCrv = EgtGetNext( nOutlineId)
|
|
local dParE = GetTrimParamByGeo( nGuideId, nNextCrv, WIN_GEO_IN)
|
|
EgtTrimCurveStartEndAtParam( nGuideId, dParS, dParE)
|
|
|
|
local vMovableSections = EgtGetNameInGroup( nProfileId, WIN_MOVABLE .. WIN_SECTION)
|
|
for i = 1, #vMovableSections do
|
|
local nStmExtra = CreateProfileSurfById( nGuideId, nProfileId, vMovableSections[i], 0, nAuxGrp)
|
|
EgtSetColor( nStmExtra, Color3d( 128, 128, 128))
|
|
EgtSetName( nStmExtra, WIN_MOVABLE .. WIN_SECTION)
|
|
end
|
|
dLenTot = dLenTot + #vMovableSections * EgtCurveLength( nGuideId)
|
|
EgtErase( nGuideId)
|
|
|
|
-- 2) soglia extra per le sottoante fisse
|
|
-- recupero i profili extra da estrudere
|
|
local vExtraSections = EgtGetNameInGroup( nProfileId, WIN_FIXED .. WIN_SECTION)
|
|
if #vExtraSections > 0 then
|
|
-- cerco tutte le sottoante fisse
|
|
local vChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi')
|
|
for i = 1, #vChildren do
|
|
local nSashAreaId = EgtGetParent( EgtGetParent( vChildren[i]))
|
|
local nSashType = EgtGetInfo( nSashAreaId, WIN_SASHTYPE, 'i')
|
|
if nSashType == WIN_SASHTYPES.SLIDE_FIXED then
|
|
|
|
local nGuideId = EgtCopyGlob( vChildren[i], nAuxGrp)
|
|
EgtExtendCurveStartByLen( nGuideId, 1000)
|
|
EgtExtendCurveEndByLen( nGuideId, 1000)
|
|
-- trim della guida con il geo dei pezzi vicini
|
|
local nOutlineId = EgtGetInfo( vChildren[i], WIN_COPY, 'i')
|
|
local nPrevCrv = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'i')
|
|
local dParS = GetTrimParamByGeo( nGuideId, nPrevCrv, WIN_GEO_OUT)
|
|
local nNextCrv = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'i')
|
|
local dParE = GetTrimParamByGeo( nGuideId, nNextCrv, WIN_GEO_OUT)
|
|
EgtTrimCurveStartEndAtParam( nGuideId, dParS, dParE)
|
|
|
|
for j = 1, #vExtraSections do
|
|
local nStmExtra = CreateProfileSurfById( nGuideId, nProfileId, vExtraSections[j], 0, nAuxGrp)
|
|
EgtSetColor( nStmExtra, Color3d( 128, 128, 128))
|
|
EgtSetName( nStmExtra, WIN_FIXED .. WIN_THRESHOLD)
|
|
end
|
|
|
|
-- aggiorno lunghezza ( TODO da gestire separatamente con i tipi di soglia)
|
|
dLenTot = dLenTot + #vExtraSections * EgtCurveLength( nGuideId)
|
|
EgtErase( nGuideId)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- salvo info lunghezza
|
|
EgtSetInfo( nAreaId, WIN_THRESHOLD_LEN, dLenTot)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola e disegna il gocciolatoio
|
|
local function CalcWaterdrip( nPartId, nOutlineId, nAreaId, bDraw)
|
|
|
|
-- verifico presenza gocciolatoio
|
|
local nProfileLayId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileLayId, WIN_PRF_MAIN)
|
|
local nWaterdripId = EgtGetFirstNameInGroup( nProfileId, WIN_WATERDRIP)
|
|
if not nWaterdripId then
|
|
return
|
|
end
|
|
|
|
local dLenTot = 0
|
|
-- recupero il gruppo per il disegno dei solidi
|
|
local nSolidLayId
|
|
if bDraw and s_bCalcSolid then
|
|
nSolidLayId = GetAuxLayer()
|
|
end
|
|
|
|
-- recupero tutti gli split che possono creare interruzioni nel gocciolatoio
|
|
local vSplits = {}
|
|
local nBottomRail = EgtGetInfo( nOutlineId, WIN_REF_BOTTOMRAIL_PART, 'i')
|
|
if not nBottomRail then -- se ha bottomrail gli split non causano interruzioni nel gocciolatoio
|
|
local vStack = {nAreaId}
|
|
local i = 1
|
|
while vStack[i] do
|
|
local nAreaType = EgtGetInfo( vStack[i], WIN_AREATYPE, 'i')
|
|
if nAreaType == WIN_AREATYPES.SPLIT then
|
|
local nSplitId = EgtGetFirstNameInGroup( vStack[i], WIN_SPLIT)
|
|
local nSplitType = EgtGetInfo( nSplitId, WIN_SPLITTYPE, 'i')
|
|
if nSplitType ~= WIN_SPLITTYPES.FRENCH then
|
|
local vCurrSplits = EgtGetAllInGroup( nSplitId)
|
|
for j = 1, #vCurrSplits do
|
|
-- verifico se lo split poggia sulla curva bottom
|
|
local dDist1 = EgtPointCurveDist( EgtSP( vCurrSplits[j]), nOutlineId)
|
|
local dDist2 = EgtPointCurveDist( EgtEP( vCurrSplits[j]), nOutlineId)
|
|
if dDist1 < GEO.EPS_SMALL or dDist2 < GEO.EPS_SMALL then
|
|
table.insert( vSplits, vCurrSplits[j])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- se non è anta o vetro ( che interrompono la cascata di pezzi relativi al telaio) salvo le sottaree per analizzarle
|
|
if nAreaType ~= WIN_AREATYPES.SASH and nAreaType ~= WIN_AREATYPES.FILL then
|
|
local vChildren = EgtGetNameInGroup( vStack[i], WIN_AREA .. '*') or {}
|
|
vStack = EgtJoinTables( vStack, vChildren)
|
|
end
|
|
-- passo all'area successiva
|
|
i = i + 1
|
|
end
|
|
end
|
|
|
|
-- recupero le curve sulle quali costruire il gocciolatoio: in generale è solo l'outline bottom, nel caso di cambio profilo sono solo i suoi sottotratti che poggiano
|
|
-- contro le ante
|
|
local vBottomOutlines = { nOutlineId}
|
|
local bProfileChange = EgtGetInfo( nOutlineId, WIN_PRF_CHANGE, 'b') or false
|
|
if bProfileChange then
|
|
local nMixedOutlinesLay = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_OUTLINES)
|
|
local vSashOutlines = EgtGetNameInGroup( nMixedOutlinesLay, WIN_SASH)
|
|
vBottomOutlines = vSashOutlines
|
|
end
|
|
|
|
-- recupero curve vicine
|
|
local nPrevCrv = EgtGetLastInGroup( EgtGetParent( nOutlineId))
|
|
local nNextCrv = EgtGetNext( nOutlineId)
|
|
|
|
for i = 1, #vBottomOutlines do
|
|
local vParams = {}
|
|
|
|
-- verifico se interruzioni per i pezzi vicini del telaio
|
|
if AreSamePointApprox( EgtSP( vBottomOutlines[i]), EgtEP( nPrevCrv)) then
|
|
local dPar = GetTrimParamByGeo( vBottomOutlines[i], nPrevCrv, WIN_GEO_IN)
|
|
table.insert( vParams, dPar)
|
|
end
|
|
if AreSamePointApprox( EgtEP( vBottomOutlines[i]), EgtSP( nNextCrv)) then
|
|
local dPar = GetTrimParamByGeo( vBottomOutlines[i], nNextCrv, WIN_GEO_IN)
|
|
table.insert( vParams, dPar)
|
|
end
|
|
|
|
-- verifico se interruzioni per split
|
|
for j = 1, #vSplits do
|
|
-- verifico se lo split poggia sulla curva
|
|
local dDist1 = EgtPointCurveDist( EgtSP( vSplits[j]), vBottomOutlines[i])
|
|
local dDist2 = EgtPointCurveDist( EgtEP( vSplits[j]), vBottomOutlines[i])
|
|
if dDist1 < GEO.EPS_SMALL or dDist2 < GEO.EPS_SMALL then
|
|
-- recupero i parametri di intersezione con il geo dello split
|
|
local dParIn = GetTrimParamByGeo( vBottomOutlines[i], vSplits[j], WIN_GEO_IN)
|
|
if dParIn then
|
|
table.insert( vParams, dParIn)
|
|
end
|
|
local dParOut = GetTrimParamByGeo( vBottomOutlines[i], vSplits[j], WIN_GEO_OUT)
|
|
if dParOut then
|
|
table.insert( vParams, dParOut)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- riordino i parametri ( non dovrebbero mai capitare parametri coincidenti)
|
|
table.sort( vParams)
|
|
|
|
for j = 1, #vParams, 2 do
|
|
-- creo la guida di estrusione per il gocciolatoio
|
|
local nGuideId = EgtCopyGlob( vBottomOutlines[i], nSolidLayId)
|
|
-- trim della curva
|
|
EgtTrimCurveStartEndAtParam( nGuideId, vParams[j], vParams[j+1])
|
|
-- aggiorno la lunghezza
|
|
dLenTot = dLenTot + EgtCurveLength( nGuideId)
|
|
-- disegno
|
|
if bDraw and s_bCalcSolid then
|
|
-- estrudo la superficie
|
|
local nStm = CreateProfileSurf( nGuideId, nProfileId, WIN_WATERDRIP, 0, nSolidLayId)
|
|
EgtSetColor( nStm, Color3d( 128, 128, 128))
|
|
EgtSetName( nStm, WIN_WATERDRIP)
|
|
end
|
|
EgtErase( nGuideId)
|
|
end
|
|
end
|
|
|
|
-- salvo la lunghezza del gocciolatoio
|
|
EgtSetInfo( nAreaId, WIN_WATERDRIP_LEN, dLenTot)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che calcola e disegna le guarnizioni
|
|
local function CalcGaskets( nAreaId, bDraw)
|
|
|
|
local nOutlineLayId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local vOrigOutlines = EgtGetAllInGroup( nOutlineLayId)
|
|
local dLenTot = 0
|
|
|
|
-- recupero dati dei pezzi che serviranno nei conti e i veri outlines da considerare
|
|
local tParts = {}
|
|
local vOutlines = {}
|
|
for i = 1, #vOrigOutlines do
|
|
local bThreshold = EgtGetName( vOrigOutlines[i]) == WIN_BOTTOM and EgtGetInfo( vOrigOutlines[i], WIN_THRESHOLD, 'b')
|
|
if bThreshold then
|
|
-- gestione speciale per soglia che non ha pezzo associato
|
|
local nMainProfileId = GetOutlineProfileId( vOrigOutlines[i])
|
|
tParts[i] = { nProfileId = nMainProfileId, frProfile = nil}
|
|
vOutlines[i] = vOrigOutlines[i]
|
|
else
|
|
local nPartId = FindAssociatedPart( vOrigOutlines[i], false)
|
|
local nProfileLayId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayId, WIN_PRF_MAIN)
|
|
local nFrameId = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTIONFRAME)
|
|
local frProfile = EgtFR( nFrameId, GDB_ID.ROOT)
|
|
tParts[i] = { nProfileId = nMainProfileId, frProfile = frProfile}
|
|
vOutlines[i] = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
|
end
|
|
end
|
|
|
|
-- gruppo temporaneo per i conti
|
|
local nGrp = EgtGroup( nAreaId)
|
|
|
|
-- cerco tutte le possibili guarnizioni
|
|
for i = 1, 3 do
|
|
-- nome della guarnizione corrente
|
|
local sGasket = WIN_GASKET .. tostring( i)
|
|
local vCrvs = {}
|
|
for i = 1, #vOutlines do
|
|
local nCrv = EgtCopyGlob( vOutlines[i], nGrp)
|
|
table.insert( vCrvs, nCrv)
|
|
|
|
-- calcolo offset da applicare alla curva
|
|
local dOffs
|
|
local vGasketIds = EgtGetNameInGroup( tParts[i].nProfileId, sGasket .. '*')
|
|
if #vGasketIds == 1 then
|
|
-- se guarnizione recupero offset dalla sua dimensione
|
|
local b3Box = EgtGetBBoxRef( vGasketIds[1], GDB_BB.STANDARD, tParts[i].frProfile)
|
|
dOffs = b3Box:getMax():getX()
|
|
tParts[i].sGasket = sGasket
|
|
elseif #vGasketIds > 1 then
|
|
-- se ho più guarnizioni devo identificare quella dal lato corretto ( caso di split)
|
|
local nCrvRef = EgtIf( i == 1, vOrigOutlines[2], vOrigOutlines[i-1])
|
|
local _, _, nSide = EgtPointCurveDistSide( EgtMP( nCrvRef), nCrv, Z_AX())
|
|
if nSide == 1 then
|
|
tParts[i].sGasket = sGasket .. '_1'
|
|
local nGasketId = EgtGetFirstNameInGroup( tParts[i].nProfileId, tParts[i].sGasket)
|
|
local b3Box = EgtGetBBoxRef( nGasketId, GDB_BB.STANDARD, tParts[i].frProfile)
|
|
dOffs = b3Box:getMin():getX()
|
|
else
|
|
tParts[i].sGasket = sGasket .. '_2'
|
|
local nGasketId = EgtGetFirstNameInGroup( tParts[i].nProfileId, tParts[i].sGasket)
|
|
local b3Box = EgtGetBBoxRef( nGasketId, GDB_BB.STANDARD, tParts[i].frProfile)
|
|
dOffs = b3Box:getMax():getX()
|
|
end
|
|
else
|
|
-- se non ha guarnizione è curva di trim ( quindi deve avere info)
|
|
dOffs = EgtGetInfo( tParts[i].nProfileId, WIN_TRIM .. sGasket, 'd')
|
|
if not dOffs then
|
|
-- se non ha info di trim significa che devo passare alla guarnizione successiva
|
|
vCrvs = {}
|
|
break
|
|
end
|
|
dOffs = - dOffs
|
|
tParts[i].sGasket = nil
|
|
end
|
|
|
|
-- offset
|
|
EgtOffsetCurve( nCrv, dOffs)
|
|
end
|
|
|
|
if #vCrvs > 0 then
|
|
-- taglio le curve
|
|
TrimOrderedCurves( vCrvs)
|
|
|
|
-- aggiorno lunghezza
|
|
for i = 1, #vCrvs do
|
|
if tParts[i].sGasket then -- devo ignorare le curve di trim
|
|
dLenTot = dLenTot + EgtCurveLength( vCrvs[i])
|
|
end
|
|
end
|
|
|
|
-- disegno
|
|
if bDraw and s_bCalcSolid then
|
|
-- recupero il gruppo per il disegno dei solidi
|
|
local nSolidLayerId = GetAuxLayer()
|
|
for i = 1, #vCrvs do
|
|
if tParts[i].sGasket then
|
|
-- estrusione principale della giunzione
|
|
local nGasketStm = CreateProfileSurf( vOutlines[i], tParts[i].nProfileId, tParts[i].sGasket, 100, nSolidLayerId)
|
|
EgtSetColor( nGasketStm, Color3d( 128, 128, 128))
|
|
EgtSetName( nGasketStm, sGasket)
|
|
|
|
-- trim start
|
|
local nPrev = EgtIf( i == 1, #vCrvs, i - 1)
|
|
local nGuideId
|
|
if not tParts[nPrev].sGasket then
|
|
-- se precedente è curva di trim la uso direttamente
|
|
nGuideId = EgtCopyGlob( vCrvs[nPrev], nSolidLayerId)
|
|
EgtInvertCurve( nGuideId)
|
|
else
|
|
-- taglio lungo la bisettrice
|
|
local vtDir = 0.5 * ( EgtSV( vCrvs[i]) - EgtEV( vCrvs[nPrev]))
|
|
if vtDir:isSmall() then
|
|
vtDir = EgtSV( vCrvs[i])
|
|
vtDir:rotate( Z_AX(), 90)
|
|
end
|
|
nGuideId = EgtLinePVL( nSolidLayerId, EgtSP( vCrvs[i]), vtDir, 200)
|
|
EgtExtendCurveStartByLen( nGuideId, 100)
|
|
end
|
|
local nTrimStart = EgtSurfTmByExtrusion( nSolidLayerId, nGuideId, - 200 * Z_AX())
|
|
EgtSurfTmIntersect( nGasketStm, nTrimStart)
|
|
EgtErase( { nGuideId, nTrimStart})
|
|
|
|
-- trim end
|
|
local nNext = EgtIf( i == #vCrvs, 1, i + 1)
|
|
if not tParts[nNext].sGasket then
|
|
nGuideId = EgtCopyGlob( vCrvs[nNext], nSolidLayerId)
|
|
else
|
|
local vtDir = 0.5 * ( EgtSV( vCrvs[nNext]) - EgtEV( vCrvs[i]))
|
|
if vtDir:isSmall() then
|
|
vtDir = EgtSV( vCrvs[nNext])
|
|
vtDir:rotate( Z_AX(), 90)
|
|
end
|
|
nGuideId = EgtLinePVL( nSolidLayerId, EgtEP( vCrvs[i]), vtDir, 200)
|
|
EgtExtendCurveStartByLen( nGuideId, 100)
|
|
end
|
|
local nTrimEnd = EgtSurfTmByExtrusion( nSolidLayerId, nGuideId, - 200 * Z_AX())
|
|
EgtInvertSurf( nTrimEnd)
|
|
EgtSurfTmIntersect( nGasketStm, nTrimEnd)
|
|
EgtErase( { nGuideId, nTrimEnd})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- aggiorno valore lunghezza
|
|
EgtSetInfo( nAreaId, WIN_GASKET_LEN, dLenTot)
|
|
|
|
EgtErase( nGrp)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
function WinCalculate.AddAccessories( nAreaId, bDraw)
|
|
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
if nAreaType == WIN_AREATYPES.FRAME then
|
|
local nOutlineLayId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
|
|
-- accessori del pezzo inferiore: soglia e gocciolatoio
|
|
local nBottomId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_BOTTOM)
|
|
local bThreshold = EgtGetInfo( nAreaId, WIN_THRESHOLD, 'b') or false
|
|
if bThreshold then
|
|
-- soglia
|
|
CalcThreshold( nBottomId, nAreaId)
|
|
else
|
|
-- gocciolatoio
|
|
local nPartId = EgtGetInfo( nBottomId, WIN_REF_PART, 'i')
|
|
CalcWaterdrip( nPartId, nBottomId, nAreaId, bDraw)
|
|
end
|
|
|
|
-- guarnizioni se definisce direttamente anta
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') or GDB_ID.NULL
|
|
local nChildType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL
|
|
if nChildType == WIN_AREATYPES.SASH then
|
|
CalcGaskets( nAreaId, bDraw)
|
|
end
|
|
-- TODO guarnizioni per gocciolatoio
|
|
|
|
elseif nAreaType == WIN_AREATYPES.SASH then
|
|
-- guarnizioni
|
|
CalcGaskets( nAreaId, bDraw)
|
|
|
|
elseif nAreaType == WIN_AREATYPES.SPLIT then
|
|
-- guarnizioni se è french split
|
|
local nSplitId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT)
|
|
local nSplitType = EgtGetInfo( nSplitId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL
|
|
if nSplitType == WIN_SPLITTYPES.FRENCH then
|
|
CalcGaskets( nAreaId, bDraw)
|
|
end
|
|
|
|
elseif nAreaType == WIN_AREATYPES.NULL then
|
|
-- guarnizioni se ha come sottoarea un'anta
|
|
local nChildArea = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') or GDB_ID.NULL
|
|
local nChildType = EgtGetInfo( nChildArea, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL
|
|
if nChildType == WIN_AREATYPES.SASH then
|
|
CalcGaskets( nAreaId, bDraw)
|
|
end
|
|
end
|
|
|
|
-- calcolo accessori per sotto-aree
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
WinCalculate.AddAccessories( nChildAreaId, bDraw)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
--------------------------------- PREVIEW ----------------------------------------
|
|
----------------------------------------------------------------------------------
|
|
local function CalcBottomRailPreview( nPreviewGrp, nOutlineId, nBottomRail, nProfileGrp, nGeoGrp, color)
|
|
|
|
-- costruisco box complessivo degli zoccoli
|
|
local vCrvs = {}
|
|
|
|
-- la curva out corrisponde al geo in del pezzo bottom
|
|
local nPartGeoIn = EgtGetFirstNameInGroup( nGeoGrp, WIN_GEO_IN)
|
|
vCrvs[1] = EgtCopyGlob( nPartGeoIn, nPreviewGrp)
|
|
EgtInvertCurve( vCrvs[1])
|
|
|
|
local vNextOutlines = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'vi')
|
|
local vEndProfiles = EgtGetNameInGroup( nProfileGrp, WIN_PRF_END)
|
|
local b3ProfileEnd = GetProfileLocalBox( vEndProfiles[1])
|
|
vCrvs[2] = EgtCopyGlob( abs( vNextOutlines[1]), nPreviewGrp)
|
|
EgtOffsetCurve( vCrvs[2], b3ProfileEnd:getMin():getX())
|
|
|
|
-- la curva in corrisponde al geo in dell'ultimo bottomrail
|
|
local vBottomRails = EgtGetInfo( nOutlineId, WIN_REF_BOTTOMRAIL_PART, 'vi')
|
|
local nBottomRailPart = vBottomRails[#vBottomRails]
|
|
local nGeoLayer = EgtGetFirstNameInGroup( nBottomRailPart, WIN_GEO)
|
|
local nGeoIn = EgtGetFirstNameInGroup( nGeoLayer, WIN_GEO_IN)
|
|
vCrvs[3] = EgtCopyGlob( nGeoIn, nPreviewGrp)
|
|
|
|
local vPrevOutlines = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'vi')
|
|
local vStartProfiles = EgtGetNameInGroup( nProfileGrp, WIN_PRF_START)
|
|
local b3ProfileStart = GetProfileLocalBox( vStartProfiles[1])
|
|
vCrvs[4] = EgtCopyGlob( abs( vPrevOutlines[1]), nPreviewGrp)
|
|
EgtOffsetCurve( vCrvs[4], b3ProfileStart:getMin():getX())
|
|
|
|
-- creo la regione e ne estraggo il bordo
|
|
local nAreaId = CalcIntersectionRegion( vCrvs, nPreviewGrp)
|
|
EgtSetColor( nAreaId, color)
|
|
local nCrvId = EgtExtractSurfFrChunkLoops( nAreaId, 0, nPreviewGrp)
|
|
EgtSetColor( nCrvId, EgtStdColor( 'BLACK'))
|
|
EgtModifyCurveThickness( nCrvId, 0)
|
|
|
|
-- creo linee di divisione tra gli zoccoli
|
|
if nBottomRail > 1 then
|
|
local b3Surf = EgtGetBBoxGlob( nAreaId, GDB_BB.STANDARD)
|
|
local dLen = b3Surf:getDimX()
|
|
local dStep = b3Surf:getDimY() / nBottomRail
|
|
for i = 1, nBottomRail - 1 do
|
|
local pt = b3Surf:getMin() + i * dStep * Y_AX()
|
|
local nCrvId = EgtLinePVL( nPreviewGrp, pt, X_AX(), dLen)
|
|
EgtSetColor( nCrvId, EgtStdColor( 'BLACK'))
|
|
end
|
|
end
|
|
|
|
EgtErase( vCrvs)
|
|
end
|
|
|
|
----------------------------------------------------------------------------------
|
|
local function CalcPartPreview( nPartId, nPreviewGrp)
|
|
|
|
local nAreaId
|
|
|
|
local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
|
local nGeoGrp = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local nProfileGrp = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
|
|
-- verifico se è sash active/inactive per gestione speciale
|
|
local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i')
|
|
local bOnSplit = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b')
|
|
|
|
-- recupero il tipo di giunzione
|
|
local nStartJoint = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'i')
|
|
local nEndJoint = EgtGetInfo( nOutlineId, WIN_ENDJOINT, 'i')
|
|
|
|
-- se non ha giunzioni short e non è active/inactive come preview posso considerare direttamente la regione del geo
|
|
if nStartJoint ~= WIN_PART_JNT.SHORT and nEndJoint ~= WIN_PART_JNT.SHORT and not bOnSplit then
|
|
local nGeoSurf = EgtGetFirstNameInGroup( nGeoGrp, WIN_GEO_SURF)
|
|
nAreaId = EgtCopyGlob( nGeoSurf, nPreviewGrp)
|
|
EgtSetStatus( nAreaId, GDB_ST.ON)
|
|
|
|
-- altrimenti devi calcolare le curve che delimitano la regione
|
|
else
|
|
-- gruppo temporaneo per i conti
|
|
local nGrpTmp = EgtGroup( nPreviewGrp)
|
|
|
|
-- curva out è il geo out tranne nel caso di sash active/inactive per le quali considero l'outline per evitare sovrapposizioni
|
|
if bOnSplit then
|
|
EgtCopyGlob( nOutlineId, nGrpTmp)
|
|
else
|
|
local nGeoOut = EgtGetFirstNameInGroup( nGeoGrp, WIN_GEO_OUT)
|
|
EgtCopyGlob( nGeoOut, nGrpTmp)
|
|
end
|
|
|
|
-- curva right
|
|
local vGeoRight = EgtGetNameInGroup( nGeoGrp, WIN_GEO_RIGHT)
|
|
if nEndJoint == WIN_PART_JNT.SHORT then
|
|
-- se giunzione short per evitare sovrapposizioni devo fermarla al box del pezzo adiacente
|
|
local vEndProfiles = EgtGetNameInGroup( nProfileGrp, WIN_PRF_END)
|
|
for i = 1, #vGeoRight do
|
|
local nNextOutline = EgtGetInfo( vGeoRight[i], WIN_REF_OUTLINE, 'i')
|
|
local nCrv = EgtCopyGlob( abs( nNextOutline), nGrpTmp)
|
|
local b3Profile = GetProfileLocalBox( vEndProfiles[i])
|
|
local dRailDelta = EgtGetInfo( vEndProfiles[i], WIN_RAILDELTA, 'd') or 0
|
|
local dOffs = b3Profile:getMin():getX() - dRailDelta
|
|
if nNextOutline < 0 then
|
|
EgtInvertCurve( nCrv)
|
|
dOffs = - ( b3Profile:getMax():getX() - dRailDelta)
|
|
end
|
|
EgtOffsetCurve( nCrv, dOffs)
|
|
end
|
|
else
|
|
-- altrimenti posso utilizzare direttamente la curva del geo
|
|
for i = 1, #vGeoRight do
|
|
EgtCopyGlob( vGeoRight[i], nGrpTmp)
|
|
end
|
|
end
|
|
|
|
-- curva in
|
|
local nGeoIn = EgtGetFirstNameInGroup( nGeoGrp, WIN_GEO_IN)
|
|
EgtCopyGlob( nGeoIn, nGrpTmp)
|
|
|
|
-- curva left
|
|
local vGeoLeft = EgtGetNameInGroup( nGeoGrp, WIN_LEFT)
|
|
if nStartJoint == WIN_PART_JNT.SHORT then
|
|
local vStartProfiles = EgtGetNameInGroup( nProfileGrp, WIN_PRF_START)
|
|
for i = 1, #vGeoLeft do
|
|
local nPrevOutline = EgtGetInfo( vGeoLeft[i], WIN_REF_OUTLINE, 'i')
|
|
local nCrv = EgtCopyGlob( abs( nPrevOutline), nGrpTmp)
|
|
local b3Profile = GetProfileLocalBox( vStartProfiles[i])
|
|
local dRailDelta = EgtGetInfo( vStartProfiles[i], WIN_RAILDELTA, 'd') or 0
|
|
local dOffs = b3Profile:getMin():getX() - dRailDelta
|
|
if nPrevOutline < 0 then
|
|
EgtInvertCurve( nCrv)
|
|
dOffs = - ( b3Profile:getMax():getX() - dRailDelta)
|
|
end
|
|
EgtOffsetCurve( nCrv, dOffs)
|
|
end
|
|
else
|
|
for i = 1, #vGeoLeft do
|
|
EgtCopyGlob( vGeoLeft[i], nGrpTmp)
|
|
end
|
|
end
|
|
|
|
-- creo la regione
|
|
nAreaId = CalcIntersectionRegion( EgtGetAllInGroup( nGrpTmp), nPreviewGrp)
|
|
EgtErase( nGrpTmp)
|
|
end
|
|
|
|
-- sistemo la regione
|
|
local color = EgtGetColor( nPartId)
|
|
EgtSetColor( nAreaId, color)
|
|
-- estraggo il contorno
|
|
local nCompoId = EgtExtractSurfFrChunkLoops( nAreaId, 0, nPreviewGrp)
|
|
EgtSetColor( nCompoId, EgtStdColor( 'BLACK'))
|
|
EgtModifyCurveThickness( nCompoId, 0)
|
|
|
|
-- se bottom aggiungo anche eventuale preview del bottomrail
|
|
if EgtGetName( nOutlineId) == WIN_BOTTOM then
|
|
local nBottomRail = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or 0
|
|
if nBottomRail > 0 then
|
|
CalcBottomRailPreview( nPreviewGrp, nOutlineId, nBottomRail, nProfileGrp, nGeoGrp, color)
|
|
end
|
|
end
|
|
end
|
|
|
|
----------------------------------------------------------------------------------
|
|
local function CalcFillPreview( nPartId, nPreviewGrp)
|
|
-- creo bordo a partire dall'outline
|
|
local nAreaId = EgtGetInfo( nPartId, WIN_AREA, 'i')
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local vOutlineList = EgtGetAllInGroup( nOutlineLayerId)
|
|
local nCompoOutlineId = EgtCurveCompoByChain( nPreviewGrp, vOutlineList, EgtSP( vOutlineList[1]), false)
|
|
-- creo area
|
|
local nSurfId = EgtSurfFlatRegion( nPreviewGrp, {nCompoOutlineId})
|
|
EgtSetColor( nSurfId, EgtGetColor( nPartId))
|
|
EgtErase( nCompoOutlineId)
|
|
end
|
|
|
|
----------------------------------------------------------------------------------
|
|
local function CalcHardwarePreview( nAreaId, nPreviewGrp)
|
|
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
if nAreaType == WIN_AREATYPES.SASH then
|
|
-- se anta disegno la ferramenta se è definita
|
|
local sHdwFavourite = EgtGetInfo( nAreaId, WIN_HDW_FAVOURITE)
|
|
if sHdwFavourite and sHdwFavourite ~= WIN_HDW_NULL then
|
|
DrawSashHardware( nAreaId, nAreaId, nPreviewGrp, true)
|
|
end
|
|
return
|
|
|
|
elseif nAreaType == WIN_AREATYPES.SPLIT then
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) or GDB_ID.NULL
|
|
local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL
|
|
if nSplitType == WIN_SPLITTYPES.FRENCH then
|
|
local sHdwFavourite = EgtGetInfo( nAreaId, WIN_HDW_FAVOURITE)
|
|
if sHdwFavourite and sHdwFavourite ~= WIN_HDW_NULL then
|
|
-- disegno ferramenta per tutte le ante avendo come gruppo di riferimento delle info il parent dell'area split french
|
|
local vSashes = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
for j = 1, #vSashes do
|
|
DrawSashHardware( vSashes[j], nAreaId, nPreviewGrp, true)
|
|
end
|
|
end
|
|
return
|
|
else
|
|
-- se non è split french devo controllare le sue sottoaree
|
|
local vChildrenAreas = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*') or {}
|
|
for i = 1, #vChildrenAreas do
|
|
CalcHardwarePreview( vChildrenAreas[i], nPreviewGrp)
|
|
end
|
|
end
|
|
else
|
|
-- controllo le sue sottoaree
|
|
local vChildrenAreas = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*') or {}
|
|
for i = 1, #vChildrenAreas do
|
|
CalcHardwarePreview( vChildrenAreas[i], nPreviewGrp)
|
|
end
|
|
end
|
|
end
|
|
|
|
----------------------------------------------------------------------------------
|
|
local function CalcPreview( nFrameId)
|
|
|
|
-- creo gruppo per la preview
|
|
local nPreviewGrp = EgtGroup( GDB_ID.ROOT)
|
|
EgtSetName( nPreviewGrp, WIN_PREVIEW)
|
|
EgtSetLevel( nPreviewGrp, GDB_LV.SYSTEM)
|
|
EgtSetStatus( nPreviewGrp, GDB_ST.OFF)
|
|
|
|
-- scorro tutti i pezzi e ne realizzo la preview
|
|
local nPartId = EgtGetFirstPart()
|
|
while nPartId do
|
|
local nPartType = EgtGetInfo( nPartId, WIN_PART_TYPE, 'i') or WIN_PART_TYPES.NULL
|
|
if nPartType == WIN_PART_TYPES.FILL then
|
|
CalcFillPreview( nPartId, nPreviewGrp)
|
|
elseif nPartType == WIN_PART_TYPES.BOTTOMRAIL then
|
|
-- pezzo di bottomrail viene ignorato perchè già creato con il corrispondente pezzo bottom
|
|
else
|
|
CalcPartPreview( nPartId, nPreviewGrp)
|
|
end
|
|
nPartId = EgtGetNextPart( nPartId)
|
|
end
|
|
|
|
-- copio i disegni di apertura delle ante dal gruppo delle aree
|
|
local vStack = { nFrameId}
|
|
local i = 1
|
|
while i <= #vStack do
|
|
local nAreaType = EgtGetInfo( vStack[i], WIN_AREATYPE, 'i')
|
|
if nAreaType == WIN_AREATYPES.SASH then
|
|
local nOpeningGrp = EgtGetFirstNameInGroup( vStack[i], WIN_SASH_OPENING)
|
|
local vOpeningCrvs = EgtGetAllInGroup( nOpeningGrp)
|
|
for j = 1, #vOpeningCrvs do
|
|
local nId = EgtCopyGlob( vOpeningCrvs[j], nPreviewGrp)
|
|
EgtSetColor( nId, EgtStdColor( 'BLACK'))
|
|
end
|
|
else
|
|
-- aggiungo allo stack di aree da controllare le sue aree figlie
|
|
local vChildrenAreas = EgtGetNameInGroup( vStack[i], WIN_AREA .. '*') or {}
|
|
vStack = EgtJoinTables( vStack, vChildrenAreas)
|
|
end
|
|
i = i + 1
|
|
end
|
|
|
|
-- preview ferramenta
|
|
CalcHardwarePreview( nFrameId, nPreviewGrp)
|
|
end
|
|
|
|
|
|
|
|
----------------------------------------------------------------------------------
|
|
------------------------------ FUNZIONI ----------------------------------------
|
|
----------------------------------------------------------------------------------
|
|
-- funzione che crea tutti i pezzi della finestra partendo dal telaio
|
|
function WinCalculate.CreatePartFromArea( nFrameId)
|
|
-- assegno il tipo di profilo alle curve del base outline
|
|
CalculateAreaProfileType( nFrameId)
|
|
-- calcolo outline a partire dal base outline
|
|
CalculateAreaOutline( nFrameId)
|
|
-- creo pezzi
|
|
s_nSashNbr = 0 -- resetto il numero di ante del progetto
|
|
CalculateAreaParts( nFrameId)
|
|
-- calcolo le spine
|
|
CalculateAreaDowels( nFrameId)
|
|
|
|
-- calcolo preview 2d se richiesta
|
|
if s_bCalcPreview then
|
|
CalcPreview( nFrameId)
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che ricalcola i solidi ( per cambio modalità visualizzazione)
|
|
function WinCalculate.RecalcSolids( nFrameId)
|
|
|
|
-- scorro tutti i pezzi
|
|
local nPartId = EgtGetFirstPart()
|
|
while nPartId do
|
|
-- se solidi non vanno calcolati elimino semplicemente il gruppo dei solidi da ogni pezzo
|
|
if not s_bCalcSolid then
|
|
local nSolidLayId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) or GDB_ID.NULL
|
|
EgtErase( nSolidLayId)
|
|
|
|
-- ricalcolo dei solidi
|
|
else
|
|
-- se fill, lo uso per ricalcolare strip
|
|
local nPartType = EgtGetInfo( nPartId, WIN_PART_TYPE, 'i')
|
|
if nPartType == WIN_PART_TYPES.FILL then
|
|
local nAreaId = EgtGetInfo( nPartId, WIN_AREA, 'i')
|
|
local nParentAreaId = EgtGetParent( nAreaId)
|
|
local nParentOutlineLayId = EgtGetFirstNameInGroup( nParentAreaId, WIN_OUTLINE)
|
|
local vParentOutlines = EgtGetAllInGroup( nParentOutlineLayId)
|
|
for i = 1, #vParentOutlines do
|
|
CreateStripFromOutline( nParentAreaId, vParentOutlines[i])
|
|
end
|
|
|
|
-- verifico se solido da calcolare
|
|
local nSolidLayId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID)
|
|
if not nSolidLayId then
|
|
local nOutlineLayId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local nGeoLayId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
CalcFillSolid( nPartId, nOutlineLayId, nGeoLayId)
|
|
end
|
|
|
|
-- se pezzo, ricalcolo il suo solido
|
|
else
|
|
-- elimino gruppo dei solidi
|
|
local nSolidLayId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) or GDB_ID.NULL
|
|
EgtErase( nSolidLayId)
|
|
-- ricalcolo il solido principale
|
|
local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
|
|
local nSolidId = CalcSolid( nPartId, nOutlineId)
|
|
-- aggiungo lavorazioni
|
|
local nProcLayId = EgtGetFirstNameInGroup( nPartId, WIN_PRC)
|
|
local vProc = EgtGetAllInGroup( nProcLayId)
|
|
for i = 1, #vProc do
|
|
local nType = EgtGetInfo( vProc[i], WIN_PRC_FEATURE_TYPE)
|
|
local nProfilingType = EgtGetInfo( vProc[i], WIN_PRC_PROFILE_INFO)
|
|
if nType == WIN_PRC_TYPE.HOLE or ( nType == WIN_PRC_TYPE.PROFILING and nProfilingType == WIN_PRC_PROFILE_TYPE.GENERIC) then
|
|
UpdateSolidWithProcessingSurf( vProc[i], nSolidId, nProcLayId)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
nPartId = EgtGetNextPart( nPartId)
|
|
end
|
|
|
|
-- accessori e ferramenta
|
|
local nAuxGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AUX)
|
|
if not s_bCalcSolid then
|
|
EgtErase( nAuxGrp or GDB_ID.NULL)
|
|
elseif not nAuxGrp then
|
|
nAuxGrp = GetAuxLayer()
|
|
-- ferramenta
|
|
DrawHardware( nFrameId, nAuxGrp)
|
|
-- accessori
|
|
WinCalculate.AddAccessories( nFrameId, true)
|
|
end
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
return WinCalculate
|