Egalware/egwwindowlua
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f8eab3581ce7e9dd4ef3a0c016ad7027d6e19878
egwwindowlua/Designing/WinLib/WinCalculate.lua
T
SaraP f8eab3581c DataWindow : 
- gestione dei pezzi di ante troppo piccoli che scompaiono
- correzione nel calcolo outline sash e fill nel caso di cambio profilo
- migliorie nel calcolo solidi e lavorazioni.
2026-04-01 09:19:23 +02:00

8504 lines
366 KiB
Lua
Raw Blame History

--
-- 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
local JSON = require( 'JSON')
local XML = require( 'xml2lua')
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_dAngledCos = 0.995 -- coseno limite oltre il quale viene forzata giunzione angled
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 = EgtGroup( EgtGetParent( nCrv1))
local dExtraLen = 10000
local nCrvA, nCrvB
local nType1 = EgtGetType( nCrv1)
local nType2 = EgtGetType( nCrv2)
-- se compo viene gestita estensione solo sulla sua prima/ultima curva
if nType1 == GDB_TY.CRV_COMPO then
local _, dE = EgtCurveDomain( nCrv1)
nCrv1 = EgtCopyCompoSubCurve( nCrv1, dE - 1, nGrp)
nType1 = EgtGetType( nCrv1)
end
if nType2 == GDB_TY.CRV_COMPO then
nCrv2 = EgtCopyCompoSubCurve( nCrv2, 0, nGrp)
nType2 = EgtGetType( nCrv2)
end
if nType1 == GDB_TY.CRV_LINE and nType2 == 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 nType1 == GDB_TY.CRV_ARC and nType2 == 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))
elseif ( nType1 == GDB_TY.CRV_ARC and nType2 == GDB_TY.CRV_LINE) or
( nType1 == GDB_TY.CRV_LINE and nType2 == GDB_TY.CRV_ARC) then
-- 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( nGrp)
end
return ptInt
end
---------------------------------------------------------------------
-- funzione che controlla se vi è overlap tra nOrigId e una porzione della sua estensione ( nCrvId)
local function CheckExtensionOverlap( nCrvId, nOrigId)
local dParS = EgtCurveParamAtPoint( nOrigId, EgtSP( nCrvId))
local dParE = EgtCurveParamAtPoint( nOrigId, EgtEP( nCrvId))
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( nCrvId, EgtSP( nOrigId))
local dPar2 = EgtCurveParamAtPoint( nCrvId, EgtEP( nOrigId))
if dPar1 or dPar2 then
return true
end
elseif dParS and not AreSamePointApprox( EgtSP( nCrvId), EgtEP( nOrigId)) then
return true
elseif dParE and not AreSamePointApprox( EgtEP( nCrvId), EgtSP( nOrigId)) then
return true
end
return false
end
---------------------------------------------------------------------
-- funzione che crea una copia estesa della curva con estensione di lunghezza "illimitata"
local function CreateCurveExtension( nCrvId, nGrpId)
-- recupero tipo di estensione
local bTangStart = EgtGetInfo( nCrvId, WIN_TANG_START, 'b') or false
local bTangEnd = EgtGetInfo( nCrvId, WIN_TANG_END, 'b') or false
local dExtraLen = 10000
local nExtId
if EgtGetType( nCrvId) == GDB_TY.CRV_LINE then
-- estensione immediata
nExtId = EgtCopyGlob( nCrvId, nGrpId)
EgtExtendCurveStartByLen( nExtId, dExtraLen)
EgtExtendCurveEndByLen( nExtId, dExtraLen)
elseif EgtGetType( nCrvId) == GDB_TY.CRV_ARC then
-- il risultato sarà una circonferenza ( se start ed end non vanno estesi in tangenza) oppure una composita ( se uno degli estremi va esteso in tangenza)
if not bTangStart and not bTangEnd then
-- se estensione standard su entrambi gli estremi trasformo arco in circonferenza
nExtId = EgtCopyGlob( nCrvId, nGrpId)
local dAngOld = EgtArcAngCenter( nCrvId)
EgtModifyArcAngCenter( nExtId, EgtIf( dAngOld > 0, 360, -360))
elseif bTangStart and bTangEnd then
nExtId = EgtCurveCompo( nGrpId, nCrvId, false)
EgtAddCurveCompoLineTg( nExtId, dExtraLen, true)
EgtAddCurveCompoLineTg( nExtId, dExtraLen, false)
elseif bTangStart and not bTangEnd then
local nExtArcId = EgtCopyGlob( nCrvId, nGrpId)
local dAngOld = EgtArcAngCenter( nCrvId)
EgtModifyArcAngCenter( nExtArcId, EgtIf( dAngOld > 0, 340, -340))
nExtId = EgtCurveCompo( nGrpId, nExtArcId)
EgtAddCurveCompoLineTg( nExtId, dExtraLen, false)
elseif not bTangStart and bTangEnd then
local nExtArcId = EgtCopyGlob( nCrvId,nGrpId)
EgtInvertCurve( nExtArcId)
local dAngOld = EgtArcAngCenter( nExtArcId)
EgtModifyArcAngCenter( nExtArcId, EgtIf( dAngOld > 0, 340, -340))
EgtInvertCurve( nExtArcId)
nExtId = EgtCurveCompo( nGrpId, nExtArcId)
EgtAddCurveCompoLineTg( nExtId, dExtraLen)
end
elseif EgtGetType( nCrvId) == GDB_TY.CRV_COMPO then
-- se composita formata da una sola sottocurva la gestisco come curva semplice
local _, dEnd = EgtCurveDomain( nCrvId)
if abs( dEnd - 1) < GEO.EPS_SMALL then
local nSimpleCrv = EgtCopyCompoSubCurve( nCrvId, 0, nGrpId)
EgtSetInfo( nSimpleCrv, WIN_TANG_START, bTangStart)
EgtSetInfo( nSimpleCrv, WIN_TANG_END, bTangEnd)
nExtId = CreateCurveExtension( nSimpleCrv, nGrpId)
EgtErase( nSimpleCrv)
else
nExtId = EgtCopyGlob( nCrvId, nGrpId)
-- start
if EgtCurveCompoRadius( nExtId, 0) > 0 then
if bTangStart then
EgtAddCurveCompoLineTg( nExtId, dExtraLen, false)
else
local ptC = EgtCurveCompoCenter( nExtId, 0)
local dAngOld = EgtCurveCompoAngCenter( nExtId, 0)
EgtRemoveCurveCompoCurve( nExtId, false)
local nNewArc = EgtArcCPA( nGrpId, ptC, EgtSP( nExtId), EgtIf( dAngOld > 0, -340, 340), 0)
EgtInvertCurve( nNewArc)
EgtAddCurveCompoCurve( nExtId, nNewArc, true, false)
end
else
EgtExtendCurveStartByLen( nExtId, dExtraLen)
end
-- end
local _, dEnd = EgtCurveDomain( nExtId)
if EgtCurveCompoRadius( nExtId, dEnd - 1) > 0 then
if bTangEnd then
EgtAddCurveCompoLineTg( nExtId, dExtraLen)
else
local ptC = EgtCurveCompoCenter( nExtId, dEnd - 1)
local dAngOld = EgtCurveCompoAngCenter( nExtId, dEnd - 1)
EgtRemoveCurveCompoCurve( nExtId, true)
local nNewArc = EgtArcCPA( nGrpId, ptC, EgtEP( nExtId), EgtIf( dAngOld > 0, 340, -340), 0)
EgtAddCurveCompoCurve( nExtId, nNewArc)
end
else
EgtExtendCurveEndByLen( nExtId, dExtraLen)
end
end
end
return nExtId
end
---------------------------------------------------------------------
-- funzione che date due curve parzialmente sovrapposte con nCrvId composita, allunga nCrvId aggiungendo i tratti di nRefCrvId che fuoriescono da essa
local function AddExtension( nCrvId, nRefCrvId)
local dParS = EgtCurveParamAtPoint( nCrvId, EgtSP( nRefCrvId), 100 * GEO.EPS_SMALL)
if not dParS then
local dParTrim = EgtCurveParamAtPoint( nRefCrvId, EgtSP( nCrvId), 100 * GEO.EPS_SMALL)
if dParTrim then
local nNewCrv = EgtCopyParamRange( nRefCrvId, 0, dParTrim, EgtGetParent( nCrvId))
EgtAddCurveCompoCurve( nCrvId, nNewCrv, true, false)
end
end
local dParE = EgtCurveParamAtPoint( nCrvId, EgtEP( nRefCrvId), 100 * GEO.EPS_SMALL)
if not dParE then
local dParTrim = EgtCurveParamAtPoint( nRefCrvId, EgtEP( nCrvId), 100 * GEO.EPS_SMALL)
if dParTrim then
local _, dE = EgtCurveDomain( nRefCrvId)
local nNewCrv = EgtCopyParamRange( nRefCrvId, dParTrim, dE, EgtGetParent( nCrvId))
EgtAddCurveCompoCurve( nCrvId, nNewCrv)
end
end
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 calcolo le estensioni per gli archi e le composite ( che vanno gestite come gli archi)
local dExtraLen = 10000
local vSemiPlanes = {}
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( vSemiPlanes, nSemiPlaneId)
elseif EgtGetType( vCrvs[i]) == GDB_TY.CRV_ARC then
local nCrvId = CreateCurveExtension( vCrvs[i], nGrpTmp)
table.insert( tArcs, { nCrvId = nCrvId, nOrigId = vCrvs[i], dRad = EgtArcRadius( vCrvs[i])})
else
-- se composita deve contenere un arco, recupero il suo raggio
local _, dEnd = EgtCurveDomain( vCrvs[i])
local dRad = 0
for j = 0, dEnd - 1 do
dRad = EgtCurveCompoRadius( vCrvs[i], j)
if dRad > 0 then break end
end
local nCrvId = CreateCurveExtension( vCrvs[i], nGrpTmp)
table.insert( tArcs, { nCrvId = nCrvId, nOrigId = vCrvs[i], dRad = dRad})
end
end
-- calcolo la regione definita dai semipiani
for i = 2, #vSemiPlanes do
EgtSurfFrIntersect( vSemiPlanes[1], vSemiPlanes[i])
EgtErase( vSemiPlanes[i])
end
nSurfId = vSemiPlanes[1]
-- se presenti archi, calcolo il loro contributo alla regione
if #tArcs > 0 then
local nCrvBorder = EgtExtractSurfFrChunkLoops( nSurfId, 0, nGrpTmp)
-- riordino 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
-- limito la curva estesa alla regione
local nSurfTrim = EgtSurfFlatRegion( nGrpTmp, nCrvBorder)
local nCrv, nCnt = EgtTrimCurveWithRegion( tArcs[i].nCrvId, nSurfTrim, true, false)
-- se errore lo ignoro
if not nCrv then
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
if EgtGetType( nCrv) == GDB_TY.CRV_ARC then
EgtModifyCurveStartPoint( nCrv, EgtSP( nCrv + nCnt - 1))
EgtErase( nCrv + nCnt - 1)
else
EgtAddCurveCompoCurve( nCrv, nCrv + nCnt - 1, true, false)
end
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)
if nInters then
if nCnt == 1 then
EgtChangeClosedCurveStartPoint( j, EgtSP( nInters))
end
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
end
-- modifico il bordo corrente considerando solo i tratti che poggiano sulle curve originali
for j = 1, #vArcs do
if CheckExtensionOverlap( vArcs[j], tArcs[i].nOrigId) then
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])
break
end
end
end
end
-- ricostruisco la superficie
nSurfId = EgtSurfFlatRegion( nGrpTmp, nCrvBorder)
end
EgtRelocateGlob( nSurfId, nGrp)
EgtErase( nGrpTmp)
return nSurfId
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, bDelete, nSurfId)
local nGrpTmp = EgtGroup( GDB_ID.ROOT)
EgtSetStatus( nGrpTmp, GDB_ST.OFF)
-- se non calcolata, costruisco la regione definita dalle curve
if not nSurfId then
nSurfId = CalcIntersectionRegion( vCrvs, nGrpTmp)
end
-- copia estesa delle curve per verificare gli overlaps
local vExtCrvs = {}
for i = 1, #vCrvs do
vExtCrvs[i] = CreateCurveExtension( vCrvs[i], nGrpTmp)
end
-- recupero le curve di bordo della regione
local nBorderId = EgtExtractSurfFrChunkLoops( nSurfId, 0, nGrpTmp)
local nCrvBorder, nCnt = EgtExplodeCurveCompo( nBorderId)
-- associo ad ogni curva originale le curve di bordo corrispondenti
-- per gestire correttamente associazione devo partire da una curva di vCrvs e un tratto di nCrvBorder in corrispondenza biunivoca
-- ( 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), vExtCrvs[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
-- creo tabella di corrispondenze vCrvs -> CrvBorder
local tabAss = {}
local nC = nFirstIdxCrv
local nB = nFirstIdxBorder
repeat
-- cerco la curva originale associata partendo dall'ultima trovata
local dDist = EgtPointCurveDist( EgtMP( nCrvBorder + nB), vExtCrvs[nC+1])
local nSafeCnt = 0
while dDist > 2 * GEO.EPS_SMALL and nSafeCnt < #vExtCrvs do
nSafeCnt = nSafeCnt + 1
nC = ( nC + 1) % #vCrvs
dDist = EgtPointCurveDist( EgtMP( nCrvBorder + nB), vExtCrvs[nC+1])
end
-- se non ho trovato curva associata errore
if nSafeCnt == #vExtCrvs then
return
end
-- se la curva originale trovata è già associata ad una curva di bordo, verifico se posso associare alla curva di bordo corrente la curva originale consecutiva
-- ( per gestire estensioni che si sovrappongono a curve originali)
if tabAss[vCrvs[nC + 1]] then
local nNext = ( nC + 1) % #vCrvs
dDist = EgtPointCurveDist( EgtMP( nCrvBorder + nB), vExtCrvs[nNext+1])
while dDist < GEO.EPS_SMALL do
nC = nNext
nNext = ( nNext + 1) % #vCrvs
dDist = EgtPointCurveDist( EgtMP( nCrvBorder + nB), vExtCrvs[nNext+1])
end
end
-- aggiungo associazione
local nOrigCrv = vCrvs[nC + 1]
if tabAss[nOrigCrv] then
table.insert( tabAss[nOrigCrv], nCrvBorder + nB)
else
tabAss[nOrigCrv] = { nCrvBorder + nB}
end
-- passo alla curva di bordo successiva
nB = ( nB + 1) % nCnt
until nB == nFirstIdxBorder
-- sostituisco le curve originali con quelle di bordo appena calcolate
local vResultCurves = {}
local vExtraCurves = {}
for i = 1, #vCrvs do
if not tabAss[vCrvs[i]] then
-- se non ha curve di bordo associate è curva extra da gestire in modo speciale
if bDelete then
EgtErase( vCrvs[i])
else
-- se non va eliminata la restituisco come curva extra
EgtSetStatus( vCrvs[i], GDB_ST.OFF)
table.insert( vExtraCurves, vCrvs[i])
end
else
local nCrvId
if #tabAss[vCrvs[i]] > 1 then
-- se ha associata più di una curva di bordo creo la compo corrispondente
nCrvId = EgtCurveCompo( nGrpTmp, tabAss[vCrvs[i]])
else
nCrvId = tabAss[vCrvs[i]][1]
end
-- assegno il nome
local sName = EgtGetName( vCrvs[i])
if sName then
EgtSetName( nCrvId, sName)
end
-- copio le info
local vInfo = EgtGetAllInfo( vCrvs[i])
for j = 1, #vInfo do
local sInfo = EgtSplitString( vInfo[j], '=')
EgtSetInfo( nCrvId, sInfo[1], sInfo[2])
end
-- riposiziono
EgtRelocateGlob( nCrvId, vCrvs[i], GDB_IN.AFTER)
-- modifico l'id assegnando quello della curva originale che sostituisce
EgtErase( vCrvs[i])
EgtChangeId( nCrvId, vCrvs[i])
table.insert( vResultCurves, vCrvs[i])
end
end
EgtErase( nGrpTmp)
return vResultCurves, vExtraCurves
end
---------------------------------------------------------------------
-- funzione che data una curva di outline restituisce l'id del suo profilo
local function GetOutlineProfileId( nOutlineId, bForceBottomRail, nBottomRail)
-- recupero il pezzo associato all'outline
local nPartId
if EgtGetName( nOutlineId) == WIN_BOTTOM then
-- controlli per bottomrail
local nBottomRailTot = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or 0
if nBottomRailTot > 0 then
local vBottomRailParts = EgtGetInfo( nOutlineId, WIN_REF_BOTTOMRAIL_PART, 'vi')
if bForceBottomRail then
-- devo recuperare l'ultimo bottomrail
nPartId = vBottomRailParts[#vBottomRailParts]
elseif nBottomRail then
-- devo recuperare il bottomrail indicato
nPartId = vBottomRailParts[nBottomRail]
end
end
-- controllo per soglia : non avendo un pezzo associato, devo restituire il profilo teorico
local bThreshold = EgtGetInfo( nOutlineId, WIN_THRESHOLD, 'b')
if bThreshold then
local nProfileGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
local nFrameProfileGrpId = EgtGetFirstNameInGroup( nProfileGrpId, WIN_FRAME)
local sThreshold = EgtGetInfo( nOutlineId, WIN_PROFILETYPE)
return EgtGetFirstNameInGroup( nFrameProfileGrpId, sThreshold)
end
end
if not nPartId then
nPartId = EgtGetInfo( nOutlineId, WIN_REF_PART, 'i')
end
-- recupero il profilo
local nProfileGrpId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
local nMainProfileId = EgtGetFirstNameInGroup( nProfileGrpId, WIN_PRF_MAIN)
return nMainProfileId
end
---------------------------------------------------------------------
-- funzione che restituisce l'outline non virtuale associato alla curva ( potrebbe anche essere la curva stessa)
local function GetNonVirtualOutline( nOutlineId)
local nSouOutlineId = nOutlineId
local nAreaType = EgtGetInfo( EgtGetParent( EgtGetParent( nSouOutlineId)), WIN_AREATYPE, 'i')
while nAreaType ~= WIN_AREATYPES.FRAME and nAreaType ~= WIN_AREATYPES.SASH and EgtGetName( abs( nSouOutlineId)) ~= WIN_SPLIT do
nSouOutlineId = EgtGetInfo( abs( nSouOutlineId), WIN_SOU_OUTLINE, 'i')
local nAreaId = EgtGetParent( EgtGetParent( abs( nSouOutlineId)))
nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
end
return nSouOutlineId
end
---------------------------------------------------------------------
-- funzione che recupera il pezzo associato ad un outline
local function FindAssociatedPart( nOutlineId, bUseBottomRail)
-- ricavo la curva non virtuale associata ( ovvero la curva da cui deriva che ha un pezzo associato)
local nCrvId = abs( GetNonVirtualOutline( nOutlineId))
local nPartId = EgtGetInfo( nCrvId, WIN_REF_PART, 'i')
-- 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)
return b3Box
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
-- 1) split
if EgtGetName( nPrevOutlineId) == WIN_SPLIT then
-- verifico da quale lato dello split originale si trova l'outline per decidere quale controprofilo considerare
-- TODO si potrebbe considerare il segno di nPrevOutlineId ?
local _, _, nSide = EgtPointCurveDistSide( EgtMP( nOutlineId), nPrevOutlineId, Z_AX())
if nSide == 1 then
sPrevCtrIn = WIN_CTRIN .. '1' -- dx
else
sPrevCtrIn = WIN_CTRIN .. '2' -- sx
end
-- 2) pezzo del telaio con cambio profilo
else
-- 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_PROFILETYPE)
if sProfileType == WIN_RAIL or sProfileType == WIN_FILL_RAIL then
local dOffs = EgtGetInfo( nProfileId, WIN_RAILOFFS, 'd')
EgtOffsetCurve( nGuideId, - dOffs)
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
----------------------------------------------------------------------------------
---------------------- CALCOLO DEI PROFILI PER BASEOUTLINES ---------------------
----------------------------------------------------------------------------------
-- 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, nAreaId)
local nSplitType = EgtGetInfo( nAreaId, WIN_SPLITTYPE, 'i')
-- la tipologia è salvata nell'area 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 = nAreaId
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, nCurrType)
-- i figli della curva nSouId sono base outlines e non posso sapere a quali outlines corrispondono quindi per capire se sto guardando il figlio
-- corretto controllo se il tipo di anta è lo stesso del corrente oppure no
local vSplitChildren = EgtGetInfo( nSplitId, WIN_CHILD, 'vi')
local nAdjSashType = EgtGetInfo( EgtGetParent( EgtGetParent( vSplitChildren[1])), WIN_SASHTYPE, 'i')
if nAdjSashType == nCurrType then
-- se il tipo è lo stesso allora devo guardare l'altro figlio dello split
nAdjSashType = EgtGetInfo( EgtGetParent( EgtGetParent( vSplitChildren[2])), WIN_SASHTYPE, 'i')
end
return nAdjSashType
end
---------------------------------------------------------------------
-- funzione che calcola i profili delle ante sulle curve di outline ( non di base outline)
local function CalcSashProfiles( vOutlines, nAreaId)
local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL
local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0
-- imposto profili sash
for i = 1, #vOutlines do
local nOutlineId = vOutlines[i]
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 french ( e quindi deve avere profilo speciale e.g. battente/ricevente)
local nSouId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i'))
local nSplitType = EgtGetInfo( nSouId, WIN_SPLITTYPE, 'i')
if nSplitType == WIN_SPLITTYPES.FRENCH then
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 then
-- scelgo il profilo in base al tipo dell'anta adiacente
local nAdjSashType = FindAdjacentSashType( nSouId, WIN_SASHTYPES.ACTIVE_IN)
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
-- scelgo il profilo in base al tipo dell'anta adiacente
local nAdjSashType = FindAdjacentSashType( nSouId, WIN_SASHTYPES.INACTIVE_IN)
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
-- b) alzante scorrevole
elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then
local nAdjSashType = FindAdjacentSashType( nSouId, WIN_SASHTYPES.SLIDE_MOVABLE)
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
end
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)
-- verifico se soglia
if sName == WIN_BOTTOM then
EgtSetInfo( nOutlineId, WIN_THRESHOLD, bThreshold)
end
-- 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
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
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)
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
-- 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], nAreaId)
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])
EgtSetInfo( vSplitIds[i], WIN_INV_SPLIT, true)
end
end
-- se split di tipo french non ha profilo assegnato perchè non ha un pezzo associato
end
-- NULL
elseif nAreaType == WIN_AREATYPES.NULL then
-- le aree null sono aree virtuali quindi non hanno pezzi ( e dunque profili) associati
-- SASH
elseif nAreaType == WIN_AREATYPES.SASH then
-- i profili verranno calcolati direttamente sulle curve di outline
-- dimensioni
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
local vOutlineIds = EgtGetAllInGroup( nOutlineLayerId)
local vPartDim = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vi') or {}
for i = 1, #vOutlineIds do
EgtSetInfo( vOutlineIds[i], WIN_PART_DIM, vPartDim[i])
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
----------------------------------------------------------------------------------
----------------------------- PROFILI PEZZO -------------------------------------
----------------------------------------------------------------------------------
-- funzione che calcola l'offset da applicare alla curva di outline bottom per ottenere la curva di outline del bottomrail richiesto
local function CalcRailOffset( nOutlineId, nProfileId, nBottomRail)
-- recupero la dimensioni dei pezzi bottom e bottomrails
local dDimBottom = EgtGetInfo( nOutlineId, WIN_PART_DIM, 'd')
local vDimBottomRails = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL .. WIN_PART_DIM, 'vd')
local dOverlap = EgtGetInfo( nProfileId, WIN_OVERLAP, 'd')
local dRailOffs = dDimBottom
for i = 1, nBottomRail - 1 do
dRailOffs = dRailOffs + vDimBottomRails[i]
end
dRailOffs = dRailOffs - nBottomRail * dOverlap
EgtSetInfo( nProfileId, WIN_RAILOFFS, dRailOffs)
end
---------------------------------------------------------------------
-- funzione che crea il profilo della dimensione corretta
local function AdjustProfileDimension( nOutlineId, nProfileId, dDimOld, dDim)
local bSplit = ( EgtGetName( nOutlineId) == WIN_SPLIT)
local sProfileName = EgtGetInfo( nProfileId, WIN_PROFILETYPE)
local bMixed = EgtStartsWith( sProfileName, WIN_MIXED)
local dDeltaDim = dDim - dDimOld
local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
local frSection = EgtFR( nFrameId, GDB_RT.GLOB)
local vtMove = - frSection:getVersX()
-- traslo le curve "interne"
local vCurves = { WIN_IN, WIN_CTRIN, WIN_OFST .. WIN_CTRIN, WIN_STRIP, WIN_SIMPLIFIED .. WIN_IN, WIN_SIMPLIFIED .. WIN_OFST .. WIN_CTRIN, WIN_SIMPLIFIED .. WIN_STRIP}
if bSplit then
vCurves = { WIN_IN .. '2', WIN_CTRIN .. '2', WIN_OFST .. WIN_CTRIN .. '2', WIN_STRIP .. '2',
WIN_SIMPLIFIED .. WIN_IN .. '2', WIN_SIMPLIFIED .. WIN_OFST .. WIN_CTRIN .. '2', WIN_SIMPLIFIED .. WIN_STRIP .. '2'}
elseif bMixed then
vCurves = { WIN_SASH .. WIN_IN, WIN_FILL .. WIN_IN, WIN_SASH .. WIN_CTRIN, WIN_FILL .. WIN_CTRIN, WIN_OFST .. WIN_SASH .. WIN_CTRIN, WIN_OFST .. WIN_FILL .. WIN_CTRIN, WIN_STRIP,
WIN_SIMPLIFIED .. WIN_SASH .. WIN_IN, WIN_SIMPLIFIED .. WIN_FILL .. WIN_IN, WIN_SIMPLIFIED .. WIN_OFST .. WIN_SASH .. WIN_CTRIN,
WIN_SIMPLIFIED .. WIN_OFST .. WIN_FILL .. WIN_CTRIN, WIN_SIMPLIFIED .. WIN_STRIP, WIN_MIXED_COMMON .. WIN_IN}
end
for i = 1, #vCurves do
local nCrvId = EgtGetFirstNameInGroup( nProfileId, vCurves[i]) or GDB_ID.NULL
EgtMove( nCrvId, dDeltaDim * vtMove, GDB_RT.GLOB)
end
-- traslo i dowels
local vDowels = EgtGetNameInGroup( nProfileId, WIN_DOWEL .. '*')
EgtMove( vDowels, 0.5 * dDeltaDim * vtMove)
-- ricostruisco la sezione ( i=1) e la sezione semplificata ( i=2)
for i = 1, 2 do
-- prefisso al nome delle curve per sezione standard o semplificata
local sSimplPrefix = EgtIf( i == 1, '', WIN_SIMPLIFIED)
-- prefisso al nome delle curve per gestire parte sash o fill ( cambio profilo)
local vsPartPrefix = EgtIf( bMixed and not bSplit, { WIN_SASH, WIN_FILL}, {''})
-- nome dei semiprofili da combinare per creare la sezione
local vsProfiles = EgtIf( bSplit, { WIN_IN .. '1', WIN_IN .. '2'}, { WIN_IN, WIN_OUT})
for j = 1, #vsPartPrefix do
local nSectionId = EgtGetFirstNameInGroup( nProfileId, sSimplPrefix .. vsPartPrefix[j] .. WIN_SECTION)
EgtErase( nSectionId)
local vSemiProfileNames = { sSimplPrefix .. vsPartPrefix[j] .. vsProfiles[1], sSimplPrefix .. vsProfiles[2]}
local vSemiProfiles = { EgtGetFirstNameInGroup( nProfileId, vSemiProfileNames[1]), EgtGetFirstNameInGroup( nProfileId, vSemiProfileNames[2])}
nSectionId = EgtCurveCompo( nProfileId, vSemiProfiles[1], false)
EgtAddCurveCompoLine( nSectionId, EgtSP( vSemiProfiles[2]))
EgtAddCurveCompoCurve( nSectionId, vSemiProfiles[2], false)
EgtCloseCurveCompo( nSectionId)
EgtSetName( nSectionId, sSimplPrefix .. vsPartPrefix[j] .. WIN_SECTION)
end
end
-- ricostruisco il box
local nRef = EgtGetFirstNameInGroup( nProfileId, WIN_REF)
local b3Profile = EgtGetBBoxRef( nRef, GDB_BB.STANDARD, frSection)
EgtErase( nRef)
nRef = EgtRectangle2P( nProfileId, b3Profile:getMin() - X_AX() * dDeltaDim, b3Profile:getMax())
EgtTransform( nRef, EgtFR( nFrameId))
EgtSetName( nRef, WIN_REF)
if EgtGetName( nOutlineId) == WIN_SPLIT then
-- sposto il frame per lasciarlo posizionato come prima rispetto al box ( sono state spostate solo le curve interne)
local dMove = b3Profile:getMax():getX() / dDimOld * dDim - b3Profile:getMax():getX()
EgtMove( nFrameId, dMove * vtMove)
end
end
---------------------------------------------------------------------
local function CreatePartProfile( nPartId, nOutlineId, dDim, nBottomRail)
-- gruppo per i profili
local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
if nProfileLayerId then
EgtEmptyGroup( nProfileLayerId)
else
nProfileLayerId = EgtGroup( nPartId)
EgtSetName( nProfileLayerId, WIN_PROFILE)
EgtSetStatus( nProfileLayerId, GDB_ST.OFF)
end
-- profilo principale :
-- recupero se è pezzo di telaio o anta
local nParentId = EgtGetParent( EgtGetParent( nOutlineId))
local nAreaType = EgtGetInfo( nParentId or GDB_ID.NULL, WIN_AREATYPE, 'i') or 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 nBottomRail then
local nBottomRailTot = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or 0
if nBottomRail == nBottomRailTot then
sProfileName = WIN_FILL_RAIL
else
sProfileName = WIN_RAIL
end
end
-- recupero il profilo
local nOrigMainProfileId = EgtGetFirstNameInGroup( nLayerId, sProfileName)
-- creo copia
local nMainProfileId = EgtCopy( nOrigMainProfileId, nProfileLayerId)
local sMainProfileType = EgtGetName( nMainProfileId)
EgtSetInfo( nMainProfileId, WIN_PROFILETYPE, sMainProfileType)
EgtSetName( nMainProfileId, WIN_PRF_MAIN)
-- se bottomrail salvo info per scostamento dall'outline
if nBottomRail then
CalcRailOffset( nOutlineId, nMainProfileId, nBottomRail)
end
-- verifico se vanno modificate le dimensioni del profilo
local dDimStd = EgtGetInfo( nMainProfileId, WIN_DIM_STD, 'd')
if dDim then
if abs( dDimStd - dDim) > GEO.EPS_SMALL then
AdjustProfileDimension( nOutlineId, nMainProfileId, dDimStd, dDim)
end
else
-- se non ha dimensione imposto quella standard
if nBottomRail then
local vBottomRailDims = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL.. WIN_PART_DIM, 'vd') or {}
table.insert( vBottomRailDims, nBottomRail, dDimStd)
EgtSetInfo( nOutlineId, WIN_BOTTOMRAIL.. WIN_PART_DIM, vBottomRailDims)
else
EgtSetInfo( nOutlineId, WIN_PART_DIM, dDimStd)
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)
end
---------------------------------------------------------------------
-- funzione che recupera i profili start ed end di un pezzo
local function CalcStartEndProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutlineId)
-- recupero il gruppo per i profili
local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
-- recupero profili start/end e ne creo copia
for i = 1, #vPrevOutlineId do
-- se il tipo corrente è split il pezzo va tagliato con eventuale bottomrail, altrimenti con il bottom
local nOrigStartProfileId = GetOutlineProfileId( abs( vPrevOutlineId[i]), EgtGetName( nOutlineId) == WIN_SPLIT)
local nStartProfileId = EgtCopy( nOrigStartProfileId, nProfileLayerId)
EgtSetName( nStartProfileId, WIN_PRF_START)
end
for i = 1, #vNextOutlineId do
local nOrigEndProfileId = GetOutlineProfileId( abs( vNextOutlineId[i]), EgtGetName( nOutlineId) == WIN_SPLIT)
local nEndProfileId = EgtCopy( nOrigEndProfileId, nProfileLayerId)
EgtSetName( nEndProfileId, WIN_PRF_END)
end
return nProfileLayerId
end
----------------------------------------------------------------------------------
------------------------------ CREAZIONE PEZZI ---------------------------------
----------------------------------------------------------------------------------
-- funzione che dato il tipo di giunzione e di pezzo ( orizzontale o verticale) restituisce se è corto, lungo o angolato
local function CalcPartJoint( nJointType, bHorizontal)
if nJointType == WIN_JNT.ANGLED then
return WIN_PART_JNT.ANGLED
elseif nJointType == WIN_JNT.FULL_H then
if bHorizontal then
return WIN_PART_JNT.FULL
else
return WIN_PART_JNT.SHORT
end
elseif nJointType == WIN_JNT.FULL_V then
if bHorizontal then
return WIN_PART_JNT.SHORT
else
return WIN_PART_JNT.FULL
end
end
end
---------------------------------------------------------------------
local function CalcOutlineStartJoint( nOutlineId, nPrevOutlineId, vJoints)
local nStartJoint
if EgtGetName( nOutlineId) == WIN_BOTTOM then
nStartJoint = CalcPartJoint( vJoints[1], true)
elseif EgtGetName( nOutlineId) == WIN_RIGHT then
nStartJoint = CalcPartJoint( vJoints[2], false)
elseif EgtGetName( nOutlineId) == WIN_TOP then
nStartJoint = CalcPartJoint( vJoints[3], true)
-- correzione per caso a triangolo : se l'outline vicino è di tipo bottom, il corrente deve essere trattato come un pezzo verticale
if EgtGetName( nPrevOutlineId) == WIN_BOTTOM then
nStartJoint = CalcPartJoint( vJoints[2], false)
end
elseif EgtGetName( nOutlineId) == WIN_LEFT then
nStartJoint = CalcPartJoint( vJoints[4] or vJoints[3], false) -- ( vJoints[3] per gestire caso a triangolo)
end
-- eventuali correzioni :
-- a) forzatura a bisettrice se elementi in tangenza ( entro 6°) o dello stesso tipo
if nStartJoint ~= WIN_PART_JNT.ANGLED then
if EgtEV( nPrevOutlineId) * EgtSV( nOutlineId) > s_dAngledCos or EgtGetName( nOutlineId) == EgtGetName( nPrevOutlineId) then
nStartJoint = WIN_PART_JNT.ANGLED
end
end
-- b) forzatura a short se incontro con soglia
if EgtGetInfo( nPrevOutlineId, WIN_THRESHOLD, 'b') then
nStartJoint = WIN_PART_JNT.SHORT
end
return nStartJoint
end
---------------------------------------------------------------------
local function CalcOutlineEndJoint( nOutlineId, nNextOutlineId, vJoints)
local nEndJoint
if EgtGetName( nOutlineId) == WIN_BOTTOM then
nEndJoint = CalcPartJoint( vJoints[2], true)
elseif EgtGetName( nOutlineId) == WIN_RIGHT then
nEndJoint = CalcPartJoint( vJoints[3], false)
elseif EgtGetName( nOutlineId) == WIN_TOP then
nEndJoint = CalcPartJoint( vJoints[4] or vJoints[3], true) -- ( vJoints[3] per gestire caso a triangolo)
-- correzione per caso a triangolo : se l'outline vicino è di tipo bottom, il corrente deve essere trattato come un pezzo verticale
if EgtGetName( nNextOutlineId) == WIN_BOTTOM then
nEndJoint = CalcPartJoint( vJoints[1], false)
end
elseif EgtGetName( nOutlineId) == WIN_LEFT then
nEndJoint = CalcPartJoint( vJoints[1], false)
end
-- eventuali correzioni :
-- a) forzatura a bisettrice se elementi in tangenza ( entro 6°) o dello stesso tipo
if nEndJoint ~= WIN_PART_JNT.ANGLED then
if EgtEV( nOutlineId) * EgtSV( nNextOutlineId) > s_dAngledCos or EgtGetName( nOutlineId) == EgtGetName( nNextOutlineId) then
nEndJoint = WIN_PART_JNT.ANGLED
end
end
-- b) forzatura a short se incontro con soglia
if EgtGetInfo( nNextOutlineId, WIN_THRESHOLD, 'b') then
nEndJoint = WIN_PART_JNT.SHORT
end
return nEndJoint
end
---------------------------------------------------------------------
local function GetOutlineJoints( vOutlineIds, nAreaId)
local vJoints = EgtGetInfo( nAreaId, WIN_JOINTS, 'vi')
for i = 1, #vOutlineIds do
local nPrevIdx = EgtIf( i == 1, #vOutlineIds, i - 1)
local nNextIdx = EgtIf( i == #vOutlineIds, 1, i + 1)
local nStartJoint = CalcOutlineStartJoint( vOutlineIds[i], vOutlineIds[nPrevIdx], vJoints)
local nEndJoint = CalcOutlineEndJoint( vOutlineIds[i], vOutlineIds[nNextIdx], vJoints)
EgtSetInfo( vOutlineIds[i], WIN_STARTJOINT, nStartJoint)
EgtSetInfo( vOutlineIds[i], WIN_ENDJOINT, nEndJoint)
end
end
---------------------------------------------------------------------
-- 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
---------------------------------------------------------------------
local function CreateOutlinePart( nOutlineId, sName, dDim, 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)
-- 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)
EgtSetInfo( nPartId, WIN_BOTTOMRAIL, nBottomRail)
else
EgtSetInfo( nOutlineId, WIN_REF_PART, nPartId)
EgtSetInfo( nPartId, WIN_PART_TYPE, WIN_PART_TYPES.STD)
end
-- imposto nome
local sOutlineName = EgtIf( nBottomRail, WIN_BOTTOMRAIL .. '_' .. tostring( nBottomRail), EgtGetName( nOutlineId))
local sPartName = sName .. '_' .. sOutlineName
EgtSetName( nPartId, sPartName)
-- imposto 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
-- creo il profilo associato al pezzo con la dimensione opportuna
CreatePartProfile( nPartId, nOutlineId, dDim, nBottomRail)
return nPartId
end
---------------------------------------------------------------------
local function CreatePartsFromOutlines( vOutlines, nAreaId, sName)
local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i')
-- calcolo le giunzioni
GetOutlineJoints( vOutlines, nAreaId)
-- TODO segnalare errore se pezzi con giunzione angled non hanno le stesse dimensioni
local vPartsDim = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vd') or {}
-- creo i pezzi per ogni curva
for i = 1, #vOutlines do
EgtSetInfo( vOutlines[i], WIN_PART_DIM, vPartsDim[i])
CreateOutlinePart( vOutlines[i], sName, vPartsDim[i])
if nBottomRail and EgtGetName( vOutlines[i]) == WIN_BOTTOM then
EgtSetInfo( vOutlines[i], WIN_BOTTOMRAIL, nBottomRail)
local vBottomRailDim = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL .. WIN_PART_DIM, 'vd') or {}
EgtSetInfo( vOutlines[i], WIN_BOTTOMRAIL .. WIN_PART_DIM, vBottomRailDim)
for j = 1, nBottomRail do
CreateOutlinePart( vOutlines[i], sName, vBottomRailDim[j], j)
end
end
end
end
---------------------------------------------------------------------
local function CreateFillPartFromArea( nAreaId, sName)
local nPartId = EgtGroup( GDB_ID.ROOT)
-- inserisco riferimento alla sua area
EgtSetInfo( nPartId, WIN_AREA, nAreaId)
-- imposto nome del pezzo
EgtSetName( nPartId, sName .. '_' .. WIN_FILL)
EgtSetInfo( nPartId, WIN_PART_TYPE, WIN_PART_TYPES.FILL)
-- imposto colore e tipologia
local nFillType = EgtGetInfo( nAreaId, WIN_FILLTYPE, 'i')
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
return nPartId
end
----------------------------------------------------------------------------------
------------------------------ CALCOLO OUTLINE ---------------------------------
----------------------------------------------------------------------------------
local function GetFramePrevNextOutline( vOutlines, nOutlineLayerId)
for i = 2, #vOutlines - 1 do
EgtSetInfo( vOutlines[i], WIN_PREV_OUTLINES, { vOutlines[i-1]})
EgtSetInfo( vOutlines[i], WIN_NEXT_OUTLINES, { vOutlines[i+1]})
end
-- gestione particolare per primo e ultimo
EgtSetInfo( vOutlines[1], WIN_PREV_OUTLINES, { vOutlines[#vOutlines]})
EgtSetInfo( vOutlines[1], WIN_NEXT_OUTLINES, { vOutlines[2]})
EgtSetInfo( vOutlines[#vOutlines], WIN_PREV_OUTLINES, { vOutlines[#vOutlines - 1]})
EgtSetInfo( vOutlines[#vOutlines], WIN_NEXT_OUTLINES, { vOutlines[1]})
end
------------------------------ NULL ------------------------------
---------------------------------------------------------------------
local function GetBorderRegions( nSplitId, nCompo, nAreaId)
-- taglio il bordo in due in corrispondenza dello split
local nCrv1 = EgtCopyGlob( nCompo, nAreaId)
local nCrv2 = EgtCopyGlob( nCompo, nAreaId)
local dPar1 = EgtCurveParamAtPoint( nCompo, EgtSP( nSplitId), 100 * GEO.EPS_SMALL)
local dPar2 = EgtCurveParamAtPoint( nCompo, EgtEP( nSplitId), 100 * GEO.EPS_SMALL)
EgtTrimCurveStartEndAtParam( nCrv1, dPar2, dPar1)
EgtTrimCurveStartEndAtParam( nCrv2, dPar1, dPar2)
-- aggiungo la curva di split al bordo per chiuderlo orientandola opportunamente
local nSplitId1 = EgtCopyGlob( nSplitId, nAreaId)
EgtAddCurveCompoCurve( nCrv1, nSplitId1)
local _, dParE1 = EgtCurveDomain( nCrv1)
EgtCurveCompoSetTempProp( nCrv1, dParE1 - 1, nSplitId)
local nSplitId2 = EgtCopyGlob( nSplitId, nAreaId)
EgtInvertCurve( nSplitId2)
EgtAddCurveCompoCurve( nCrv2, nSplitId2)
local _, dParE2 = EgtCurveDomain( nCrv2)
EgtCurveCompoSetTempProp( nCrv2, dParE2 - 1, - nSplitId)
-- se mixed split inverito le regioni finali vanno scambiate
local bInvert = EgtGetInfo( nSplitId, WIN_INV_SPLIT, 'b') or false
if bInvert then
return nCrv2, nCrv1
else
return nCrv1, nCrv2
end
end
---------------------------------------------------------------------
local function CalculateNullOutline( nCompoOutline, vSplitIds, vChildAreas)
local nGrpTmp = EgtGroup( GDB_ID.ROOT)
-- calcolo i bordi delle sottoregioni null tagliando il bordo complessivo dell'area di split con gli split
local vBorders = {}
local nCompoRef = nCompoOutline
for i = 1, #vSplitIds do
-- calcolo i bordi delle due regioni definite dallo split
local nCrv1, nCrv2 = GetBorderRegions( vSplitIds[i], nCompoRef, nGrpTmp)
table.insert( vBorders, nCrv1)
-- il secondo bordo è quello da suddividere con lo split successivo ( se esiste)
nCompoRef = nCrv2
if i == #vSplitIds then
table.insert( vBorders, nCrv2)
end
end
-- creo gli outline delle sottoaree a partire dai bordi calcolati
for i = 1, #vChildAreas do
if vBorders[i] then
local nOutlineLayerId = EgtGroup( vChildAreas[i])
EgtSetName( nOutlineLayerId, WIN_OUTLINE)
EgtSetStatus( nOutlineLayerId, GDB_ST.OFF)
EgtRelocateGlob( vBorders[i], nOutlineLayerId)
-- dalla curva di bordo ricavo le sottocurve che compongono l'outline
local vSouCrvs = EgtCurveCompoGetTempProp( vBorders[i])
local nFirst, nCnt = EgtExplodeCurveCompo( vBorders[i])
-- assegno nome e info a tutte le curve a partire dalla curva da cui derviano ( salvata nella temp prop della curva)
for j = 0, nCnt - 1 do
local nCrvId = nFirst + j
EgtSetInfo( nCrvId, WIN_SOU_OUTLINE, vSouCrvs[j+1])
-- assengo il nome : se deriva da split lo scelgo in base all'orientamento, se deriva da outline lo copio
if EgtGetName( abs( vSouCrvs[j+1])) == WIN_SPLIT then
local vtS = EgtSV( nCrvId)
if AreSameVectorApprox( vtS, X_AX()) then
EgtSetName( nCrvId, WIN_BOTTOM)
elseif AreOppositeVectorApprox( vtS, X_AX()) then
EgtSetName( nCrvId, WIN_TOP)
elseif AreSameVectorApprox( vtS, Y_AX()) then
EgtSetName( nCrvId, WIN_RIGHT)
elseif AreOppositeVectorApprox( vtS, Y_AX()) then
EgtSetName( nCrvId, WIN_LEFT)
end
else
EgtSetName( nCrvId, EgtGetName( abs( vSouCrvs[j+1])))
end
end
-- riordino le curve per avere la bottom come prima
for j = 0, nCnt - 1 do
if EgtGetName( nFirst + j) ~= WIN_BOTTOM then
EgtRelocate( nFirst + j, nOutlineLayerId)
else
break
end
end
else
-- se non c'è bordo l'area non è valida e va eliminata
EgtErase( vChildAreas[i])
end
end
EgtErase( nGrpTmp)
end
------------------------------ SPLIT ------------------------------
---------------------------------------------------------------------
-- funzione che corregge i profili del telaio individuati di tipo mixed dallo split
local function AdjustMixedFrames( vOutlines)
-- pezzi consecutivi coinvolti da cambio profilo devono avere : profilo di tipo mixed, stesse dimensioni, separazione con giunzione a bisettrice
if vOutlines == 1 then return end
-- fisso come dimensione quella del primo pezzo
local dDimRef = EgtGetInfo( vOutlines[1], WIN_PART_DIM, 'd')
for i = 1, #vOutlines do
local bMixed = EgtGetInfo( vOutlines[i], WIN_PRF_CHANGE, 'b') or false
local dDim = EgtGetInfo( vOutlines[i], WIN_PART_DIM, 'd')
-- se non era stato individuato correttamente come profilo mixed oppure la dimensione va modificata ricalcolo il profilo
if not bMixed or abs( dDim - dDimRef) > GEO.EPS_SMALL then
if not bMixed then
EgtSetInfo( vOutlines[i], WIN_PRF_CHANGE, true)
local sRealProfile = EgtIf( EgtGetName( vOutlines[i]) == WIN_BOTTOM, WIN_MIXED_BOTTOM, WIN_MIXED_TOP)
EgtSetInfo( vOutlines[i], WIN_PROFILETYPE, sRealProfile)
end
if abs( dDim - dDimRef) > GEO.EPS_SMALL then
EgtSetInfo( vOutlines[i], WIN_PART_DIM, dDimRef)
end
local nPartId = EgtGetInfo( vOutlines[i], WIN_REF_PART, 'i')
CreatePartProfile( nPartId, vOutlines[i], dDimRef)
end
-- imposto giunzione
if i ~= 1 then
EgtSetInfo( vOutlines[i], WIN_STARTJOINT, WIN_PART_JNT.ANGLED)
end
if i ~= #vOutlines then
EgtSetInfo( vOutlines[i], WIN_ENDJOINT, WIN_PART_JNT.ANGLED)
end
end
end
---------------------------------------------------------------------
-- funzione che verifica gli outlines prev/next per lo split controllando l'interferenza tra i profili
local function TestSplitTrimOutlines( nOutlineId, nTrimOutline, tabOutlines, nMainProfile, b3Profile, nGrpTmp, bPrevOrNext)
local vTrimOutlines = {}
-- 1) recupero le curve da testare :
-- a) curva individuata dall'intersezione dello split con l'outline
local vTestOutlines = { tabOutlines[nTrimOutline]}
-- b) curve vicine a quella individuata dall'intersezione che interferiscono con lo split ( 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( nTrimOutline) or EgtGetLastInGroup( EgtGetParent( nTrimOutline))
local bInters = true
while bInters and nTestCurve ~= nTrimOutline do
local nRefOutline = abs( tabOutlines[nTestCurve])
local nProfileId = GetOutlineProfileId( nRefOutline, true)
local b3Profile = GetProfileLocalBox( nProfileId)
local nRefSurf = EgtSurfFrFatCurve( nGrpTmp, nRefOutline, b3Profile:getMin():getX(), false)
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, tabOutlines[nTestCurve])
nTestCurve = EgtGetPrev( nTestCurve) or EgtGetLastInGroup( EgtGetParent( nTestCurve))
end
end
-- curve successive
nTestCurve = EgtGetNext( nTrimOutline) or EgtGetFirstInGroup( EgtGetParent( nTrimOutline))
bInters = true
while bInters and nTestCurve ~= nTrimOutline do
local nRefOutline = abs( tabOutlines[nTestCurve])
local nProfileId = GetOutlineProfileId( nRefOutline, true)
local b3Profile = GetProfileLocalBox( nProfileId)
local nRefSurf = EgtSurfFrFatCurve( nGrpTmp, nRefOutline, b3Profile:getMin():getX(), false)
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, tabOutlines[nTestCurve])
nTestCurve = EgtGetNext( nTestCurve) or EgtGetFirstInGroup( EgtGetParent( nTestCurve))
end
end
if #vTestOutlines == 1 then
return vTestOutlines
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( abs( vTestOutlines[i]), true)
vsCtrIn[i] = GetProfileCtrIn( abs( 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( abs( vTestOutlines[i]), vProfiles[i], vsCtrIn[i], 4 * dExtraLen, nGrpTmp)
if i > 1 then
if AreSameVectorApprox( EgtEV( abs( vTestOutlines[i-1])), EgtSV( abs( vTestOutlines[i]))) then
EgtCutSurfTmPlane( nTestSurf, EgtEP( abs( vTestOutlines[i-1])), - EgtEV( abs( vTestOutlines[i-1])), false)
else
local nTrimSurf = CreateProfileSurf( abs( 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( abs( vTestOutlines[i])), EgtSV( abs( vTestOutlines[i+1]))) then
EgtCutSurfTmPlane( nTestSurf, EgtEP( abs( vTestOutlines[i])), EgtEV( abs( vTestOutlines[i])), false)
else
local nTrimSurf = CreateProfileSurf( abs( 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( vTrimOutlines, vTestOutlines[i])
end
end
return vTrimOutlines
end
---------------------------------------------------------------------
-- funzione che recupera gli outline precedenti e successivi degli split
local function GetSplitsPrevNextOutline( vSplitIds, vOutlineIds)
local nGrpTmp = EgtGroup( GDB_ID.ROOT)
-- ad ogni outline dell'area di split associo l'outline non virtuale corrispondente ( per rendere più solidi i conti successivi)
local tabOutlines = {}
for i = 1, #vOutlineIds do
tabOutlines[vOutlineIds[i]] = GetNonVirtualOutline( vOutlineIds[i])
end
-- per ogni split individuo i prev e i next
for i = 1, #vSplitIds do
local nMainProfile = GetOutlineProfileId( vSplitIds[i])
local b3Profile = GetProfileLocalBox( nMainProfile)
-- controllo la validità delle curve prev/next trovate dall'intersezione degli outlines e la validità di eventuali curve vicine verificando l'interferenza tra i profili
local nPrevOutlineId = EgtGetInfo( vSplitIds[i], WIN_SPLIT_STARTINTERS, 'i')
local vPrevOutlineIds = TestSplitTrimOutlines( vSplitIds[i], nPrevOutlineId, tabOutlines, nMainProfile, b3Profile, nGrpTmp, true)
EgtSetInfo( vSplitIds[i], WIN_PREV_OUTLINES, vPrevOutlineIds)
-- setto tutte le giunzioni a short
local vStartJoints = {}
for i = 1, #vPrevOutlineIds do
vStartJoints[i] = WIN_PART_JNT.SHORT
end
EgtSetInfo( vSplitIds[i], WIN_STARTJOINT, vStartJoints)
local nNextOutlineId = EgtGetInfo( vSplitIds[i], WIN_SPLIT_ENDINTERS, 'i')
local vNextOutlineIds = TestSplitTrimOutlines( vSplitIds[i], nNextOutlineId, tabOutlines, nMainProfile, b3Profile, nGrpTmp, false)
EgtSetInfo( vSplitIds[i], WIN_NEXT_OUTLINES, vNextOutlineIds)
local vEndJoints = {}
for i = 1, #vNextOutlineIds do
vEndJoints[i] = WIN_PART_JNT.SHORT
end
EgtSetInfo( vSplitIds[i], WIN_ENDJOINT, vEndJoints)
-- se split di tipo mixed i pezzi che incontra deve essere di tipo mixed ( anche se avevo trovato una sola tipologia di figli), devono essere separati da giunzione
-- a bisettrice e devono avere le stesse dimensioni. Impongo queste condizioni eventualmente ricalcolando i profili
local bChangeProfile = EgtGetInfo( vSplitIds[i], WIN_PRF_CHANGE, 'b') or false
if bChangeProfile then
AdjustMixedFrames( vPrevOutlineIds)
AdjustMixedFrames( vNextOutlineIds)
end
end
EgtErase( nGrpTmp)
end
---------------------------------------------------------------------
-- funzione che adatta la curva di split al bordo
local function TrimSplitWithOutline( nSplitId, nOutlineCompo, vOutlineIds)
-- estendo agli estremi ( TO DO : gestire caso di split non lineare)
EgtExtendCurveStartByLen( nSplitId, 1000)
EgtExtendCurveEndByLen( nSplitId, 1000)
local ptS = EgtIP( nSplitId, nOutlineCompo, EgtSP( nSplitId))
local ptE = EgtIP( nSplitId, nOutlineCompo, EgtEP( nSplitId))
-- se non trovo punti di intersezione lo split è fuori dall'outline e quindi va eliminato
if not ptS and not ptE then
return false
end
local dParS = EgtCurveParamAtPoint( nSplitId, ptS)
local dParE = EgtCurveParamAtPoint( nSplitId, ptE)
EgtTrimCurveStartEndAtParam( nSplitId, dParS, dParE)
-- recupero le curve con cui avviene l'intersezione e le salvo come info
local dParCrvS = EgtCurveParamAtPoint( nOutlineCompo, ptS)
local nCrv = vOutlineIds[ floor( dParCrvS) + 1]
EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, nCrv)
local dParCrvE = EgtCurveParamAtPoint( nOutlineCompo, ptE)
nCrv = vOutlineIds[ floor( dParCrvE) + 1]
EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, nCrv)
return true
end
---------------------------------------------------------------------
local function CalcSplitDimensions( nAreaId, dDim)
local vMeasureTypes = EgtGetInfo( nAreaId, WIN_MEASURE_TYPE, 'vi')
local vMeasureValues = EgtGetInfo( nAreaId, WIN_MEASURE_VALUE, 'vd')
local vDimensions = {}
-- calcolo le dimensioni di tutti gli split assoluti e percentuali e calcolo i valori di riferimento per eventuali split proporzionali
local nPropTot = 0
local dPropDim = dDim
local bProportional = false
for i = 1, #vMeasureTypes do
if vMeasureTypes[i] == WIN_MEASURE.ABSOLUTE then
vDimensions[i] = vMeasureValues[i]
dPropDim = dPropDim - vDimensions[i]
elseif vMeasureTypes[i] == WIN_MEASURE.PERCENTAGE then
vDimensions[i] = dDim * vMeasureValues[i] / 100
dPropDim = dPropDim - vDimensions[i]
elseif vMeasureTypes[i] == WIN_MEASURE.PROPORTIONAL then
nPropTot = nPropTot + vMeasureValues[i]
bProportional = true
end
end
-- calcolo le dimensioni degli split proporzionali
if bProportional then
if dPropDim < GEO.EPS_SMALL then
return {}
end
for i = 1, #vMeasureTypes do
if vMeasureTypes[i] == WIN_MEASURE.PROPORTIONAL then
vDimensions[i] = dPropDim * vMeasureValues[i] / nPropTot
end
end
end
return vDimensions
end
---------------------------------------------------------------------
local function GetSplitAreaBorderCurves( nSplitDir, nOutlineLayerId)
local vCrvs = {}
-- se split verticale servono le curve di sinistra e di destra, che sono rispettivamente quella prima e quella dopo il bottom
-- non ricerco la left/right per casi dove non sono definite ( e.g. triangolo)
if nSplitDir == WIN_SPLITORIENTATION.VERTICAL then
vCrvs[1] = EgtGetLastInGroup( nOutlineLayerId)
vCrvs[2] = EgtGetNext( EgtGetFirstNameInGroup( nOutlineLayerId, WIN_BOTTOM))
-- se split orizzontale servono le curve inferiore e superiore
elseif nSplitDir == WIN_SPLITORIENTATION.HORIZONTAL then
vCrvs[1] = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_BOTTOM)
vCrvs[2] = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_TOP)
end
return vCrvs
end
---------------------------------------------------------------------
local function CalcStandardSplitContributions( nSplitDir, nOutlineLayerId, vSplitIds)
-- nel caso di split standard la dimensione è sempre luce
local tPartsDim = {}
-- 1) contributo dei pezzi che delimitano la regione degli split
local vDim = {}
local vCrvs = GetSplitAreaBorderCurves( nSplitDir, nOutlineLayerId)
for i = 1, 2 do
-- recupero il pezzo contro cui poggia
local nSouId = GetNonVirtualOutline( vCrvs[i])
-- recupero il profilo ( eventualmente di bottomrail)
local nProfileId = GetOutlineProfileId( abs( nSouId), true)
local dRailOffs = EgtGetInfo( nProfileId, WIN_RAILOFFS, 'd') or 0
local b3Profile = GetProfileLocalBox( nProfileId)
-- calcolo il contributo
if nSouId < 0 then
vDim[i] = b3Profile:getMax():getX() + dRailOffs
else
vDim[i] = abs( b3Profile:getMin():getX()) + dRailOffs
end
end
tPartsDim[1] = { 0, vDim[1]}
-- 2) contributo degli split
for i = 1, #vSplitIds do
local nProfileId = GetOutlineProfileId( vSplitIds[i])
local b3Profile = GetProfileLocalBox( nProfileId)
local vCurrSplitDim = {}
vCurrSplitDim[1] = abs( b3Profile:getMin():getX())
vCurrSplitDim[2] = b3Profile:getMax():getX()
-- se cambio profilo invertito devo scambiare le dimensioni del profilo
local bInvert = EgtGetInfo( vSplitIds[i], WIN_INV_SPLIT, 'b') or false
if bInvert then
vCurrSplitDim[1], vCurrSplitDim[2] = vCurrSplitDim[2], vCurrSplitDim[1]
end
table.insert( tPartsDim, vCurrSplitDim)
end
table.insert( tPartsDim, { vDim[2], 0})
return tPartsDim
end
---------------------------------------------------------------------
local function CalcFrenchSplitContributions( nSplitDir, nOutlineLayerId, nBaseOutlineLayerId, vSplitIds, bDaylight)
-- nel caso di french split ( gruppo di ante) la dimensione può essere di tipo luce o esterno anta
local tPartsDim = {}
local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
local nSashProfileGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_SASH)
-- 1) contributo dei pezzi che delimitano la regione degli split
local vDim = {}
local vCrvs = GetSplitAreaBorderCurves( nSplitDir, nOutlineLayerId)
local vBaseCrvs = GetSplitAreaBorderCurves( nSplitDir, nBaseOutlineLayerId)
for i = 1, 2 do
-- recupero l'outline del pezzo telaio/split su cui poggia e il base outline dell'anta che poggerà
local nSouId = GetNonVirtualOutline( vCrvs[i])
local nSashBaseOutline = EgtGetInfo( vBaseCrvs[i], WIN_CHILD, 'i')
-- a) contributo del telaio
local nProfileId = GetOutlineProfileId( abs( nSouId))
local b3Profile = GetProfileLocalBox( nProfileId)
if nSouId < 0 then
vDim[i] = abs( b3Profile:getMax():getX())
else
vDim[i] = abs( b3Profile:getMin():getX())
end
-- considero l'overlap in base all'anta che vi poggerà
local sKey = EgtIf( EgtGetName( nSashBaseOutline) == WIN_BOTTOM, WIN_SASH_BOTTOM_OVERLAP, WIN_SASH_TOP_OVERLAP)
local dSashOverlap = EgtGetInfo( nProfileId, sKey, 'd')
vDim[i] = vDim[i] - dSashOverlap
-- b) se luce devo considerare anche il contributo dell'anta
if bDaylight then
-- anta non è ancora calcolata quindi devo usare profilo e dimensione teorica ricavandole dal base outline
local sSashName = EgtGetName( nSashBaseOutline)
local sSashProfile = EgtIf( sSashName == WIN_BOTTOM, WIN_FRAME_BOTTOM, WIN_FRAME_TOP)
local nSashType = EgtGetInfo( EgtGetParent( EgtGetParent( nSashBaseOutline)), WIN_SASHTYPE, 'i')
if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then
if sSashName == WIN_BOTTOM then
sSashProfile = WIN_SLIDE_MOVABLE_BOTTOM
elseif sSashName == WIN_TOP then
sSashProfile = WIN_SLIDE_MOVABLE_TOP
else
sSashProfile = WIN_SLIDE_MOVABLE_SIDE
end
elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then
if sSashName == WIN_BOTTOM then
sSashProfile = WIN_SLIDE_FIXED_BOTTOM
elseif sSashName == WIN_TOP then
sSashProfile = WIN_SLIDE_FIXED_TOP
else
sSashProfile = WIN_SLIDE_FIXED_SIDE
end
elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then
if sSashName == WIN_BOTTOM then
sSashProfile = WIN_SLIDE_MOVABLEBACK_BOTTOM
elseif sSashName == WIN_TOP then
sSashProfile = WIN_SLIDE_MOVABLEBACK_TOP
else
sSashProfile = WIN_SLIDE_MOVABLEBACK_SIDE
end
end
local nProfileId = EgtGetFirstNameInGroup( nSashProfileGrp, sSashProfile)
local dDim = EgtGetInfo( nSashBaseOutline, WIN_PART_DIM, 'd') or EgtGetInfo( nProfileId, WIN_DIM_STD, 'd')
vDim[i] = vDim[i] + dDim
end
end
tPartsDim[1] = { 0, vDim[1]}
-- 2) contributo degli split
for i = 1, #vSplitIds do
local vCurrSplitDim = { 0, 0}
-- ricavo i base outlines delle ante che poggeranno sullo split
local vSashChildren = EgtGetInfo( vSplitIds[i], WIN_CHILD, 'vi')
local vSashTypes = {}
vSashTypes[1] = EgtGetInfo( EgtGetParent( EgtGetParent( vSashChildren[1])), WIN_SASHTYPE, 'i')
vSashTypes[2] = EgtGetInfo( EgtGetParent( EgtGetParent( vSashChildren[2])), WIN_SASHTYPE, 'i')
for j = 1, 2 do
-- recupero il profilo teorico
local sSashProfile
local nOther = EgtIf( j == 1, 2, 1)
if vSashTypes[j] == WIN_SASHTYPES.ACTIVE then
sSashProfile = WIN_SASH_ACTIVE
elseif vSashTypes[j] == WIN_SASHTYPES.INACTIVE then
sSashProfile = WIN_SASH_INACTIVE
elseif vSashTypes[j] == WIN_SASHTYPES.ACTIVE_OUT or vSashTypes[j] == WIN_SASHTYPES.INACTIVE_OUT then
sSashProfile = WIN_FRENCH_OUT
elseif vSashTypes[j] == WIN_SASHTYPES.ACTIVE_IN then
if vSashTypes[nOther] == WIN_SASHTYPES.ACTIVE_OUT then
sSashProfile = WIN_FRENCH_IN
else
sSashProfile = WIN_SASH_ACTIVE
end
elseif vSashTypes[j] == WIN_SASHTYPES.INACTIVE_IN then
if vSashTypes[nOther] == WIN_SASHTYPES.INACTIVE_OUT then
sSashProfile = WIN_FRENCH_IN
else -- adiacente è active
sSashProfile = WIN_SASH_INACTIVE
end
elseif vSashTypes[j] == WIN_SASHTYPES.SLIDE_MOVABLE then
if vSashTypes[nOther] == WIN_SASHTYPES.SLIDE_MOVABLE then
sSashProfile = WIN_SLIDE_ACTIVE_IN
else
sSashProfile = WIN_SLIDE_ACTIVE
end
elseif vSashTypes[j] == WIN_SASHTYPES.SLIDE_FIXED then
sSashProfile = WIN_SLIDE_INACTIVE
elseif vSashTypes[j] == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then
sSashProfile = WIN_SLIDE_INACTIVE
end
local nProfileId = EgtGetFirstNameInGroup( nSashProfileGrp, sSashProfile)
local b3Profile = GetProfileLocalBox( nProfileId)
if bDaylight then
local dDim = EgtGetInfo( vSashChildren[j], WIN_PART_DIM, 'd') or EgtGetInfo( nProfileId, WIN_DIM_STD, 'd')
vCurrSplitDim[j] = dDim - b3Profile:getMax():getX()
else
vCurrSplitDim[j] = - b3Profile:getMax():getX()
end
end
table.insert( tPartsDim, vCurrSplitDim)
end
table.insert( tPartsDim, { vDim[2], 0})
return tPartsDim
end
---------------------------------------------------------------------
-- funzione che calcola gli offset da applicare ai base splits per posizionarli correttamente
local function CalcSplitPositionOffsets( nAreaId, nAreaInfoId, vSplitIds, nSplitType)
local nSplitDir = EgtGetInfo( nAreaInfoId, WIN_SPLIT_DIR, 'i')
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
local nBaseOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
-- calcolo i contributi dei vari pezzi presenti
local tPartsDim
if nSplitType == WIN_SPLITTYPES.FRENCH then
local bDaylight = EgtGetInfo( nAreaInfoId, WIN_DAYLIGHT_MEASURE, 'b') or false
tPartsDim = CalcFrenchSplitContributions( nSplitDir, nOutlineLayerId, nBaseOutlineLayerId, vSplitIds, bDaylight)
else
tPartsDim = CalcStandardSplitContributions( nSplitDir, nOutlineLayerId, vSplitIds)
end
-- ricavo la vera dimensione disponibile
local b3Box = EgtGetBBoxGlob( nOutlineLayerId, GDB_BB.STANDARD)
local dRealDim = EgtIf( nSplitDir == WIN_SPLITORIENTATION.VERTICAL, b3Box:getDimX(), b3Box:getDimY())
for i = 1, #tPartsDim do
dRealDim = dRealDim - tPartsDim[i][1] - tPartsDim[i][2]
end
-- calcolo le dimensioni assolute di tutte le sottoaree
local vSplitDimensions = CalcSplitDimensions( nAreaInfoId, dRealDim)
-- le posizioni salvate negli split sono calcolate rispetto al box del base outline, le posizioni appena calcolate sono rispetto al box dell'outline
-- quindi calcolo la correzione da applicare
local b3BoxBase = EgtGetBBoxGlob( nBaseOutlineLayerId, GDB_BB.STANDARD)
local dCorrection = EgtIf( nSplitDir == WIN_SPLITORIENTATION.VERTICAL, ( b3Box:getMin():getX() - b3BoxBase:getMin():getX()), ( b3Box:getMin():getY() - b3BoxBase:getMin():getY()))
tPartsDim[1][2] = tPartsDim[1][2] + dCorrection
-- calcolo gli offset
local vOffs = {}
local dPrevPos = 0
for i = 1, #vSplitIds do
local dNewPos = dPrevPos + tPartsDim[i][2] + vSplitDimensions[i] + tPartsDim[i+1][1]
local dOldPos = EgtGetInfo( vSplitIds[i], WIN_SPLIT_POSITION, 'd')
vOffs[i] = dNewPos - dOldPos
local bInvert = EgtGetInfo( vSplitIds[i], WIN_INV_SPLIT, 'b') or false
if bInvert then
vOffs[i] = - vOffs[i]
end
dPrevPos = dNewPos
end
return vOffs
end
---------------------------------------------------------------------
local function CalculateSplitOutline( nAreaId, vSplitIds, sName)
-- recupero l'outline e creo composita del bordo
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
local vOutlineIds = EgtGetAllInGroup( nOutlineLayerId)
local nOutlineCompo = EgtCurveCompo( nAreaId, vOutlineIds, false)
for i = 1, #vOutlineIds do
EgtCurveCompoSetTempProp( nOutlineCompo, i - 1, vOutlineIds[i])
end
local nSplitType = EgtGetInfo( vSplitIds[1], WIN_SPLITTYPE, 'i')
-- creo i pezzi associati ( per avere i profili corretti da usare per i conti del posizionamento)
if nSplitType ~= WIN_SPLITTYPES.FRENCH then
local vSplitDim = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vd') or {}
for i = 1, #vSplitIds do
CreateOutlinePart( vSplitIds[i], sName, vSplitDim[i])
EgtSetInfo( vSplitIds[i], WIN_PART_DIM, vSplitDim[i])
-- imposto le giunzioni
EgtSetInfo( vSplitIds[i], WIN_STARTJOINT, WIN_PART_JNT.SHORT)
EgtSetInfo( vSplitIds[i], WIN_ENDJOINT, WIN_PART_JNT.SHORT)
end
end
-- posiziono correttamente gli split e li taglio con l'outline
local vOffs = CalcSplitPositionOffsets( nAreaId, nAreaId, vSplitIds, nSplitType)
for i = 1, #vSplitIds do
EgtOffsetCurve( vSplitIds[i], vOffs[i])
TrimSplitWithOutline( vSplitIds[i], nOutlineCompo, vOutlineIds)
end
if nSplitType ~= WIN_SPLITTYPES.FRENCH then
-- ricavo prev e next
GetSplitsPrevNextOutline( vSplitIds, vOutlineIds)
-- creo l'outline delle aree figlie di tipo null
local vChildAreas = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*')
CalculateNullOutline( nOutlineCompo, vSplitIds, vChildAreas)
end
EgtErase( nOutlineCompo)
end
---------------------------------------------------------------------
local function CalculateGridSplitOutline( nAreaId, vSplitIds, sName)
local vAreas = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*')
local vVirtualAreas = EgtGetNameInGroup( nAreaId, WIN_VIRTUAL_AREA)
-- raggruppo gli split e le aree per ordine
local tabGrid = {}
for i = 1, #vSplitIds do
local nOrder = EgtGetInfo( vSplitIds[i], WIN_GRIDSPLIT_ORDER, 'i')
if tabGrid[nOrder] then
table.insert( tabGrid[nOrder], vSplitIds[i])
else
tabGrid[nOrder] = { vSplitIds[i]}
end
end
local tabAreas = {}
for i = 1, #vAreas do
local nOrder = EgtGetInfo( vAreas[i], WIN_GRIDSPLIT_ORDER, 'i')
if tabAreas[nOrder] then
table.insert( tabAreas[nOrder], vAreas[i])
else
tabAreas[nOrder] = { vAreas[i]}
end
end
-- creo i pezzi
local vDimMain = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vd') or {}
local vDimOther = EgtGetInfo( vVirtualAreas[1], WIN_PART_DIM, 'vd') or {}
for i = 0, #tabGrid do
for j = 1, #tabGrid[i] do
local dDim = EgtIf( i == 0, vDimMain[j], vDimOther[j])
CreateOutlinePart( tabGrid[i][j], sName, dDim)
EgtSetInfo( tabGrid[i][j], WIN_PART_DIM, dDim)
-- imposto le giunzioni
EgtSetInfo( tabGrid[i][j], WIN_STARTJOINT, WIN_PART_JNT.SHORT)
EgtSetInfo( tabGrid[i][j], WIN_ENDJOINT, WIN_PART_JNT.SHORT)
end
end
-- calcolo gli offset
local vOffsMain = CalcSplitPositionOffsets( nAreaId, nAreaId, tabGrid[0])
local vOffsSecondary = CalcSplitPositionOffsets( nAreaId, vVirtualAreas[1], tabGrid[1])
for i = 0, #tabGrid do
-- recupero l'area di riferimento che racchiude gli split ( i.e. l'area dello split per split principali, area virtuale i-esima per split secondari) e ne costruisco il bordo
local nRefAreaId = EgtIf( i == 0, nAreaId, vVirtualAreas[i])
local nOutlineLayerId = EgtGetFirstNameInGroup( nRefAreaId, WIN_OUTLINE)
local vOutlineIds = EgtGetAllInGroup( nOutlineLayerId)
local nOutlineCompo = EgtCurveCompo( nAreaId, vOutlineIds, false)
for i = 1, #vOutlineIds do
EgtCurveCompoSetTempProp( nOutlineCompo, i - 1, vOutlineIds[i])
end
-- posiziono correttamente e taglio con outline
local vOffs = EgtIf( i == 0, vOffsMain, vOffsSecondary)
for j = 1, #tabGrid[i] do
EgtOffsetCurve( tabGrid[i][j], vOffs[j])
if not TrimSplitWithOutline( tabGrid[i][j], nOutlineCompo, vOutlineIds) then
-- se split fuoriesce dalla sottoarea lo elimino insieme al pezzo associato
local nPartId = EgtGetInfo( tabGrid[i][j], WIN_REF_PART, 'i')
EgtErase( nPartId)
EgtErase( tabGrid[i][j])
tabGrid[i][j] = nil
end
end
-- ricavo prev e next
GetSplitsPrevNextOutline( tabGrid[i], vOutlineIds)
-- creo gli outline delle aree figlie ( i.e. aree virtuali per split principale, sottoaree di ordine i-esimo per split secondari di ordine i-esimo)
CalculateNullOutline( nOutlineCompo, tabGrid[i], EgtIf( i == 0, vVirtualAreas, tabAreas[i]))
EgtErase( nOutlineCompo)
end
end
------------------------------ SASH -------------------------------
---------------------------------------------------------------------
-- 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 dDeltaOffs = EgtGetInfo( nProfileId, WIN_RAILOFFS , 'd') or 0
local dOffs = b3FrameProfile:getMin():getX() - dDeltaOffs
EgtOffsetCurve( nCrv, dOffs)
end
vCrvs = TrimOrderedCurves( vCrvs, true)
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 identifica la forma dell'anta/gruppo di ante
local function IdentifySashShape( nAreaId, nOutlineLayerId)
local vOutlines = EgtGetAllInGroup( nOutlineLayerId)
local nCompoId = EgtCurveCompo( nOutlineLayerId, vOutlines, false)
-- verifico se trapezio
local bTrap, ptOrig, vtB1, vtE1, vtB2 = EgtCurveIsATrapezoid( nCompoId)
if bTrap then
-- verifico se rettangolo controllando se lati sono paralleli
local vtE2 = vtB1 + vtE1 - vtB2
if AreSameOrOppositeVectorApprox( vtE1, vtE2) then
EgtSetInfo( nAreaId, WIN_SASH_SHAPE, WIN_SASH_SHAPES.RECT)
else
EgtSetInfo( nAreaId, WIN_SASH_SHAPE, WIN_SASH_SHAPES.TRAP)
end
else
-- verifico se cerchio
local bCircle = EgtCurveIsACircle( nCompoId)
if bCircle then
EgtSetInfo( nAreaId, WIN_SASH_SHAPE, WIN_SASH_SHAPES.CIRCLE)
-- verifico se forma con arco
elseif #vOutlines == 4 and EgtGetType( vOutlines[3]) == GDB_TY.CRV_ARC then
local dAngCenter = EgtArcAngCenter( vOutlines[3])
if abs( dAngCenter - 180) < GEO.EPS_SMALL then
EgtSetInfo( nAreaId, WIN_SASH_SHAPE, WIN_SASH_SHAPES.ROUND_ARC)
else
if abs( EgtCurveLength( vOutlines[2]) - EgtCurveLength( vOutlines[4])) < GEO.EPS_SMALL then
EgtSetInfo( nAreaId, WIN_SASH_SHAPE, WIN_SASH_SHAPES.SEGMENTAL_ARC)
else
-- verifico se metà di arco a tutto sesto o ribassato
if AreSameVectorApprox( EgtEV( vOutlines[2]), EgtSV( vOutlines[3])) or AreSameVectorApprox( EgtEV( vOutlines[3]), EgtSV( vOutlines[4])) then
EgtSetInfo( nAreaId, WIN_SASH_SHAPE, WIN_SASH_SHAPES.SEMI_ROUND_ARC)
else
EgtSetInfo( nAreaId, WIN_SASH_SHAPE, WIN_SASH_SHAPES.SEMI_SEGMENTAL_ARC)
end
end
end
else
EgtSetInfo( nAreaId, WIN_SASH_SHAPE, WIN_SASH_SHAPES.GENERIC)
end
end
EgtErase( nCompoId)
end
---------------------------------------------------------------------
local function CalculateSashOutline( nAreaId, nAreaLayerId, nOutlineLayerId)
-- calcolo l'outline corrispondente al telaio
local nFrameArea = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*')
local nFrameOutlineLayer = EgtGetFirstNameInGroup( nFrameArea, WIN_OUTLINE)
local vFrameOutlines = EgtGetAllInGroup( nFrameOutlineLayer)
local vFrameOffs = {}
-- calcolo gli offset da applicare ad ogni curva
for i = 1, #vFrameOutlines do
-- recupero il suo profilo per calcolare l'offset ( se pezzo contro vetro fisso non serve, sarà tagliato da uno split)
local nProfileId = GetOutlineProfileId( vFrameOutlines[i])
local sKey = EgtIf( EgtGetName( vFrameOutlines[i]) == WIN_BOTTOM, WIN_SASH_BOTTOM_OVERLAP, WIN_SASH_TOP_OVERLAP)
local dOverlap = EgtGetInfo( nProfileId, sKey, 'd')
if dOverlap then
local b3Profile = GetProfileLocalBox( nProfileId)
vFrameOffs[i] = b3Profile:getMin():getX() + dOverlap
end
end
-- costruisco l'outline
for i = 1, #vFrameOutlines do
local nOutlineId = EgtCopyGlob( vFrameOutlines[i], nOutlineLayerId)
EgtSetInfo( nOutlineId, WIN_SOU_OUTLINE, vFrameOutlines[i])
-- rimuovo info che non voglio trasferire sull'anta
EgtRemoveInfo( nOutlineId, WIN_PRF_CHANGE)
EgtRemoveInfo( nOutlineId, WIN_THRESHOLD)
EgtRemoveInfo( nOutlineId, WIN_PART_DIM)
-- applico l'offset
if vFrameOffs[i] then
EgtOffsetCurve( nOutlineId, vFrameOffs[i])
else
-- se non ha offset definito è un pezzo che verrà tagliato da uno split ma, affinchè la forma del telaio sia coerente, se è in tangenza con uno dei suoi vicini
-- devo applicare lo stesso offset
local nPrevIdx = EgtIf( i == 1, #vFrameOutlines, i-1)
local nNextIdx = EgtIf( i == #vFrameOutlines, 1, i+1)
if AreSameVectorApprox( EgtSV( vFrameOutlines[i]), EgtEV( vFrameOutlines[nPrevIdx])) then
while not vFrameOffs[nPrevIdx] do
nPrevIdx = EgtIf( nPrevIdx == 1, #vFrameOutlines, nPrevIdx-1)
end
EgtOffsetCurve( nOutlineId, vFrameOffs[nPrevIdx])
vFrameOffs[i] = vFrameOffs[nPrevIdx]
elseif AreSameVectorApprox( EgtEV( vFrameOutlines[i]), EgtSV( vFrameOutlines[nNextIdx])) then
while not vFrameOffs[nNextIdx] do
nNextIdx = EgtIf( nNextIdx == #vFrameOutlines, 1, nNextIdx+1)
end
EgtOffsetCurve( nOutlineId, vFrameOffs[nNextIdx])
vFrameOffs[i] = vFrameOffs[nNextIdx]
end
end
end
-- accorcio gli offset
local vCrvs = TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true)
-- 2) taglio con eventuali split
local vSplitAreas = {}
local nParentArea = EgtGetParent( nAreaId)
while nParentArea ~= nFrameArea do
local nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i')
if nAreaType == WIN_AREATYPES.SPLIT then
table.insert( vSplitAreas, nParentArea)
end
nParentArea = EgtGetParent( nParentArea)
end
if #vSplitAreas > 0 then
-- creo bordo complessivo dell'outline, salvando le info di SouOutline come temp prop della curva per non perderle
local vSouOutlines = {}
for i = 1, #vCrvs do
vSouOutlines[i] = EgtGetInfo( vCrvs[i], WIN_SOU_OUTLINE, 'i')
end
local nCompo = EgtCurveCompo( nOutlineLayerId, vCrvs)
for i = 0, #vCrvs - 1 do
EgtCurveCompoSetTempProp( nCompo, i, vSouOutlines[i+1])
end
-- recupero gli split coinvolti dalle ante
local vBaseOutlines = EgtGetAllInGroup( nAreaLayerId)
local tabSplits = {}
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 sash 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)
-- rimuovo info che non voglio trasferire
EgtRemoveInfo( nOutlineId, WIN_PRF_CHANGE)
EgtRemoveInfo( nOutlineId, WIN_INV_SPLIT)
-- 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 nProfileId = GetOutlineProfileId( nSplitOutline)
if nProfileId then
local b3Profile = GetProfileLocalBox( nProfileId)
local sKey = EgtIf( EgtGetName( tabSplits[vSplitBaseOutlines[j]]) == WIN_BOTTOM, WIN_SASH_BOTTOM_OVERLAP, WIN_SASH_TOP_OVERLAP)
local dOverlap = EgtGetInfo( nProfileId, sKey, 'd')
local dFillPerpOffset = abs( b3Profile:getMin():getX()) - dOverlap
EgtOffsetCurve( nOutlineId, - dFillPerpOffset)
else
-- è french split quindi non ha offset
end
-- b) aggiorno la curva complessiva di outline con la curva appena calcolata
EgtExtendCurveStartByLen( nOutlineId, 1000)
EgtExtendCurveEndByLen( nOutlineId, 1000)
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
local nOutlineId = nCrv + i
EgtSetInfo( nOutlineId, WIN_SOU_OUTLINE, vTempProps[i+1])
-- sistemo il nome
if EgtGetName( abs( vTempProps[i+1])) == WIN_SPLIT then
local nBaseSplit = EgtGetInfo( abs( vTempProps[i+1]), WIN_COPY, 'i')
EgtSetName( nOutlineId, EgtGetName( tabSplits[nBaseSplit]))
else
EgtSetName( nOutlineId, EgtGetName( abs( vTempProps[i+1])))
end
end
-- riordino in modo da avere il bottom come prima curva
for i = 0, nCnt - 1 do
if EgtGetName( nCrv + i) ~= WIN_BOTTOM then
EgtRelocateGlob( nCrv + i, nOutlineLayerId, GDB_IN.LAST_SON)
else
break
end
end
end
-- calcolo i profili
local vOutlineCrvs = EgtGetAllInGroup( nOutlineLayerId)
CalcSashProfiles( vOutlineCrvs, nAreaId)
-- spostamento in z : recupero la quota da un profilo dell'anta
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
local sSashProfile = EgtGetInfo( vOutlineCrvs[1], WIN_PROFILETYPE)
local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile)
local dSashZOffset = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd')
EgtMove( vOutlineCrvs, Z_AX() * dSashZOffset)
return vOutlineCrvs
end
---------------------------------------------------------------------
local function VerifySashParts( vOutlines, nAreaId)
-- controlla se i pezzi di un'anta sono validi e se necessitano di gestione speciale nel calcolo dei prev e dei next. Vi sono due tipologie di pezzi che richiedono gestione speciale :
-- a) extra : il pezzo non serve, il suo contributo si limita al trim dei suoi pezzi vicini con il suo bordo out
-- b) special : il pezzo è necessario ma non sufficiente per il trim dei suoi pezzi vicini, che vanno tagliati non solo con il pezzo stesso ma anche tra di loro
-- per distinguere i pezzi extra da special controllo se i semiprofili interni dei pezzi vicini si incontrano in un punto sensato per cui il pezzo risulta superfluo oppure no
local nGrpTmp1 = EgtGroup( nAreaId)
local nGrpTmp2 = EgtGroup( nAreaId)
-- recupero i bordi interni ed esterni dei semiprofili in
local vInSemiProfile = {}
local vOutSemiProfile = {}
for i = 1, #vOutlines do
-- recupero il semiprofilo in
local nProfileId = GetOutlineProfileId( vOutlines[i])
local nSectionFrId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
local frSectionFrame = EgtFR( nSectionFrId, GDB_ID.ROOT)
local nInId = EgtGetFirstNameInGroup( nProfileId, WIN_IN)
local b3In = EgtGetBBoxRef( nInId, GDB_BB.STANDARD, frSectionFrame)
vInSemiProfile[i] = EgtCopyGlob( vOutlines[i], nGrpTmp1)
EgtSetInfo( vInSemiProfile[i], 'SouIdx', i)
-- se non è possibile calcolare l'interno ( e.g. arco con raggio inferiore alla sua dimensione) il pezzo è sicuramente extra ma considero comunque le sue curve nel fare i conti
-- per non sfalsare gli indici
if not EgtOffsetCurve( vInSemiProfile[i], b3In:getMin():getX()) then
EgtSetInfo( vOutlines[i], WIN_EXTRA_CRV, true)
end
vOutSemiProfile[i] = EgtCopyGlob( vOutlines[i], nGrpTmp2)
EgtOffsetCurve( vOutSemiProfile[i], b3In:getMax():getX())
EgtSetInfo( vOutSemiProfile[i], 'SouIdx', i)
end
local _, vExtraIn = TrimOrderedCurves( vInSemiProfile, false)
-- se nessun bordo più interno scompare allora tutti i pezzi sono standard
if #vExtraIn == 0 then
EgtErase( nGrpTmp1)
EgtErase( nGrpTmp2)
return
end
local _, vExtraOut = TrimOrderedCurves( vOutSemiProfile, false)
-- se il bordo esterno del suo profilo in scompare i suoi vicini si incontrano in modo sensato quindi il pezzo è sicuramente superfluo
for i = 1, #vExtraOut do
local nIdx = EgtGetInfo( vExtraOut[i], 'SouIdx', 'i')
EgtSetInfo( vOutlines[nIdx], WIN_EXTRA_CRV, true)
end
-- analizzo i tratti con gestione speciale consecutivi insieme
local nOldId
local vExtraInGrps = {}
for i = 1, #vExtraIn do
local nIdx = EgtGetInfo( vExtraIn[i], 'SouIdx', 'i')
if not EgtGetInfo( vOutlines[nIdx], WIN_EXTRA_CRV, 'b') then
if not nOldId or EgtGetNext( nOldId) ~= vExtraIn[i] then
table.insert( vExtraInGrps, { vExtraIn[i]})
else
table.insert( vExtraInGrps[#vExtraInGrps], vExtraIn[i])
end
nOldId = vExtraIn[i]
end
end
for i = 1, #vExtraInGrps do
-- calcolo il punto di incontro dei semiprofili interni dei due pezzi vicini validi
local nIdx1 = EgtGetInfo( vExtraInGrps[i][1], 'SouIdx', 'i')
local nPrevIdx = EgtIf( nIdx1 == 1, #vOutlines, nIdx1-1)
while EgtGetInfo( vOutlines[nPrevIdx], WIN_EXTRA_CRV, 'b') do
nPrevIdx = EgtIf( nPrevIdx == 1, #vOutlines, nPrevIdx-1)
end
local nIdx2 = EgtGetInfo( vExtraInGrps[i][#vExtraInGrps[i]], 'SouIdx', 'i')
local nNextIdx = EgtIf( nIdx2 == #vOutlines, 1, nIdx2+1)
while EgtGetInfo( vOutlines[nNextIdx], WIN_EXTRA_CRV, 'b') do
nNextIdx = EgtIf( nNextIdx == #vOutlines, 1, nNextIdx+1)
end
local nPrevOut = vOutSemiProfile[nPrevIdx]
local nNextOut = vOutSemiProfile[nNextIdx]
local ptInters = FindIntersectionPoint( nPrevOut, nNextOut, EgtEP( nPrevOut))
-- ricavo le curva che delimita la regione valida per l'intersezione dei semiprofili dei pezzi vicini
local vCurrOutlines = {}
for j = 1, #vExtraInGrps[i] do
local nIdx = EgtGetInfo( vExtraInGrps[i][j], 'SouIdx', 'i')
vCurrOutlines[j] = vOutlines[nIdx]
end
local nCompoOutline = EgtCurveCompo( nGrpTmp1, vCurrOutlines, false)
local nProfileId = GetOutlineProfileId( vCurrOutlines[1])
local nSectionFrId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
local frSectionFrame = EgtFR( nSectionFrId, GDB_ID.ROOT)
local nCPId = EgtGetFirstNameInGroup( nProfileId, WIN_OUT)
local b3CP = EgtGetBBoxRef( nCPId, GDB_BB.STANDARD, frSectionFrame)
local nRefCrv = EgtOffsetCurveAdv( nCompoOutline, b3CP:getMin():getX())
local _, _, nSide = EgtPointCurveDistSide( ptInters, nRefCrv, Z_AX())
for j = 1, #vCurrOutlines do
-- se il punto di intersezione cade nella regione valida il pezzo è extra altrimenti è special
if nSide == -1 then
EgtSetInfo( vCurrOutlines[j], WIN_EXTRA_CRV, true)
else
EgtSetInfo( vCurrOutlines[j], WIN_SPECIAL_CRV, true)
end
end
end
EgtErase( nGrpTmp1)
EgtErase( nGrpTmp2)
end
---------------------------------------------------------------------
local function GetSashPrevNextOutlines( vOutlineIds, nOutlineLayerId, nAreaId)
local vJoints = EgtGetInfo( nAreaId, WIN_JOINTS, 'vi')
for i = 1, #vOutlineIds do
if EgtGetInfo( vOutlineIds[i], WIN_EXTRA_CRV, 'b') then
-- non c'è bisogno di settare prev/next perchè il pezzo viene ignorato
else
-- a) prev
local nPrevId = EgtGetPrev( vOutlineIds[i]) or EgtGetLastInGroup( nOutlineLayerId)
local bExtra = EgtGetInfo( nPrevId, WIN_EXTRA_CRV, 'b') or false
local bSpecial = EgtGetInfo( nPrevId, WIN_SPECIAL_CRV, 'b') or false
if not bExtra and not bSpecial then
-- se il precedente è un pezzo standard il prev è solamente lui e il joint calcolato è già corretto
EgtSetInfo( vOutlineIds[i], WIN_PREV_OUTLINES, nPrevId)
else
-- recupero tutti i precedenti fino a quando non trovo un elemento standard
local vPrevIds = {}
while bExtra or bSpecial do
table.insert( vPrevIds, 1, nPrevId)
nPrevId = EgtGetPrev( nPrevId) or EgtGetLastInGroup( nOutlineLayerId)
bExtra = EgtGetInfo( nPrevId, WIN_EXTRA_CRV, 'b') or false
bSpecial = EgtGetInfo( nPrevId, WIN_SPECIAL_CRV, 'b') or false
end
table.insert( vPrevIds, 1, nPrevId)
-- calcolo i joints
local vStartJoints = {}
local nOldId = vOutlineIds[i]
local nOldTgId = vOutlineIds[i]
local bTangChain = true -- indica se l'outline e i primi vicini formano una catena di curve in tangenza
local nJoint -- il primo joint non è quello salvato nelle info della curva ma è da calcolare con la prima curva non extra
for j = #vPrevIds, 1, -1 do
if EgtGetInfo( vPrevIds[j], WIN_EXTRA_CRV, 'b') then
-- con i pezzi extra la giunzione è sempre full perchè il pezzo corrente va trimmato con il loro bordo esterno
vStartJoints[j] = WIN_PART_JNT.FULL
else
if not nJoint then
nJoint = CalcOutlineStartJoint( nOldId, vPrevIds[j], vJoints)
end
if AreSameVectorApprox( EgtEV( vPrevIds[j]), EgtSV( nOldTgId)) then
-- curve in tangenza devono avere la stessa giunzione
vStartJoints[j] = nJoint
else
-- se arrivo dalla catena di primi vicini tangenti devo ricalcolare il joint altrimenti va forzato ad angled
if bTangChain then
nJoint = CalcOutlineStartJoint( nOldId, vPrevIds[j], vJoints)
else
nJoint = WIN_PART_JNT.ANGLED
end
bTangChain = false
vStartJoints[j] = nJoint
end
nOldId = vPrevIds[j]
end
-- gli extra vanno ignorati nel calcolo delle giunzioni ma vanno considerati per il calcolo delle tangenze
nOldTgId = vPrevIds[j]
end
EgtSetInfo( vOutlineIds[i], WIN_PREV_OUTLINES, vPrevIds)
EgtSetInfo( vOutlineIds[i], WIN_STARTJOINT, vStartJoints)
end
-- b) next
local nNextId = EgtGetNext( vOutlineIds[i]) or EgtGetFirstInGroup( nOutlineLayerId)
bExtra = EgtGetInfo( nNextId, WIN_EXTRA_CRV, 'b') or false
bSpecial = EgtGetInfo( nNextId, WIN_SPECIAL_CRV, 'b') or false
if not bExtra and not bSpecial then
-- caso standard
EgtSetInfo( vOutlineIds[i], WIN_NEXT_OUTLINES, nNextId)
else
local vNextIds = {}
while bExtra or bSpecial do
table.insert( vNextIds, nNextId)
nNextId = EgtGetNext( nNextId) or EgtGetFirstInGroup( nOutlineLayerId)
bExtra = EgtGetInfo( nNextId, WIN_EXTRA_CRV, 'b') or false
bSpecial = EgtGetInfo( nNextId, WIN_SPECIAL_CRV, 'b')
end
table.insert( vNextIds, nNextId)
-- calcolo i joints
local vEndJoints = {}
local nOldId = vOutlineIds[i]
local nOldTgId = vOutlineIds[i]
local bTangChain = true
local nJoint
for j = 1, #vNextIds do
-- se extra la giunzione deve essere full
if EgtGetInfo( vNextIds[j], WIN_EXTRA_CRV, 'b') then
vEndJoints[j] = WIN_PART_JNT.FULL
else
if not nJoint then
nJoint = CalcOutlineEndJoint( nOldId, vNextIds[j], vJoints)
end
if AreSameVectorApprox( EgtEV( nOldTgId), EgtSV( vNextIds[j])) then
vEndJoints[j] = nJoint
else
if bTangChain then
nJoint = CalcOutlineEndJoint( nOldId, vNextIds[j], vJoints)
else
nJoint = WIN_PART_JNT.ANGLED
end
bTangChain = false
vEndJoints[j] = nJoint
end
nOldId = vNextIds[j]
end
nOldTgId = vNextIds[j]
end
EgtSetInfo( vOutlineIds[i], WIN_NEXT_OUTLINES, vNextIds)
EgtSetInfo( vOutlineIds[i], WIN_ENDJOINT, vEndJoints)
end
end
end
end
------------------------------ FILL -------------------------------
---------------------------------------------------------------------
local function CalculateFillOutline( nAreaId, nOutlineLayerId)
-- recupero area parent di tipo telaio/anta che la contiene
local nParentArea = EgtGetParent( nAreaId)
local nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i')
while nAreaType ~= WIN_AREATYPES.FRAME and nAreaType ~= WIN_AREATYPES.SASH do
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 dDeltaZ = 0
local vParentOutlines = EgtGetAllInGroup( nParentOutlineLayer)
local vParentOffs = {}
-- calcolo gli offset
for i = 1, #vParentOutlines do
-- recupero il suo profilo per calcolare l'offset perpendicolare
local nParentProfileId = GetOutlineProfileId( vParentOutlines[i], true)
local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd')
if dOverlap then
local b3FrameProfile = GetProfileLocalBox( nParentProfileId)
local dDimRef = b3FrameProfile:getMin():getX()
-- verifico se contributo per bottomrail
local dRailOffs = EgtGetInfo( nParentProfileId, WIN_RAILOFFS, 'd') or 0
vParentOffs[i] = abs( dDimRef) - dOverlap + dRailOffs
-- movimento in z
if dDeltaZ < GEO.EPS_SMALL then
dDeltaZ = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd')
end
end
end
-- creo le curve di outlines
for i = 1, #vParentOutlines do
-- copio la curva di outline del parent
local nOutlineId = EgtCopy( vParentOutlines[i], nOutlineLayerId)
EgtSetInfo( nOutlineId, WIN_SOU_OUTLINE, vParentOutlines[i])
-- applico offset
if vParentOffs[i] then
EgtOffsetCurve( nOutlineId, - vParentOffs[i])
else
-- se non ha offset definito è un pezzo che verrà tagliato da uno split ma, affinchè la forma del telaio sia coerente, devo applicare lo stesso offset a curve
-- che sono in tangenza
local nPrevIdx = EgtIf( i == 1, #vParentOutlines, i-1)
local nNextIdx = EgtIf( i == #vParentOutlines, 1, i+1)
if AreSameVectorApprox( EgtSV( vParentOutlines[i]), EgtEV( vParentOutlines[nPrevIdx])) then
while not vParentOffs[nPrevIdx] do
nPrevIdx = EgtIf( nPrevIdx == 1, #vParentOutlines, nPrevIdx-1)
end
EgtOffsetCurve( nOutlineId, - vParentOffs[nPrevIdx])
vParentOffs[i] = vParentOffs[nPrevIdx]
elseif AreSameVectorApprox( EgtEV( vParentOutlines[i]), EgtSV( vParentOutlines[nNextIdx])) then
while not vParentOffs[nNextIdx] do
nNextIdx = EgtIf( nNextIdx == #vParentOutlines, 1, nNextIdx+1)
end
EgtOffsetCurve( nOutlineId, - vParentOffs[nNextIdx])
vParentOffs[i] = vParentOffs[nNextIdx]
end
end
end
-- accorcio gli offset
local vCrvs = TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true)
-- applico spostamento verticale
EgtMove( vCrvs, Z_AX() * dDeltaZ)
-- 2) taglio con split
local nParentType = EgtGetInfo( EgtGetParent( nAreaId), WIN_AREATYPE, 'i')
if nParentType ~= WIN_AREATYPES.NULL then
return
end
-- creo bordo complessivo dell'outline, salvando le info come temp prop della curva per non perderle
local vSouOutlines = {}
for i = 1, #vCrvs do
vSouOutlines[i] = EgtGetInfo( vCrvs[i], WIN_SOU_OUTLINE, 'i')
end
local nCompo = EgtCurveCompo( nOutlineLayerId, vCrvs)
for i = 0, #vCrvs - 1 do
EgtCurveCompoSetTempProp( nCompo, i, vSouOutlines[i+1])
end
-- recupero gli split che definiscono l'area fill cercando gli split da cui derviano gli elementi dell'area null parent
local vSplitIds = {}
local nNullOutlineLayer = EgtGetFirstNameInGroup( EgtGetParent( nAreaId), WIN_OUTLINE)
local vNullOutlines = EgtGetAllInGroup( nNullOutlineLayer)
for i = 1, #vNullOutlines do
local nSouOutline = GetNonVirtualOutline( vNullOutlines[i])
if EgtGetName( abs( nSouOutline)) == WIN_SPLIT then
table.insert( vSplitIds, nSouOutline)
end
end
-- li ordino per id crescente in modo da effettuare i tagli nell'ordine corretto
table.sort( vSplitIds, function ( a, b) return abs( a) < abs( b) end)
for i = 1, #vSplitIds do
-- creo la curva di outline corrispondente allo split
local nOutlineId = EgtCopy( abs( vSplitIds[i]), nOutlineLayerId)
if vSplitIds[i] < 0 then
EgtInvertCurve( nOutlineId)
end
-- calcolo gli offset
local nParentProfileId = GetOutlineProfileId( abs( vSplitIds[i]), true)
local b3FrameProfile = GetProfileLocalBox( nParentProfileId)
local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd')
local bMixedSplit = EgtGetInfo( abs( vSplitIds[i]), 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)
-- 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, vSplitIds[i])
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_SOU_OUTLINE, vTempProps[i+1])
end
end
---------------------------------------------------------------------
---------------------------------------------------------------------
-- funzione che calcola l'outline dal base outline e i pezzi associati
local function CalculateOutlineFromAreaOutline( nAreaId)
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
local sName = CalcPartName( nAreaId, nAreaType)
-- se area null il suo outline è già stato calcolato dalla sua area split parent
if nAreaType == WIN_AREATYPES.NULL then
return
end
-- creo gruppo per outline
local nOutlineLayerId = EgtGroup( nAreaId)
EgtSetName( nOutlineLayerId, WIN_OUTLINE)
EgtSetStatus( nOutlineLayerId, GDB_ST.OFF)
-- FRAME
if nAreaType == WIN_AREATYPES.FRAME then
-- l'outline è la copia del base outline
local nBaseOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
local nBaseOutlineId = EgtGetFirstInGroup( nBaseOutlineLayerId)
while nBaseOutlineId do
EgtCopyGlob( nBaseOutlineId, nOutlineLayerId)
nBaseOutlineId = EgtGetNext( nBaseOutlineId)
end
local vOutlines = EgtGetAllInGroup( nOutlineLayerId)
GetFramePrevNextOutline( vOutlines, nOutlineLayerId)
-- creo i pezzi
CreatePartsFromOutlines( vOutlines, nAreaId, sName)
-- SPLIT
elseif nAreaType == WIN_AREATYPES.SPLIT then
-- l'outline è copia del parent outline
local nParentId = EgtGetParent( nAreaId)
local nParentOutlineId = EgtGetFirstNameInGroup( nParentId, WIN_OUTLINE)
local vParentOutlines = EgtGetAllInGroup( nParentOutlineId)
for i = 1, #vParentOutlines do
local nOutlineId = EgtCopyGlob( vParentOutlines[i], nOutlineLayerId)
EgtSetInfo( nOutlineId, WIN_SOU_OUTLINE, vParentOutlines[i])
end
-- copio il layer di base split
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)
for i = 1, #vSplitIds do
-- TODO verificare se possibile evitare questa associazione ( calcolo sash outline)
EgtSetInfo( vSplitIds[i], WIN_COPY, vBaseSplitIds[i])
EgtSetInfo( vBaseSplitIds[i], WIN_COPY, vSplitIds[i])
end
-- se split interni ad anta ricavo quota in z dal suo profilo
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 nSashOutlineLayerId = EgtGetFirstNameInGroup( nSashAreaId, WIN_OUTLINE)
local nSashOutlineId = EgtGetFirstInGroup( nSashOutlineLayerId)
local nSashProfileId = GetOutlineProfileId( nSashOutlineId)
-- calcolo movimento in z
local dZMove = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd')
EgtMove( vSplitIds, dZMove * Z_AX())
end
-- aggiusto gli outlines e calcolo l'outline delle sottoaree null generate
local bGrid = EgtGetInfo( nAreaId, WIN_GRID_SPLIT, 'b') or false
if bGrid then
CalculateGridSplitOutline( nAreaId, vSplitIds, sName)
else
CalculateSplitOutline( nAreaId, vSplitIds, sName)
end
if nSplitType == WIN_SPLITTYPES.FRENCH then
IdentifySashShape( nAreaId, nOutlineLayerId)
end
-- SASH
elseif nAreaType == WIN_AREATYPES.SASH then
local nBaseOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
local vOutlines = CalculateSashOutline( nAreaId, nBaseOutlineLayerId, nOutlineLayerId)
-- creo i pezzi
CreatePartsFromOutlines( vOutlines, nAreaId, sName)
-- ne verifico validità
VerifySashParts( vOutlines, nAreaId)
-- assegno i prev e i next
GetSashPrevNextOutlines( vOutlines, nOutlineLayerId, nAreaId)
-- identifico la forma
IdentifySashShape( nAreaId, nOutlineLayerId)
-- disegno apertura
DrawOpening( nAreaId)
-- FILL
elseif nAreaType == WIN_AREATYPES.FILL then
CalculateFillOutline( nAreaId, nOutlineLayerId)
-- creo il pezzo associato
CreateFillPartFromArea( nAreaId, sName)
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
---------------------------------------------------------------------
-- funzione che cicla ricorsivamente su aree e sottoaree per assegnare i profili all'area
local function SetAreaProfiles( nAreaId)
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then
-- recupero i profili dalle curve di outline
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
local vOutlines = EgtGetAllInGroup( nOutlineLayerId)
local sAreaName = EgtIf( nAreaType == WIN_AREATYPES.FRAME, WIN_FRAME, WIN_SASH)
local vProfiles = {}
for i = 1, #vOutlines do
vProfiles[i] = sAreaName .. '_' .. EgtGetInfo( vOutlines[i], WIN_PROFILETYPE)
end
EgtSetInfo( nAreaId, WIN_AREA_PROFILES, vProfiles)
elseif nAreaType == WIN_AREATYPES.SPLIT then
local nSplitType = EgtGetInfo( nAreaId, WIN_SPLITTYPE, 'i')
if nSplitType ~= WIN_SPLITTYPES.FRENCH then
-- recupero area parent per capire se dentro telaio o anta
local nParentAreaId = EgtGetParent( nAreaId)
local nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i')
while nParentAreaType ~= WIN_AREATYPES.FRAME and nParentAreaType ~= WIN_AREATYPES.SASH do
nParentAreaId = EgtGetParent( nParentAreaId)
nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i')
end
local sAreaName = EgtIf( nParentAreaType == WIN_AREATYPES.FRAME, WIN_FRAME, WIN_SASH)
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT)
local vSplitIds = EgtGetAllInGroup( nSplitLayerId)
local bGridSplit = EgtGetInfo( nAreaId, WIN_GRID_SPLIT, 'b') or false
if bGridSplit then
-- recupero i profili distinguendoli per ordine di split
local tabProfiles = {}
for i = 1, #vSplitIds do
local nOrder = EgtGetInfo( vSplitIds[i], WIN_GRIDSPLIT_ORDER, 'i')
local sProfile = sAreaName .. '_' .. EgtGetInfo( vSplitIds[i], WIN_PROFILETYPE)
if tabProfiles[nOrder+1] then
table.insert( tabProfiles[nOrder+1], sProfile)
else
tabProfiles[nOrder+1] = { sProfile}
end
end
-- salvo in info separate
for i = 1, #tabProfiles do
EgtSetInfo( nAreaId, WIN_AREA_PROFILES .. tostring( i-1), tabProfiles[i])
end
else
-- recupero tutti i profili degli split
local vProfiles = {}
for i = 1, #vSplitIds do
vProfiles[i] = sAreaName .. '_' .. EgtGetInfo( vSplitIds[i], WIN_PROFILETYPE)
end
EgtSetInfo( nAreaId, WIN_AREA_PROFILES, vProfiles)
end
end
end
-- analizzo le sottoaree
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
while nChildAreaId do
SetAreaProfiles( nChildAreaId)
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
end
end
----------------------------------------------------------------------------------
-------------------------------- GEO -------------------------------------------
----------------------------------------------------------------------------------
-- funzione che crea il bisettore parabolico tra linea e arco
local function CalcParabolicBisector( nCrv1, nCrv2, dDim, nGrp, bArcExternal, bLineExternal)
-- modifico le curve affinchè abbiano estremo in comune
local ptInt = FindIntersectionPoint( nCrv1, nCrv2, EgtSP( nCrv2))
EgtModifyCurveStartPoint( nCrv2, ptInt)
EgtModifyCurveEndPoint( nCrv1, ptInt)
-- calcolo coefficienti dell'equazione del bisettore ( equazione presa da Vroni)
local nArc, nLine, nSign
if EgtGetType( nCrv1) == GDB_TY.CRV_ARC then
nArc = nCrv1
nLine = nCrv2
nSign = -1
else
nArc = nCrv2
nLine = nCrv1
nSign = 1
end
local ptC = EgtCP( nArc)
local dRad = EgtArcRadius( nArc)
-- equazione della retta
local dCoeffA = - EgtSV( nLine):getY()
local dCoeffB = EgtSV( nLine):getX()
local dCoeffC = - dCoeffA * ptInt:getX() - dCoeffB * ptInt:getY()
local dDist = dCoeffA * ptC:getX() + dCoeffB * ptC:getY() + dCoeffC
local dA = ptC:getX() - dCoeffA * dDist
local dB = ptC:getY() - dCoeffB * dDist
local dZ = ptC:getZ()
local k1 = EgtIf( bArcExternal, 1, -1) -- 1 esterno alla circonferenza / -1 interno alla circonferenza
local k2 = EgtIf( bLineExternal, 1, -1) -- 1 a destra della linea / -1 a sinistra della linea
-- campiono il bisettore ( è parametrizzato sul valore di offset t)
local vPoints = {}
local nTot = 50
for i = 1, nTot do
local t = dDim / ( nTot - 1) * ( i - 1)
local dDiscriminant = dRad * dRad + 2 * t * ( k1 * dRad - k2 * dDist) - dDist * dDist
local dX, dY
if dDiscriminant < GEO.EPS_ZERO then
dX = dA - k2 * dCoeffA * t
dY = dB - k2 * dCoeffB * t
else
dX = dA - k2 * dCoeffA * t + nSign * dCoeffB * sqrt( dDiscriminant)
dY = dB - k2 * dCoeffB * t - nSign * dCoeffA * sqrt( dDiscriminant)
end
vPoints[i] = Point3d( dX, dY, dZ)
end
local nCompo = EgtCurveCompoFromPoints( nGrp, vPoints)
return nCompo
end
---------------------------------------------------------------------
-- funzione simile a CalcIntersectionRegion ma con considerazioni speciali per le curve del geo ( e.g. gestione bisettori, curve doppie)
local function CalcGeoRegion( vCrvs, nGrp)
local nSurfId
local dExtraLen = 10000
-- gruppo temporaneo per i conti
local nGrpTmp = EgtGroup( nGrp)
EgtSetStatus( nGrpTmp, GDB_ST.OFF)
-- a) costruisco i semipiani e identifico le curve con gestione speciale
local vSemiPlanes = {}
local tArcs = {}
local vBisectors = {}
for i = 1, #vCrvs do
-- se linea costruisco il semipiano corrispondente
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( vSemiPlanes, nSemiPlaneId)
-- se arco calcolo estensione verificando se la curva è doppia
elseif EgtGetType( vCrvs[i]) == GDB_TY.CRV_ARC then
local bFound = false
local nRefOutline = EgtGetInfo( vCrvs[i], WIN_REF_OUTLINE, 'i')
if nRefOutline then
for j = 1, #tArcs do
if tArcs[j].nRefOutline == nRefOutline then
local nCopy = EgtCopyGlob( vCrvs[i], nGrpTmp)
CopyInfo( nCopy, tArcs[j].vOrigId[1], WIN_TANG_START, false)
CopyInfo( nCopy, vCrvs[i], WIN_TANG_END, false)
local nCrvId = CreateCurveExtension( nCopy, nGrpTmp)
tArcs[j].nCrvId = nCrvId
table.insert( tArcs[j].vOrigId, vCrvs[i])
bFound = true
break
end
end
end
if not bFound then
local nCrvId = CreateCurveExtension( vCrvs[i], nGrpTmp)
table.insert( tArcs, { nCrvId = nCrvId, vOrigId = { vCrvs[i]}, nRefOutline = nRefOutline, dRad = EgtArcRadius( vCrvs[i])})
end
-- se composita è bisettore con gestione speciale
else
local nCrvId = EgtCopyGlob( vCrvs[i], nGrpTmp)
table.insert( vBisectors, nCrvId)
end
end
-- b) calcolo la regione definita dai semipiani
for i = 2, #vSemiPlanes do
EgtSurfFrIntersect( vSemiPlanes[1], vSemiPlanes[i])
EgtErase( vSemiPlanes[i])
end
if EgtSurfFrChunkCount( vSemiPlanes[1]) == 0 then
return
end
nSurfId = vSemiPlanes[1]
-- c) se presenti archi, calcolo il loro contributo alla regione
if #tArcs > 0 then
local nCrvBorder = EgtExtractSurfFrChunkLoops( nSurfId, 0, nGrpTmp)
-- riordino 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
-- limito la curva estesa alla regione
local nSurfTrim = EgtSurfFlatRegion( nGrpTmp, nCrvBorder)
local nCrv, nCnt = EgtTrimCurveWithRegion( tArcs[i].nCrvId, nSurfTrim, true, false)
-- se errore lo ignoro
if not nCrv then
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
if EgtGetType( nCrv) == GDB_TY.CRV_ARC then
EgtModifyCurveStartPoint( nCrv, EgtSP( nCrv + nCnt - 1))
EgtErase( nCrv + nCnt - 1)
else
EgtAddCurveCompoCurve( nCrv, nCrv + nCnt - 1, true, false)
end
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)
if nInters then
if nCnt == 1 then
EgtChangeClosedCurveStartPoint( j, EgtSP( nInters))
end
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
end
-- modifico il bordo corrente considerando solo i tratti che poggiano sulle curve orginali
for j = 1, #vArcs do
for k = 1, #tArcs[i].vOrigId do
if CheckExtensionOverlap( vArcs[j], tArcs[i].vOrigId[k]) then
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])
break
end
end
end
end
end
-- ricostruisco la superficie
nSurfId = EgtSurfFlatRegion( nGrpTmp, nCrvBorder)
end
-- d) gestione di eventuali bisettori
if #vBisectors > 0 then
local nCrvBorder = EgtExtractSurfFrChunkLoops( nSurfId, 0, nGrpTmp)
for i = 1, #vBisectors do
local nCrv, nCnt = EgtTrimCurveWithRegion( vBisectors[i], nSurfId, true, false)
if nCrv and nCnt == 1 then
local dParS = EgtCurveParamAtPoint( nCrvBorder, EgtSP( nCrv), 100 * GEO.EPS_SMALL)
local dParE = EgtCurveParamAtPoint( nCrvBorder, EgtEP( nCrv), 100 * GEO.EPS_SMALL)
EgtTrimCurveStartEndAtParam( nCrvBorder, dParE, dParS)
EgtAddCurveCompoCurve( nCrvBorder, nCrv)
end
end
nSurfId = EgtSurfFlatRegion( nGrpTmp, nCrvBorder)
end
EgtRelocateGlob( nSurfId, nGrp)
EgtErase( nGrpTmp)
return nSurfId
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_PROFILETYPE)
if sProfileType == WIN_FILL_RAIL then
local dDelta = EgtGetInfo( nProfileId, WIN_RAILOFFS, 'd')
dCPDelta = dCPDelta + dDelta
end
return dCPDelta
end
---------------------------------------------------------------------
local function CheckSemiprofileIntersection( nGeoId, nPrevGeoId, nNextGeoId)
local nOutlineId = EgtGetInfo( nGeoId, WIN_REF_OUTLINE, 'i')
-- recupero la curva più interna del semiprofilo
local nSemiProfileId = EgtGetInfo( nGeoId, WIN_SEMI_PROFILE, 'i')
local nProfileId = EgtGetParent( nSemiProfileId)
local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
local frFrame = EgtFR( nFrameId, GDB_ID.ROOT)
local b3Box = EgtGetBBoxRef( nSemiProfileId, GDB_BB.STANDARD, frFrame)
local nInnerCrv = EgtCopyGlob( nOutlineId, EgtGetParent( nGeoId))
EgtOffsetCurve( nInnerCrv, b3Box:getMin():getX())
-- verifico se con estensione standard ( ovvero seguendo la circonferenza associata) arriva alle curve vicine del geo
local ptInt1 = FindIntersectionPoint( nInnerCrv, nPrevGeoId, ORIG())
local bTangStart = ( not ptInt1)
local ptInt2 = FindIntersectionPoint( nInnerCrv, nNextGeoId, ORIG())
local bTangEnd = ( not ptInt2)
EgtErase( nInnerCrv)
return bTangStart, bTangEnd
end
---------------------------------------------------------------------
-- funzione che stabilisce il tipo di estensione ( standard seguendo la circonferenza o lineare in tangenza) per curve del geo ad arco in base a condizioni euristiche per evitare giunzioni
-- problematiche
local function ComputeArcExtensions( nOutId, nInId, vLeftIds, vRightIds, vStartJoints, vEndJoints)
-- controllo euristico : verifico se la parte più interna del semiprofilo associato alla curva del geo ( ovvero considero tra i due archi che limitano il semiprofilo quello
-- con raggio minore perchè dovrebbe essere il più problematico) arriva alla curva di geo vicina con estensione standard oppure no
-- se curve in tangenza forza estensione in tangenza
-- se il pezzo corrente è arco devo verificare estensione per in e out
if EgtGetType( nOutId) == GDB_TY.CRV_ARC then
local bTangStart, bTangEnd = CheckSemiprofileIntersection( nOutId, vLeftIds[#vLeftIds], vRightIds[1])
-- verifico se necessaria estensione in tangenza per giunzione angled o per la curva in
if not bTangStart then
bTangStart = ( vStartJoints[#vStartJoints] == WIN_PART_JNT.ANGLED or not FindIntersectionPoint( nInId, vLeftIds[1], ORIG()))
end
EgtSetInfo( nOutId, WIN_TANG_START, bTangStart)
EgtSetInfo( nInId, WIN_TANG_END, bTangStart)
if not bTangEnd then
bTangEnd = ( vEndJoints[1] == WIN_PART_JNT.ANGLED or not FindIntersectionPoint( nInId, vRightIds[#vRightIds], ORIG()))
end
EgtSetInfo( nOutId, WIN_TANG_END, bTangEnd)
EgtSetInfo( nInId, WIN_TANG_START, bTangEnd)
end
-- verifico estensione left
for i = 1, #vLeftIds do
if EgtGetType( vLeftIds[i]) == GDB_TY.CRV_ARC then
local bTangS, bTangE = CheckSemiprofileIntersection( vLeftIds[i], nInId, nOutId)
-- se outline in tangenza con i vicini forzo estensione in tangenza
if not bTangS then
if vStartJoints[i] == WIN_PART_JNT.FULL or i == 1 or vStartJoints[i] == vStartJoints[i-1] then
local nOutlineId = EgtGetInfo( vLeftIds[i], WIN_REF_OUTLINE, 'i')
local nPrevOutlineId = EgtGetPrev( nOutlineId) or EgtGetLastInGroup( EgtGetParent( nOutlineId))
if AreSameVectorApprox( EgtEV( nPrevOutlineId), EgtSV( nOutlineId)) then
bTangS = true
end
end
end
if not bTangE then
if vStartJoints[i] == WIN_PART_JNT.FULL or i == #vLeftIds or vStartJoints[i] == vStartJoints[i+1] then
local nOutlineId = EgtGetInfo( vLeftIds[i], WIN_REF_OUTLINE, 'i')
local nNextOutlineId = EgtGetNext( nOutlineId) or EgtGetFirstInGroup( EgtGetParent( nOutlineId))
if AreSameVectorApprox( EgtEV( nOutlineId), EgtSV( nNextOutlineId)) then
bTangE = true
end
end
end
EgtSetInfo( vLeftIds[i], WIN_TANG_START, bTangS)
EgtSetInfo( vLeftIds[i], WIN_TANG_END, bTangE)
end
end
-- verifico estensione right
for i = 1, #vRightIds do
if EgtGetType( vRightIds[i]) == GDB_TY.CRV_ARC then
local bTangS, bTangE = CheckSemiprofileIntersection( vRightIds[i], nOutId, nInId)
if not bTangS then
if vEndJoints[i] == WIN_PART_JNT.FULL or i == 1 or vEndJoints[i] == vEndJoints[i-1] then
local nOutlineId = EgtGetInfo( vRightIds[i], WIN_REF_OUTLINE, 'i')
local nPrevOutlineId = EgtGetPrev( nOutlineId) or EgtGetLastInGroup( EgtGetParent( nOutlineId))
if AreSameVectorApprox( EgtEV( nPrevOutlineId), EgtSV( nOutlineId)) then
bTangS = true
end
end
end
if not bTangE then
if vEndJoints[i] == WIN_PART_JNT.FULL or i == #vRightIds or vEndJoints[i] == vEndJoints[i+1] then
local nOutlineId = EgtGetInfo( vRightIds[i], WIN_REF_OUTLINE, 'i')
local nNextOutlineId = EgtGetNext( nOutlineId) or EgtGetFirstInGroup( EgtGetParent( nOutlineId))
if AreSameVectorApprox( EgtEV( nOutlineId), EgtSV( nNextOutlineId)) then
bTangE = true
end
end
end
EgtSetInfo( vRightIds[i], WIN_TANG_START, bTangS)
EgtSetInfo( vRightIds[i], WIN_TANG_END, bTangE)
end
end
end
---------------------------------------------------------------------
-- funzione che crea le curve del geo
local function CreateGeoCurves( nOutlineId, vPrevOutlineId, vNextOutlineId, vStartJoints, vEndJoints, 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_PROFILETYPE)
if sProfileType == WIN_FILL_RAIL or sProfileType == WIN_RAIL then
-- scostamento extra legato al bottomrail
local dDelta = EgtGetInfo( nCurrProfileId, WIN_RAILOFFS, '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)
EgtSetInfo( nOutId, WIN_GEO_OFFS, dCurrOffset)
-- 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)
EgtSetInfo( nInId, WIN_GEO_OFFS, - dCurrOffset + b3CurrProfileFrame:getDimX())
-- curve left
local vPrevProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_START)
for i = 1, #vPrevOutlineId do
if vStartJoints[i] == WIN_PART_JNT.ANGLED then
-- recupero bordo out dell'altro pezzo ( non è detto coincida con l'outline)
local b3Profile = GetProfileLocalBox( vPrevProfileId[i])
local nOtherOut = EgtCopyGlob( vPrevOutlineId[i], nGeoLayerId)
EgtOffsetCurve( nOtherOut, b3Profile:getMax():getX())
-- a) calcolo bisettore: se pezzi lineari o in tangenza è segmento, altrimenti è tratto di parabola
local nBisector
if ( EgtGetType( nOutlineId) == GDB_TY.CRV_LINE and EgtGetType( vPrevOutlineId[i]) == GDB_TY.CRV_LINE) or
EgtEV( vPrevOutlineId[i]) * EgtSV( nOutlineId) > s_dAngledCos or
EgtGetName( nOutlineId) == EgtGetName( vPrevOutlineId[i]) then
local nOtherIn = EgtCopyGlob( vPrevOutlineId[i], nGeoLayerId)
EgtOffsetCurve( nOtherIn, b3Profile:getMin():getX())
local ptInt1 = FindIntersectionPoint( nOutId, nOtherOut, EgtSP( nOutId))
local ptInt2 = FindIntersectionPoint( nInId, nOtherIn, EgtSP( nInId))
EgtErase( nOtherIn)
nBisector = EgtLine( nGeoLayerId, ptInt2, ptInt1)
else
nBisector = CalcParabolicBisector( nOtherOut, nOutId, b3Profile:getDimX(), nGeoLayerId)
EgtInvertCurve( nBisector)
end
EgtSetName( nBisector, WIN_GEO_LEFT)
EgtSetInfo( nBisector, WIN_REF_OUTLINE, vPrevOutlineId[i])
EgtRelocateGlob( nBisector, nGeoLayerId, GDB_IN.LAST_SON)
-- b) se profili diversi per taglio corretto dei profili serve considerare anche il bordo out del pezzo adiacente
local sCurrProfile = EgtGetInfo( nCurrProfileId, WIN_PROFILETYPE)
local sPrevProfile = EgtGetInfo( vPrevProfileId[i], WIN_PROFILETYPE)
if sCurrProfile ~= sPrevProfile and not AreSameVectorApprox( EgtSV( nOutlineId), EgtEV( vPrevOutlineId[i])) then
EgtSetName( nOtherOut, WIN_GEO_LEFT)
EgtRelocateGlob( nOtherOut, nGeoLayerId, GDB_IN.LAST_SON)
local nSemiProfileId = EgtGetFirstNameInGroup( vPrevProfileId[i], WIN_OUT)
EgtSetInfo( nOtherOut, WIN_SEMI_PROFILE, nSemiProfileId)
EgtSetInfo( nOtherOut, WIN_REF_OUTLINE, vPrevOutlineId[i])
EgtSetInfo( nOtherOut, WIN_GEO_OFFS, b3Profile:getMax():getX())
else
-- considero la curva out come curva ausiliaria per il calcolo del geo
EgtSetName( nOtherOut, WIN_AUX)
EgtSetInfo( nOtherOut, WIN_TANG_START, true)
EgtSetInfo( nOtherOut, WIN_TANG_END, true)
end
else
local nPrevCurveId = EgtCopy( abs( vPrevOutlineId[i]), nGeoLayerId)
if vPrevOutlineId[i] < 0 then
EgtInvertCurve( nPrevCurveId)
end
local dOffs, nPrevSemiProfile
if vStartJoints[i] == WIN_PART_JNT.SHORT then
-- la curva del geo corrisponde al bordo del controprofilo in del pezzo vicino
local sCtrIn = GetProfileCtrIn( abs( vPrevOutlineId[i]), nOutlineId, vPrevProfileId[i])
local dCPDelta = GetDeltaProfile( vPrevProfileId[i], sCtrIn)
dOffs = - dCPDelta
nPrevSemiProfile = EgtGetFirstNameInGroup( vPrevProfileId[i], sCtrIn)
else
-- la curva del geo corrisponde all'out del pezzo vicino
local b3Profile = GetProfileLocalBox( vPrevProfileId[i])
dOffs = b3Profile:getMax():getX()
nPrevSemiProfile = EgtGetFirstNameInGroup( vPrevProfileId[i], WIN_OUT)
end
EgtOffsetCurve( nPrevCurveId, dOffs)
EgtSetInfo( nPrevCurveId, WIN_GEO_OFFS, dOffs)
EgtSetInfo( nPrevCurveId, WIN_SEMI_PROFILE, nPrevSemiProfile)
EgtSetInfo( nPrevCurveId, WIN_REF_OUTLINE, vPrevOutlineId[i])
EgtSetName( nPrevCurveId, WIN_GEO_LEFT)
EgtRelocateGlob( nPrevCurveId, nGeoLayerId, GDB_IN.LAST_SON)
end
end
-- curve right
local vNextProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_END)
for i = 1, #vNextOutlineId do
if vEndJoints[i] == WIN_PART_JNT.ANGLED then
local b3Profile = GetProfileLocalBox( vNextProfileId[i])
local nOtherOut = EgtCopyGlob( vNextOutlineId[i], nGeoLayerId)
EgtOffsetCurve( nOtherOut, b3Profile:getMax():getX())
-- calcolo bisettore
local nBisector
if ( EgtGetType( nOutlineId) == GDB_TY.CRV_LINE and EgtGetType( vNextOutlineId[i]) == GDB_TY.CRV_LINE) or
EgtEV( nOutlineId) * EgtSV( vNextOutlineId[i]) > s_dAngledCos or
EgtGetName( nOutlineId) == EgtGetName( vNextOutlineId[i]) then
local nOtherIn = EgtCopyGlob( vNextOutlineId[i], nGeoLayerId)
EgtOffsetCurve( nOtherIn, b3Profile:getMin():getX())
local ptInt1 = FindIntersectionPoint( nOutId, nOtherOut, EgtEP( nOutId))
local ptInt2 = FindIntersectionPoint( nInId, nOtherIn, EgtEP( nInId))
EgtErase( nOtherIn)
nBisector = EgtLine( nGeoLayerId, ptInt1, ptInt2)
else
nBisector = CalcParabolicBisector( nOutId, nOtherOut, b3Profile:getDimX(), nGeoLayerId)
end
EgtSetName( nBisector, WIN_GEO_RIGHT)
EgtSetInfo( nBisector, WIN_REF_OUTLINE, vNextOutlineId[i])
EgtRelocateGlob( nBisector, nInId, GDB_IN.BEFORE)
-- gestione per profili diversi
local sCurrProfile = EgtGetInfo( nCurrProfileId, WIN_PROFILETYPE)
local sNextProfile = EgtGetInfo( vNextProfileId[i], WIN_PROFILETYPE)
if sCurrProfile ~= sNextProfile and not AreSameVectorApprox( EgtEV( nOutlineId), EgtSV( vNextOutlineId[i])) then
EgtSetName( nOtherOut, WIN_GEO_RIGHT)
local nSemiProfileId = EgtGetFirstNameInGroup( vNextProfileId[i], WIN_OUT)
EgtSetInfo( nOtherOut, WIN_SEMI_PROFILE, nSemiProfileId)
EgtSetInfo( nOtherOut, WIN_REF_OUTLINE, vNextOutlineId[i])
EgtSetInfo( nOtherOut, WIN_GEO_OFFS, b3Profile:getMax():getX())
EgtRelocateGlob( nOtherOut, nInId, GDB_IN.BEFORE)
else
EgtSetName( nOtherOut, WIN_AUX)
EgtSetInfo( nOtherOut, WIN_TANG_START, true)
EgtSetInfo( nOtherOut, WIN_TANG_END, true)
end
else
local nNextCurveId = EgtCopy( abs( vNextOutlineId[i]), nGeoLayerId)
if vNextOutlineId[i] < 0 then
EgtInvertCurve( nNextCurveId)
end
local dOffs, nNextSemiProfile
if vEndJoints[i] == WIN_PART_JNT.SHORT then
local sCtrIn = GetProfileCtrIn( abs( vNextOutlineId[i]), nOutlineId, vNextProfileId[i])
local dCPDelta = GetDeltaProfile( vNextProfileId[i], sCtrIn)
dOffs = - dCPDelta
nNextSemiProfile = EgtGetFirstNameInGroup( vNextProfileId[i], sCtrIn)
else
local b3Profile = GetProfileLocalBox( vNextProfileId[i])
dOffs = b3Profile:getMax():getX()
nNextSemiProfile = EgtGetFirstNameInGroup( vNextProfileId[i], WIN_OUT)
end
EgtOffsetCurve( nNextCurveId, dOffs)
EgtSetInfo( nNextCurveId, WIN_GEO_OFFS, dOffs)
EgtSetInfo( nNextCurveId, WIN_SEMI_PROFILE, nNextSemiProfile)
EgtSetInfo( nNextCurveId, WIN_REF_OUTLINE, vNextOutlineId[i])
EgtSetName( nNextCurveId, WIN_GEO_RIGHT)
EgtRelocateGlob( nNextCurveId, nInId, GDB_IN.BEFORE)
end
end
-- verifico se necessaria estensione in tangenza per pezzi ad arco
local vLeftIds = EgtGetNameInGroup( nGeoLayerId, WIN_LEFT)
local vRightIds = EgtGetNameInGroup( nGeoLayerId, WIN_RIGHT)
ComputeArcExtensions( nOutId, nInId, vLeftIds, vRightIds, vStartJoints, vEndJoints)
-- costruisco la superficie
local vIds = EgtGetAllInGroup( nGeoLayerId)
local nAreaId = CalcGeoRegion( vIds, nGeoLayerId)
if not nAreaId then
return false
end
EgtSetName( nAreaId, WIN_GEO_SURF)
EgtSetStatus( nAreaId, GDB_ST.OFF)
-- elimino curve aux
local vCrvs = {}
for i = 1, #vIds do
if EgtGetName( vIds[i]) == WIN_AUX then
EgtErase( vIds[i])
else
table.insert( vCrvs, vIds[i])
end
end
local _, vExtraCrvs = TrimOrderedCurves( vCrvs, false, nAreaId)
for i = 1, #vExtraCrvs do
EgtSetInfo( vExtraCrvs[i], WIN_GEO_EXTRA, true)
end
-- 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
return true
end
---------------------------------------------------------------------
-- funzione che calcola l'ingombro dei pezzi del telaio
local function CalcGeo( nPartId, nOutlineId)
-- creo layer per ingombro
local nGeoLayerId = EgtGroup( nPartId)
EgtSetName( nGeoLayerId, WIN_GEO)
-- recupero il tipo di giunzioni
local vStartJoints
local vEndJoints
local nBottomRail = EgtGetInfo( nPartId, WIN_BOTTOMRAIL, 'i')
if nBottomRail then
-- se bottomrail deve essere short ( l'info sulla curva di riferisce al pezzo bottom)
vStartJoints = { WIN_PART_JNT.SHORT}
vEndJoints = { WIN_PART_JNT.SHORT}
else
vStartJoints = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'vi')
vEndJoints = EgtGetInfo( nOutlineId, WIN_ENDJOINT, 'vi')
end
-- aggiungo al gruppo profili quelli di trim
local vPrevOutlineId = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'vi')
local vNextOutlineId = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'vi')
local nProfileLayerId = CalcStartEndProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutlineId)
-- creo lati dell'outline
local bOk = CreateGeoCurves( nOutlineId, vPrevOutlineId, vNextOutlineId, vStartJoints, vEndJoints, nGeoLayerId, nProfileLayerId)
-- TODO verificare la validità del pezzo ( si è creata geo region, la curva out non è extra, ...)
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 -----------------------------
----------------------------------------------------------------------------------
local function CalcMixedMillings( vOutlines, nOutlineProfileId, nSplitId, nSplitProfileId, bPrev, nGrp)
-- TO DO : da capire bene come gestire il caso di cambio profilo che coinvolge più pezzi
-- TO DO : da capire quali info serve riportare nel profilo
local nGrpTmp = EgtGroup( nGrp)
local dDim1 = 61
local dDim2 = 45
local dRad = EgtGetInfo( nSplitProfileId, WIN_RAD_REF .. '1', 'd')
local ptRef = EgtIf( bPrev, EgtSP( nSplitId), EgtEP( nSplitId))
-- calcolo le curve di riferimento per lo split
local b3SplitProfile = GetProfileLocalBox( nSplitProfileId)
local dSplitFixedOffs = EgtGetInfo( nSplitProfileId, WIN_FIXED_REF, 'd')
local nCrvSF = EgtOffsetCurveAdv( nSplitId, b3SplitProfile:getMax():getX() - dSplitFixedOffs)
EgtRelocateGlob( nCrvSF, nGrpTmp)
local dSplitSashOffs1 = EgtGetInfo( nSplitProfileId, WIN_SASH_REF .. '1', 'd')
local nCrvSS1 = EgtOffsetCurveAdv( nSplitId, b3SplitProfile:getMin():getX() + dSplitSashOffs1)
EgtRelocateGlob( nCrvSS1, nGrpTmp)
local dSplitSashOffs2 = EgtGetInfo( nSplitProfileId, WIN_SASH_REF .. '2', 'd')
local nCrvSS2 = EgtOffsetCurveAdv( nSplitId, b3SplitProfile:getMin():getX() + dSplitSashOffs2)
EgtRelocateGlob( nCrvSS2, nGrpTmp)
-- calcolo le curve di riferimento prev
local nOutlineCompo = EgtCurveCompo( nGrpTmp, vOutlines, false)
local b3FrameProfile = GetProfileLocalBox( nOutlineProfileId)
local dFrameFixedOffs = EgtGetInfo( nOutlineProfileId, WIN_FIXED_REF, 'd')
local nCrvFF = EgtOffsetCurveAdv( nOutlineCompo, b3FrameProfile:getMin():getX() + dFrameFixedOffs)
local dFrameSashOffs1 = EgtGetInfo( nOutlineProfileId, WIN_SASH_REF .. '1', 'd')
local nCrvFS1 = EgtOffsetCurveAdv( nOutlineCompo, b3FrameProfile:getMin():getX() + dFrameSashOffs1)
local dFrameSashOffs2 = EgtGetInfo( nOutlineProfileId, WIN_SASH_REF .. '2', 'd')
local nCrvFS2 = EgtOffsetCurveAdv( nOutlineCompo, b3FrameProfile:getMin():getX() + dFrameSashOffs2)
local dFrameExtra = EgtGetInfo( nOutlineProfileId, WIN_EXTRA_DIST, 'd')
local nCrvFIn = EgtOffsetCurveAdv( nOutlineCompo, b3FrameProfile:getMin():getX() + dFrameSashOffs2 + dFrameExtra)
local dDepth = EgtGetInfo( nOutlineProfileId, WIN_SASH_DEPTH .. '2', 'd')
-- calcolo il bisettore a partire dall'incontro delle parti fixed del telaio e dello split
local nBisector
local pt1 = EgtIP( nCrvSF, nCrvFF, ptRef)
local dParRef = EgtCurveParamAtPoint( nCrvFF, pt1)
local nCrvRef = floor( dParRef)
if EgtCurveCompoRadius( nCrvFF, nCrvRef) == -1 then
-- se l'incontro tra la parte fixed del telaio e dello split avviene su un tratto lineare il bisettore è linea
local vtDir = ( EgtUV( nCrvFF, dParRef, -1) + EgtSV( nSplitId))
nBisector = EgtLinePVL( nGrpTmp, pt1, vtDir, 1000)
EgtExtendCurveStartByLen( nBisector, 1000)
else
-- se l'incontro tra la parte fixed del telaio e dello split avviene su un tratto ad arco il bisettore è porzione di parabola
local nArc = EgtCopyCompoSubCurve( nCrvFF, nCrvRef, nGrpTmp)
local b3Profile = GetProfileLocalBox( nSplitProfileId)
-- bisettore è tratto di parabola
local dDim = b3Profile:getDimX()
if bPrev then
nBisector = CalcParabolicBisector( nArc, nCrvSF, dDim, nGrpTmp, true, false)
EgtInvertCurve( nBisector)
else
nBisector = CalcParabolicBisector( nCrvSF, nArc, dDim, nGrpTmp, true, false)
end
EgtErase( nArc)
end
-- posizione finale del tool di profilatura che determina il limite delle fresature
local nBisectTool = EgtCopyGlob( nBisector, nGrpTmp)
EgtOffsetCurve( nBisectTool, - dDim1 * 0.5)
EgtExtendCurveStartByLen( nBisectTool, 10)
EgtExtendCurveEndByLen( nBisectTool, 10)
local nCrvSash = EgtOffsetCurveAdv( nOutlineCompo, b3FrameProfile:getMin():getX() + dFrameSashOffs1 - dDim1 * 0.5)
local ptEnd = EgtIP( nCrvSash, nBisectTool, ptRef)
local nCircle = EgtCircle( nGrpTmp, ptEnd, dDim1 * 0.5)
local nCircle2 = EgtCircle( nGrpTmp, ptEnd, dDim2 * 0.5)
-- 1) Fresatura #1
local pt2 = EgtIP( nBisector, nCrvFS1, ptRef)
local dPar1 = EgtCurveParamAtPoint( nBisector, pt1)
local dPar2 = EgtCurveParamAtPoint( nBisector, pt2)
local nMill1 = EgtCopyParamRange( nBisector, min( dPar2, dPar1), max( dPar1, dPar2), nGrpTmp)
local dPar3 = EgtCurveParamAtPoint( nCrvFS1, pt2)
local _, _, dPar4 = EgtPointCurveDist( ptEnd, nCrvFS1)
local nMill2 = EgtCopyParamRange( nCrvFS1, min( dPar4, dPar3), max( dPar3, dPar4), nGrpTmp)
local nMilling
if bPrev then
nMilling = EgtCurveCompo( nGrpTmp, { nMill2, nMill1})
else
nMilling = EgtCurveCompo( nGrpTmp, { nMill1, nMill2})
end
-- offset e contro-offset per creare fillet
local nMillingOffs = EgtOffsetCurveAdv( nMilling, - dRad)
nMilling = EgtOffsetCurveAdv( nMillingOffs, dRad)
EgtRelocateGlob( nMilling, nGrp)
EgtSetColor( nMilling, EgtStdColor( 'BLUE'))
EgtSetName( nMilling, WIN_MIXED_MILLING .. '1')
EgtSetInfo( nMilling, WIN_MIXED_SPLIT_REF, nSplitId)
EgtModifyCurveThickness( nMilling, - dDepth)
if bPrev then
EgtSetInfo( nMilling, WIN_MIXED_SASHFILL, true)
else
EgtSetInfo( nMilling, WIN_MIXED_SASHFILL, false)
end
-- 2) Fresatura #2
-- calcolo i punti di riferimento
local pt3 = EgtIP( nBisector, nCrvFIn, ptRef)
local pt4 = EgtIP( nCrvFIn, nCrvSS1, ptRef)
local pt5 = EgtIP( nCrvSS1, nCrvFS2, ptRef)
-- calcolo le curve
local dParA = EgtCurveParamAtPoint( nBisector, EgtIf( bPrev, EgtEP( nMilling), EgtSP( nMilling)))
local dParB = EgtCurveParamAtPoint( nBisector, pt3)
local nMill3 = EgtCopyParamRange( nBisector, min( dParA, dParB), max( dParA, dParB), nGrpTmp)
local dParC = EgtCurveParamAtPoint( nCrvFIn, pt3)
local dParD = EgtCurveParamAtPoint( nCrvFIn, pt4)
local nMill4 = EgtCopyParamRange( nCrvFIn, min( dParC, dParD), max( dParC, dParD), nGrpTmp)
local dParE = EgtCurveParamAtPoint( nCrvSS1, pt4)
local dParF = EgtCurveParamAtPoint( nCrvSS1, pt5)
local nMill5 = EgtCopyParamRange( nCrvSS1, min( dParE, dParF), max( dParE, dParF), nGrpTmp)
EgtInvertCurve( nMill5)
local dParG = EgtCurveParamAtPoint( nCrvFS2, pt5)
local nMill6
if bPrev then
nMill6 = EgtCopyParamRange( nCrvFS2, 0, dParG, nGrpTmp)
else
local _, dE = EgtCurveDomain( nCrvFS2)
nMill6 = EgtCopyParamRange( nCrvFS2, dParG, dE, nGrpTmp)
end
local nMilling2
if bPrev then
nMilling2 = EgtCurveCompo( nGrp, { nMill6, nMill5, nMill4, nMill3})
else
nMilling2 = EgtCurveCompo( nGrp, { nMill3, nMill4, nMill5, nMill6})
end
EgtSetColor( nMilling2, EgtStdColor( 'BLUE'))
EgtSetName( nMilling2, WIN_MIXED_MILLING .. '2')
EgtModifyCurveThickness( nMilling2, - dDepth)
-- taglio sul punto finale della lavorazione di profilatura
local pt6 = EgtIP( nMilling2, nCircle2, ptRef)
if not pt6 then
_, pt6 = EgtPointCurveDist( EgtIf( bPrev, EgtSP( nMilling), EgtEP( nMilling)), nMilling2)
end
local dParH = EgtCurveParamAtPoint( nMilling2, pt6)
if bPrev then
EgtTrimCurveStartAtParam( nMilling2, dParH)
else
EgtTrimCurveEndAtParam( nMilling2, dParH)
end
EgtErase( nGrpTmp)
return nMilling, nMilling2
end
---------------------------------------------------------------------
-- funzione che calcola le curve legate al cambio profilo
local function CalcMixedCurves( nPartId, nSplitId)
local nGrp = EgtGroup( nPartId)
EgtSetName( nGrp, WIN_MIXED_CURVES)
EgtSetStatus( nGrp, GDB_ST.OFF)
local nProfileGrpId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
local nSplitProfileId = EgtGetFirstNameInGroup( nProfileGrpId, WIN_PRF_MAIN)
-- prev
local vPrevOutlines = EgtGetInfo( nSplitId, WIN_PREV_OUTLINES, 'vi')
local nPrevProfileId = EgtGetFirstNameInGroup( nProfileGrpId, WIN_PRF_START)
local nMill1, nMill2 = CalcMixedMillings( vPrevOutlines, nPrevProfileId, nSplitId, nSplitProfileId, true, nGrp)
-- copio le fresature sui pezzi del telaio coinvolti
for i = 1, #vPrevOutlines do
local nPrevPartId = EgtGetInfo( vPrevOutlines[i], WIN_REF_PART, 'i')
local nMixedInters = EgtGetFirstNameInGroup( nPrevPartId, WIN_MIXED_CURVES)
if not nMixedInters then
nMixedInters = EgtGroup( nPrevPartId)
EgtSetName( nMixedInters, WIN_MIXED_CURVES)
EgtSetStatus( nMixedInters, GDB_ST.OFF)
end
EgtCopyGlob( nMill1, nMixedInters)
EgtCopyGlob( nMill2, nMixedInters)
end
-- next
local vNextOutlines = EgtGetInfo( nSplitId, WIN_NEXT_OUTLINES, 'vi')
local nNextProfileId = EgtGetFirstNameInGroup( nProfileGrpId, WIN_PRF_END)
local nMill3, nMill4 = CalcMixedMillings( vNextOutlines, nNextProfileId, nSplitId, nSplitProfileId, false, nGrp)
for i = 1, #vNextOutlines do
local nPrevPartId = EgtGetInfo( vNextOutlines[i], WIN_REF_PART, 'i')
local nMixedInters = EgtGetFirstNameInGroup( nPrevPartId, WIN_MIXED_CURVES)
if not nMixedInters then
nMixedInters = EgtGroup( nPrevPartId)
EgtSetName( nMixedInters, WIN_MIXED_CURVES)
EgtSetStatus( nMixedInters, GDB_ST.OFF)
end
EgtCopyGlob( nMill3, nMixedInters)
EgtCopyGlob( nMill4, nMixedInters)
end
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
CopyInfo( nCrv, nSemiProfile, WIN_PRC_ID)
else
-- se non ha semiprofilo associato è un taglio
EgtSetInfo( nCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.CUT)
end
end
---------------------------------------------------------------------
-- funzione che concatena, se possibile, lavorazioni con lo stesso semiprofilo
local function ChainProfilingProcessingCurves( vProcCrvsOrig, vRefCrvsOrig)
if #vProcCrvsOrig == 1 then
return vProcCrvsOrig, vRefCrvsOrig
end
local vProcCrvs = {}
local vRefCrvs = {}
local nCurrCrv = vProcCrvsOrig[1]
local vCurrRef = { vRefCrvsOrig[1]}
local sIdCurr = EgtGetInfo( vProcCrvsOrig[1], WIN_PRC_ID)
for i = 2, #vProcCrvsOrig do
local bChain = false
local sId = EgtGetInfo( vProcCrvsOrig[i] or GDB_ID.NULL, WIN_PRC_ID)
if sIdCurr == sId then
-- verifico se le curve si tagliano tra di loro
local ptInt = EgtIP( nCurrCrv, vProcCrvsOrig[i], EgtEP( nCurrCrv))
if ptInt then
bChain = true
local dPar1 = EgtCurveParamAtPoint( nCurrCrv, ptInt)
local dPar2 = EgtCurveParamAtPoint( vProcCrvsOrig[i], ptInt)
local vCompoCrvs = {}
-- se la curva non viene completamente trimmata la considero, altrimenti la cancello
if dPar1 > GEO.EPS_SMALL then
EgtTrimCurveEndAtParam( nCurrCrv, dPar1)
table.insert( vCompoCrvs, nCurrCrv)
else
EgtErase( nCurrCrv)
end
local _, dE = EgtCurveDomain( vProcCrvsOrig[i])
if abs( dPar2 - dE) > GEO.EPS_SMALL then
EgtTrimCurveStartAtParam( vProcCrvsOrig[i], dPar2)
table.insert( vCompoCrvs, vProcCrvsOrig[i])
else
EgtErase( vProcCrvsOrig[i])
end
nCurrCrv = EgtCurveCompo( EgtGetParent( vProcCrvsOrig[1]), vCompoCrvs)
table.insert( vCurrRef, vRefCrvsOrig[i])
end
end
if not bChain then
-- salvo la vecchia catena appena interrotta e inizializzo le variabili con la nuova
table.insert( vProcCrvs, nCurrCrv)
table.insert( vRefCrvs, vCurrRef)
nCurrCrv = vProcCrvsOrig[i]
vCurrRef = { vRefCrvsOrig[i]}
sIdCurr = sId
end
end
table.insert( vProcCrvs, nCurrCrv)
table.insert( vRefCrvs, vCurrRef)
-- se è stata creata una catena ( quindi una lavorazione ha più curve di riferimento associate), vanno risettate le info di lavorazione
for i = 1, #vRefCrvs do
if #vRefCrvs[i] > 1 then
EgtSetName( vProcCrvs[i], EgtGetName( vRefCrvs[i][1]))
local nSemiProfileId = EgtGetInfo( vRefCrvs[i][1], WIN_SEMI_PROFILE, 'i')
GetProcessingInfoFromSemiProfile( vProcCrvs[i], nSemiProfileId)
for j = 1, #vRefCrvs[i] do
EgtSetInfo( vRefCrvs[i][j], WIN_REF_PRC, vProcCrvs[i])
end
EgtSetInfo( vProcCrvs[i], WIN_REF_GEO, vRefCrvs[i])
end
end
return vProcCrvs, vRefCrvs
end
---------------------------------------------------------------------
-- funzione che verifica se la lavorazione è veramente necessaria considerando le interferenze tra i profili
local function TestProcessings( vProcCrvs, vRefCrvs, nGeoOut, nGeoIn)
if #vProcCrvs == 1 then
return
end
local nGrpTmp = EgtGroup( 0)
-- creo le superifici delle lavorazioni e quelle estese da usare per i trim
local vSurfs = {}
for i = 1, #vProcCrvs do
local nSemiProfileId = EgtGetInfo( vRefCrvs[i][1], WIN_SEMI_PROFILE, 'i')
if nSemiProfileId then
local nGuideId = EgtCopyGlob( vProcCrvs[i], nGrpTmp)
local dOffs = EgtGetInfo( vRefCrvs[i][1], WIN_GEO_OFFS, 'd')
EgtOffsetCurve( nGuideId, - dOffs)
local nProfileId = EgtGetParent( nSemiProfileId)
local nSurf = CreateProfileSurfById( nGuideId, nProfileId, nSemiProfileId, 0, nGrpTmp)
local nSurfExt = CreateProfileSurf( nGuideId, nProfileId, WIN_OFST .. EgtGetName( nSemiProfileId), 1000, nGrpTmp)
vSurfs[i] = { nId = nSurf, nExtId = nSurfExt}
end
end
-- superfici che delimitano il pezzo
local nOutlineId = EgtGetInfo( nGeoOut, WIN_REF_OUTLINE, 'i')
local nSemiProfileOut = EgtGetInfo( nGeoOut, WIN_SEMI_PROFILE, 'i')
local nProfileId = EgtGetParent( nSemiProfileOut)
local nSurfOut
local sName = EgtGetName( nSemiProfileOut)
if sName == WIN_OUT then
nSurfOut = CreateProfileSurf( nOutlineId, nProfileId, WIN_OFST .. sName, 1000, nGrpTmp)
else
nSurfOut = CreateProfileSurf( nOutlineId, nProfileId, WIN_OFST .. 'Ctr' .. sName, 1000, nGrpTmp)
EgtInvertSurf( nSurfOut)
end
local nSemiProfileIn = EgtGetInfo( nGeoIn, WIN_SEMI_PROFILE, 'i')
local sNameIn = EgtGetName( nSemiProfileIn)
if sNameIn == WIN_MIXED_COMMON .. WIN_IN then
sNameIn = WIN_FILL .. WIN_CTRIN
else
sNameIn = 'Ctr' .. sNameIn
end
local nSurfIn = CreateProfileSurf( nOutlineId, nProfileId, WIN_OFST .. sNameIn, 1000, nGrpTmp)
EgtInvertSurf( nSurfIn)
for i = 1, #vSurfs do
-- taglio la superficie con le altre lavorazioni e con il bordo
for j = 1, #vSurfs do
if i ~= j then
EgtSurfTmCut( vSurfs[i].nId, vSurfs[j].nExtId, true, false)
end
end
EgtSurfTmCut( vSurfs[i].nId, nSurfOut, true, false)
EgtSurfTmCut( vSurfs[i].nId, nSurfIn, true, false)
-- se scompare la lavorazione non serve
if EgtSurfTmPartCount( vSurfs[i].nId) == 0 then
EgtErase( vProcCrvs[i])
for j = 1, #vRefCrvs[i] do
EgtRemoveInfo( vRefCrvs[i][j], WIN_REF_PRC)
end
end
end
EgtErase( nGrpTmp)
end
---------------------------------------------------------------------
local function CreateProfilingProcessingCurve( nGeoCrvId, nPrevCrv, nSurfGeo, nPrcLayerId)
-- recupero il semiprofilo associato alla curva
local nSemiProfileId = EgtGetInfo( nGeoCrvId, WIN_SEMI_PROFILE, 'i')
local nPrcCrvId
-- se bisettrice
if not nSemiProfileId then
nPrcCrvId = EgtCopyGlob( nGeoCrvId, nPrcLayerId)
-- se lavorazione di controprofilo
else
local nGrpTmp = EgtGroup( nPrcLayerId)
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)
local dOffs = b3SemiProfile:getDimX()
-- calcolo la curva di lavorazione interna ( partendo dall'outline e non dal geo per essere coerente con la info di estensione)
local nRefOutlineId = EgtGetInfo( nGeoCrvId, WIN_REF_OUTLINE, 'i')
local nOutlineId = EgtCopyGlob( abs( nRefOutlineId), nGrpTmp)
if nRefOutlineId < 0 then
EgtInvertCurve( nOutlineId)
end
local dGeoOffs = EgtGetInfo( nGeoCrvId, WIN_GEO_OFFS, 'd')
local nOrigInnerProcId = EgtOffsetCurveAdv( nOutlineId, dGeoOffs - dOffs)
-- adatto la curva di lavorazione interna al pezzo
CopyInfo( nOrigInnerProcId, nGeoCrvId, WIN_TANG_START, false)
CopyInfo( nOrigInnerProcId, nGeoCrvId, WIN_TANG_END, false)
local nInnerProcId = CreateCurveExtension( nOrigInnerProcId, nGrpTmp)
local nInId, nCnt = EgtTrimCurveWithRegion( nInnerProcId, nSurfGeo, true, false)
if not nInId then
nCnt = 0
end
if nCnt > 0 then
if nCnt > 1 and AreSamePointApprox( EgtSP( nInId), EgtEP( nInId + nCnt - 1)) then
if EgtGetType( nInId) == GDB_TY.CRV_ARC then
EgtModifyCurveStartPoint( nInId, EgtSP( nInId + nCnt - 1))
else
EgtAddCurveCompoCurve( nInId, nInId + nCnt - 1, true, false)
end
nCnt = nCnt - 1
end
-- se ottengo più tratti considero quello che ha porzione in comune con la curva originale
if nCnt > 1 then
local nTestCrv = EgtOffsetCurveAdv( nGeoCrvId, - dOffs)
EgtRelocateGlob( nTestCrv, nGrpTmp)
local vOverlapCrvs = {}
for nId = nInId, nInId + nCnt - 1 do
if CheckExtensionOverlap( nId, nTestCrv) then
table.insert( vOverlapCrvs, nId)
end
end
if #vOverlapCrvs == 1 then
nInId = vOverlapCrvs[1]
elseif #vOverlapCrvs > 0 then
-- se ottengo più tratti di overlap con il geo considero il più vicino al geo precedente
local nIdx = 1
local dMinDist = GEO.INFINITO
local ptRef = EgtEP( nPrevCrv)
for i = 1, #vOverlapCrvs do
local dDist = dist( EgtSP( vOverlapCrvs[i]), ptRef)
if dDist < dMinDist then
dMinDist = dDist
nIdx = i
end
end
nInId = vOverlapCrvs[nIdx]
end
end
-- la allineo alla curva di lavoro
EgtOffsetCurve( nInId, dOffs)
local bExtra = EgtGetInfo( nGeoCrvId, WIN_GEO_EXTRA, 'b') or false
if bExtra then
-- se la lavorazione fa overlap con la curva del geo allora considero direttamente la curva di lavorazione interna
if CheckExtensionOverlap( nInId, nGeoCrvId) then
nPrcCrvId = nInId
EgtRelocateGlob( nPrcCrvId, nPrcLayerId)
end
else
-- modifico la curva del geo in allungamento
nPrcCrvId = EgtCurveCompo( nPrcLayerId, nGeoCrvId, false)
AddExtension( nPrcCrvId, nInId)
end
end
EgtErase( nGrpTmp)
end
-- sistemo la curva e setto le info
if nPrcCrvId then
EgtModifyCurveThickness( nPrcCrvId, 0)
EgtSetStatus( nPrcCrvId, GDB_ST.ON)
EgtSetName( nPrcCrvId, EgtGetName( nGeoCrvId))
GetProcessingInfoFromSemiProfile( nPrcCrvId, nSemiProfileId)
EgtSetInfo( nGeoCrvId, WIN_REF_PRC, nPrcCrvId)
EgtSetInfo( nPrcCrvId, WIN_REF_GEO, nGeoCrvId)
end
return nPrcCrvId
end
---------------------------------------------------------------------
local function TrimTangentProcessings( nPrc1, nPrc2, ptRef)
-- se le due lavorazioni hanno lo stesso semiprofilo e sono in tangenza nel loro punto di intersezione, allora posso trimmarle per evitare di avere porzioni di lavorazioni superflue
local sId1 = EgtGetInfo( nPrc1, WIN_PRC_ID)
local sId2 = EgtGetInfo( nPrc2, WIN_PRC_ID)
if sId1 == sId2 then
local ptInt = EgtIP( nPrc1, nPrc2, ptRef)
if ptInt then
local dPar1 = EgtCurveParamAtPoint( nPrc1, ptInt)
local dPar2 = EgtCurveParamAtPoint( nPrc2, ptInt)
if AreSameVectorApprox( EgtUV( nPrc1, dPar1, -1), EgtUV( nPrc2, dPar2, -1)) then
EgtTrimCurveEndAtParam( nPrc1, dPar1)
EgtTrimCurveStartAtParam( nPrc2, dPar2)
end
end
end
end
---------------------------------------------------------------------
-- funzione che calcola le lavorazioni di profilatura a partire dalle curve del geo
local function CreateProfilingProcessingFromGeo( nGeoLayerId, nSurfGeo, nProcLayerId, nPartId)
-- a) out
local nOut = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT)
local nPrcOut = CreateProfilingProcessingCurve( nOut, nil, nSurfGeo, nProcLayerId)
local sOutId = EgtGetInfo( nPrcOut, WIN_PRC_ID)
EgtSetInfo( nPartId, WIN_PRC_PROFILE_OUT, sOutId)
-- b) in
local nIn = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN)
local nPrcIn = CreateProfilingProcessingCurve( nIn, nil, nSurfGeo, nProcLayerId)
local sInId = EgtGetInfo( nPrcIn, WIN_PRC_ID)
EgtSetInfo( nPartId, WIN_PRC_PROFILE_IN, sInId)
-- c) right
-- costruisco le curve di lavorazione
local vRight = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
local vProcRight = {}
local vRefRight = {}
for i = 1, #vRight do
local nCrvId = CreateProfilingProcessingCurve( vRight[i], nOut, nSurfGeo, nProcLayerId)
if nCrvId then
table.insert( vProcRight, nCrvId)
table.insert( vRefRight, vRight[i])
end
end
-- concateno
vProcRight, vRefRight = ChainProfilingProcessingCurves( vProcRight, vRefRight)
-- verifico se ci sono lavorazioni superflue
TestProcessings( vProcRight, vRefRight, nOut, nIn)
-- eventuale trim con out e in
local vPrcRight = EgtGetNameInGroup( nProcLayerId, WIN_RIGHT)
TrimTangentProcessings( nPrcOut, vPrcRight[1], EgtEP( nPrcOut))
TrimTangentProcessings( vPrcRight[#vPrcRight], nPrcIn, EgtSP( nPrcIn))
-- d) left
local vLeft = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
local vProcLeft = {}
local vRefLeft = {}
for i = 1, #vLeft do
local nCrvId = CreateProfilingProcessingCurve( vLeft[i], nIn, nSurfGeo, nProcLayerId)
if nCrvId then
table.insert( vProcLeft, nCrvId)
table.insert( vRefLeft, vLeft[i])
end
end
vProcLeft, vRefLeft = ChainProfilingProcessingCurves( vProcLeft, vRefLeft)
TestProcessings( vProcLeft, vRefLeft, nOut, nIn)
local vPrcLeft = EgtGetNameInGroup( nProcLayerId, WIN_LEFT)
TrimTangentProcessings( nPrcIn, vPrcLeft[1], EgtEP( nPrcIn))
TrimTangentProcessings( vPrcLeft[#vPrcLeft], nPrcOut, EgtSP( nPrcOut))
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 nGeoArea = EgtGetLastInGroup( nGeoLayerId)
CreateProfilingProcessingFromGeo( nGeoLayerId, nGeoArea, nProcLayerId, nPartId)
-- b) lavorazioni per i sottotratti sash e fill
-- TO DO ( da capire bene soprattuto nei casi di cambio profilo che coinvolge pezzi distinti)
-- c) fresature
local nMixedIntersGrp = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_CURVES)
local vMixedInters = EgtGetNameInGroup( nMixedIntersGrp, WIN_MIXED_MILLING .. '*')
local dDepth1 = EgtGetInfo( nMainProfileId, WIN_SASH_DEPTH .. '1')
for i = 1, #vMixedInters do
local nMilling = EgtCopyGlob( vMixedInters[i], nProcLayerId)
-- sistemo spessore
if EgtGetName( nMilling) == WIN_MIXED_MILLING .. '1' then
EgtModifyCurveThickness( nMilling, - dDepth1)
end
EgtSetInfo( nMilling, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING)
EgtSetInfo( nMilling, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC)
EgtSetInfo( nMilling, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.IN)
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 nGeoArea = EgtGetLastInGroup( nGeoLayerId)
CreateProfilingProcessingFromGeo( nGeoLayerId, nGeoArea, nProcLayerId, EgtGetParent( nProcLayerId))
-- b) fresature
local nMixedIntersGrp = EgtGetFirstNameInGroup( EgtGetParent( nProcLayerId), WIN_MIXED_CURVES)
local nIntersLeft = EgtGetFirstNameInGroup( nMixedIntersGrp, WIN_MIXED_MILLING .. '1')
local nMillingLeft = EgtCopyGlob( nIntersLeft, nProcLayerId)
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)
local nIntersRight = EgtGetLastNameInGroup( nMixedIntersGrp, WIN_MIXED_MILLING .. '1')
local nMillingRight = EgtCopyGlob( nIntersRight, nProcLayerId)
EgtInvertCurve( nMillingRight)
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 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 la superficie associata per limitare le lavorazioni
local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId)
local nSurfGeo = vGeoCrvs[#vGeoCrvs]
-- 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 : costruisco le curve di lavorazione a partire da quelle del geo
CreateProfilingProcessingFromGeo( nGeoLayerId, nSurfGeo, nProcLayerId, nPartId)
end
-- calcolo eventuali lavorazioni per strip
local vStripDist = EgtGetInfo( nMainProfileId, WIN_STRIP_DIST, 'vi') or {}
local nGeoIn = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN)
local bTangStart = EgtGetInfo( nGeoIn, WIN_TANG_END, 'b') or false
local bTangEnd = EgtGetInfo( nGeoIn, WIN_TANG_START, 'b') or false
for i = 1, #vStripDist do
local nStripOutline = EgtCopyGlob( nOutlineId, nProcLayerId)
EgtOffsetCurve( nStripOutline, vStripDist[i])
-- estendo la curva per adattarla alla regione del geo basandomi sulle estensioni della curva in ( che dovrebbe essere quella più vicina)
EgtSetInfo( nStripOutline, WIN_TANG_START, bTangStart)
EgtSetInfo( nStripOutline, WIN_TANG_END, bTangEnd)
local nStripCut = CreateCurveExtension( nStripOutline, nProcLayerId)
local nRes, nCnt = EgtTrimCurveWithRegion( nStripCut, nSurfGeo, true, false)
-- se più di un tratto considero solo quello con sovrapposizione con la curva non estesa
if nCnt > 1 and AreSamePointApprox( EgtSP( nRes), EgtEP( nRes + nCnt - 1)) then
if EgtGetType( nRes) == GDB_TY.CRV_ARC then
EgtModifyCurveStartPoint( nRes, EgtSP( nRes + nCnt - 1))
EgtErase( nRes + nCnt - 1)
else
EgtAddCurveCompoCurve( nRes, nRes + nCnt - 1, true, false)
end
nCnt = nCnt - 1
end
if nCnt > 1 then
for nId = nRes, nRes + nCnt - 1 do
if CheckExtensionOverlap( nId, nStripOutline) then
nStripCut = nId
else
EgtErase( nId)
end
end
end
EgtErase( nStripOutline)
-- 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 bOnFrenchSplit = EgtGetInfo( nOutlineId, 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, nOutlineId)
-- se pezzo ad arco il geo raw sarà calcolato tramite i tronchetti
if EgtGetType( nOutlineId) == GDB_TY.CRV_ARC then
return
end
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
if not EgtOffsetCurve( vRight[i], dOvermatRight) then
EgtErase( vRight[i])
end
end
local vLeft = EgtGetNameInGroup( nGeoRawLayerId, WIN_GEO_LEFT)
for i = 1, #vLeft do
if not EgtOffsetCurve( vLeft[i], dOvermatLeft) then
EgtErase( vLeft[i])
end
end
-- creo la composita del grezzo a partire dalle curve
local vCrvs = EgtGetAllInGroup( nGeoRawLayerId)
local nRegion = CalcIntersectionRegion( vCrvs, nGeoRawLayerId)
local nCompo = EgtExtractSurfFrChunkLoops( nRegion, 0, nGeoRawLayerId)
-- aggiungo spessore
local dDimH = EgtGetInfo( nGeoLayerId, WIN_GEOHEIGHT, 'd')
EgtModifyCurveThickness( nCompo, - dDimH)
-- creo frame ausiliario
local vtX = EgtSV( nOut)
local frGeo = Frame3d( ORIG(), vtX, Z_AX() ^ vtX, Z_AX())
local nFrameId = EgtFrame( nGeoRawLayerId, frGeo)
local b3Raw = EgtGetBBoxRef( nCompo, GDB_BB.STANDARD, frGeo)
local ptMin = b3Raw:getMin()
ptMin:toGlob( frGeo)
EgtMove( nFrameId, ( ptMin - ORIG()))
EgtSetName( nFrameId, WIN_PRC_FRAME)
EgtErase( vCrvs)
EgtErase( nRegion)
end
----------------------------------------------------------------------------------
---------------------------------- SOLIDO ----------------------------------------
----------------------------------------------------------------------------------
local function GetReferenceCurve( nCrv, nOrigCrv, dOffs, nSurfTrim)
local nRes, nCnt = EgtTrimCurveWithRegion( nCrv, nSurfTrim, true, false)
if nCnt == 1 then
EgtOffsetCurve( nRes, dOffs)
return nRes
else
-- se più di un tratto interno alla regione considero solo quello che fa overlap con l'originale
for nId = nRes, nRes + nCnt - 1 do
EgtOffsetCurve( nId, dOffs)
if CheckExtensionOverlap( nId, nOrigCrv) then
return nId
end
end
end
end
---------------------------------------------------------------------
-- funzione che crea la guida per la superficie di trim, opportunamente estesa per avere booleane ben definite
local function CalcGuideExtension( nCrvId, nGeoId, nSurfTrimId, nLayerId)
local nSemiProfile = EgtGetInfo( nGeoId, WIN_SEMI_PROFILE, 'i')
local nGrpTmp = EgtGroup( nLayerId)
-- creo estensione della curva ( può essere fatta in tangenza perchè parto dalla curva di processing)
local nExtCrvId = EgtCurveCompo( nGrpTmp, nCrvId, false)
EgtAddCurveCompoLineTg( nExtCrvId, 10000, true)
EgtAddCurveCompoLineTg( nExtCrvId, 10000, false)
local nGuideId
if not nSemiProfile then
-- se bisettore controllo solamente la curva stessa
nGuideId = GetReferenceCurve( nExtCrvId, nCrvId, 0, nSurfTrimId)
-- piccola estensione per essere oltre il minimo indispensabile
EgtExtendCurveStartByLen( nGuideId, 2)
EgtExtendCurveEndByLen( nGuideId, 2)
else
-- se semiprofilo controllo estensione richiesta per la sua parte interna ed esterna
local nProfileId = EgtGetParent( nSemiProfile)
local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
local frFrame = EgtFR( nFrameId, GDB_ID.ROOT)
local b3SemiProfile = EgtGetBBoxRef( nSemiProfile, GDB_BB.STANDARD, frFrame)
-- parametri di trim
local dParS = GEO.INFINITO
local dParE = -1
-- parte in
local nInExtCrvId = EgtOffsetCurveAdv( nExtCrvId, b3SemiProfile:getMin():getX())
local nInId = GetReferenceCurve( nInExtCrvId, nCrvId, - b3SemiProfile:getMin():getX(), nSurfTrimId)
if nInId then
dParS = EgtCurveParamAtPoint( nExtCrvId, EgtSP( nInId))
dParE = EgtCurveParamAtPoint( nExtCrvId, EgtEP( nInId))
end
-- parte out
local nOutExtCrvId = EgtOffsetCurveAdv( nExtCrvId, b3SemiProfile:getMax():getX())
local nOutId = GetReferenceCurve( nOutExtCrvId, nCrvId, - b3SemiProfile:getMax():getX(), nSurfTrimId)
if nOutId then
dParS = min( dParS, EgtCurveParamAtPoint( nExtCrvId, EgtSP( nOutId)))
dParE = max( dParE, EgtCurveParamAtPoint( nExtCrvId, EgtEP( nOutId)))
end
-- aggiusto la curva estesa tenendo conto di quanto realmente serve per il corretto trim del solido
EgtTrimCurveStartEndAtParam( nExtCrvId, dParS, dParE)
nGuideId = nExtCrvId
end
EgtRelocateGlob( nGuideId, nLayerId)
EgtErase( nGrpTmp)
return nGuideId
end
---------------------------------------------------------------------
-- funzione che crea le superfici di trim e taglia il solido
local function TrimSolid( vGeoIds, nLayerId, nMainExtrusionId, nMainGuideId, nMainProfileId)
-- creo la superficie di riferimento del solido originale per capire di quanto estendere le superfici di trim in modo da avere booleane ben definite tra le superfici
local b3Profile = GetProfileLocalBox( nMainProfileId)
local nOffsMax = EgtOffsetCurveAdv( nMainGuideId, b3Profile:getMax():getX())
local nOffsMin = EgtOffsetCurveAdv( nMainGuideId, b3Profile:getMin():getX())
EgtInvertCurve( nOffsMin)
local nCompo = EgtCurveCompo( nLayerId, nOffsMax)
EgtAddCurveCompoLine( nCompo, EgtSP( nOffsMin))
EgtAddCurveCompoCurve( nCompo, nOffsMin)
EgtCloseCurveCompo( nCompo)
local nSurfTrim = EgtSurfFlatRegion( nLayerId, nCompo)
EgtSetStatus( nSurfTrim, GDB_ST.OFF)
EgtSetStatus( nCompo, GDB_ST.OFF)
local tabPrcCrv = {}
for i = 1, #vGeoIds do
local nGuideId
local nTrimSurf
-- recupero profilo di riferimento dalla curva geo
local nSemiProfileId = EgtGetInfo( vGeoIds[i], WIN_SEMI_PROFILE, 'i')
-- 1) minizinken
if not nSemiProfileId then
nGuideId = CalcGuideExtension( vGeoIds[i], vGeoIds[i], nSurfTrim, nLayerId)
EgtMove( nGuideId, Z_AX())
nTrimSurf = EgtSurfTmByExtrusion( nLayerId, nGuideId, - Z_AX() * 2 * b3Profile:getDimY(), WIN_SURF_APPROX)
EgtInvertSurf( nTrimSurf)
-- 2) controprofilo
else
-- recupero la curva di lavorazione associata e verifico se la sua superficie di trim è già stata calcolata ( una curva di lavorazione può essere associata
-- a più curve del geo)
local nPrcCrv = EgtGetInfo( vGeoIds[i], WIN_REF_PRC, 'i')
if nPrcCrv then
if tabPrcCrv[nPrcCrv] then
-- se la superficie di trim è già stata creata salvo associazione nella curva geo
EgtSetInfo( vGeoIds[i], WIN_REF_SURF, tabPrcCrv[nPrcCrv])
else
-- riposiziono la curva di lavorazione in corrispondenza dell'outline
local dOffs = EgtGetInfo( vGeoIds[i], WIN_GEO_OFFS, 'd')
local nOffsCrv = EgtOffsetCurveAdv( nPrcCrv, - dOffs)
nGuideId = CalcGuideExtension( nOffsCrv, vGeoIds[i], nSurfTrim, nLayerId)
EgtErase( nOffsCrv)
local nRefOutline = EgtGetInfo( vGeoIds[i], WIN_REF_OUTLINE, 'i')
if nRefOutline < 0 then
EgtInvertCurve( nGuideId)
end
-- recupero il controprofilo da estrudere
local sTrimProfileName = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_OFST .. EgtGetName( nSemiProfileId)
-- calcolo la superficie di estrusione
nTrimSurf = CreateProfileSurf( nGuideId, EgtGetParent( nSemiProfileId), sTrimProfileName, b3Profile:getDimX(), nLayerId)
tabPrcCrv[nPrcCrv] = nTrimSurf
end
end
end
-- taglio il solido principale
if nTrimSurf then
EgtSetStatus( nTrimSurf, GDB_ST.OFF)
EgtSurfTmIntersect( nMainExtrusionId, nTrimSurf)
EgtErase( nGuideId)
EgtSetInfo( vGeoIds[i], WIN_REF_SURF, nTrimSurf)
end
end
EgtErase( nSurfTrim)
EgtErase( nCompo)
end
---------------------------------------------------------------------
-- funzione che calcola la curva guida per il solido principale
local function CalcSolidGuide( nOutlineId, nSolidLayerId, nProfileId, nGeoLayerId)
local nGuideId
local dExtraLinearLen = 400
if EgtGetType( nOutlineId) == GDB_TY.CRV_LINE then
-- se tratto lineare non ci sono problemi per l'estensione
nGuideId = EgtCopyGlob( nOutlineId, nSolidLayerId)
EgtExtendCurveStartByLen( nGuideId, dExtraLinearLen)
EgtExtendCurveEndByLen( nGuideId, dExtraLinearLen)
else
nGuideId = EgtCurveCompo( nSolidLayerId, nOutlineId, false)
-- recupero il tipo di estensione
local nGeoOut = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT)
local bTangS = EgtGetInfo( nGeoOut, WIN_TANG_START, 'b')
local bTangE = EgtGetInfo( nGeoOut, WIN_TANG_END, 'b')
-- calcolo la lunghezza di estensione per l'arco in modo che la parte interna non si chiuda in una circonferenza
local dRad = EgtArcRadius( nOutlineId)
local dAng = EgtArcAngCenter( nOutlineId) * pi / 180
local b3Profile = GetProfileLocalBox( nProfileId)
local dInnerRad = dRad - abs( b3Profile:getMin():getX())
local dExtraLen = ( pi - 0.5 * dAng) * dInnerRad * dRad / dInnerRad - 2
if bTangS then
EgtAddCurveCompoLineTg( nGuideId, dExtraLinearLen, false)
else
EgtExtendCurveStartByLen( nGuideId, dExtraLen)
end
if bTangE then
EgtAddCurveCompoLineTg( nGuideId, dExtraLinearLen, true)
else
EgtExtendCurveEndByLen( nGuideId, dExtraLen)
end
end
EgtSetName( nGuideId, WIN_MAINGUIDE)
EgtSetStatus( nGuideId, GDB_ST.OFF)
-- se bottomrail sposto opportunamente la guida
local sProfileType = EgtGetInfo( nProfileId, WIN_PROFILETYPE)
if sProfileType == WIN_RAIL or sProfileType == WIN_FILL_RAIL then
local dOffs = EgtGetInfo( nProfileId, WIN_RAILOFFS, 'd')
EgtOffsetCurve( nGuideId, - dOffs)
end
return nGuideId
end
---------------------------------------------------------------------
-- funzione che crea il solido di estrusione principale
local function CreateMainSurf( nGuideId, nProfileId, sSectionName, nLayerId)
-- 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
-- creo i solidi corrispondenti alla parte sash e alla parte fill
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
local nGuideId = CalcSolidGuide( nOutlineId, nSolidLayerId, nMainProfileId, nGeoLayerId)
EgtSetName( nGuideId, WIN_MAINGUIDE)
EgtSetStatus( nGuideId, GDB_ST.OFF)
local sSectionSash = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_SASH .. WIN_SECTION
local nMainSash = CreateMainSurf( nGuideId, nMainProfileId, sSectionSash, nSolidLayerId)
local sSectionFill = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_FILL .. WIN_SECTION
local nMainFill = CreateMainSurf( nGuideId, nMainProfileId, sSectionFill, nSolidLayerId)
-- calcolo le superfici di taglio corrispondenti alle fresature del cambio profilo che separano la parte sash e fill
local nMixedIntersectionsGrp = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_MIXED_CURVES)
local vIntersections = EgtGetNameInGroup( nMixedIntersectionsGrp, WIN_MIXED_MILLING .. '1')
local vStmInters = {}
for i = 1, #vIntersections do
local nSplitId = EgtGetInfo( vIntersections[i], WIN_MIXED_SPLIT_REF, 'i')
local vtDir = EgtSV( nSplitId)
local nCrvTrim = EgtCopyGlob( vIntersections[i], nSolidLayerId)
EgtAddCurveCompoLine( nCrvTrim, EgtSP( nCrvTrim) - 3 * dGeoWidth * vtDir, false)
EgtAddCurveCompoLine( nCrvTrim, EgtEP( nCrvTrim) + 3 * dGeoWidth * vtDir)
EgtMove( nCrvTrim, Z_AX())
EgtSetStatus( nCrvTrim, GDB_ST.OFF)
vStmInters[i] = EgtSurfTmByExtrusion( nSolidLayerId, nCrvTrim, - 2 * dGeoWidth * Z_AX())
EgtErase( nCrvTrim)
end
-- taglio le parti sash e fill e le riunisco in una sola superficie
local nStmTrim = EgtSurfTmByTriangles( nSolidLayerId, vStmInters)
EgtSurfTmIntersect( nMainFill, nStmTrim)
EgtSurfTmSubtract( nMainSash, nStmTrim)
EgtErase( nStmTrim)
EgtSurfTmAdd( nMainSash, nMainFill)
EgtErase( nMainFill)
local nMainSolid = nMainSash
-- creo una copia dell'estrusione principale ( usata per ferramenta)
local nOrigMainExtrusionId = EgtCopy( nMainSolid, nSolidLayerId)
EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN)
EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF)
-- b) TRIM START
local vPrevGeoIds = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
TrimSolid( vPrevGeoIds, nSolidLayerId, nMainSolid, nGuideId, nMainProfileId)
-- c) TRIM END
local vNextGeoIds = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
TrimSolid( vNextGeoIds, nSolidLayerId, nMainSolid, nGuideId, nMainProfileId)
return nMainSolid
end
---------------------------------------------------------------------
-- funzione che calcola il solido corrispondente alla fresatura del cambio profilo per uno split
local function CalcMixedSplitMillingSolid( nMillingCrv, nSplitId, nSolidLayerId, dExtraLen, bPrev)
local nGuide = EgtCopyGlob( nMillingCrv, nSolidLayerId)
EgtAddCurveCompoLineTg( nGuide, 10, not bPrev)
local vtDir = EgtSV( nSplitId)
if bPrev then
vtDir = - vtDir
end
EgtAddCurveCompoLine( nGuide, EgtEP( nGuide) + dExtraLen * vtDir)
EgtAddCurveCompoLine( nGuide, EgtSP( nGuide) + dExtraLen * vtDir, false)
EgtCloseCurveCompo( nGuide)
EgtMove( nGuide, 0.01 * Z_AX())
local nCutStm = EgtSurfTmByRegionExtrusion( nSolidLayerId, nGuide, ( EgtCurveThickness( nGuide) - 2) * Z_AX())
EgtErase( nGuide)
return nCutStm
end
---------------------------------------------------------------------
-- funzione che crea la superficie di trim per uno split coinvolto da cambio profilo ( controprofilo della parte sash del telaio e fresatura)
local function CreateMixedSplitTrimSurf( nSplitId, vOutlines, nProfileId, dExtraLen, bPrev, bNext, nSolidLayerId)
-- curva base
local nGuideId = EgtCurveCompo( nSolidLayerId, vOutlines, false)
local sTrimProfile = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_OFST .. WIN_SASH .. WIN_CTRIN
local nTrimStmId = CreateProfileSurf( nGuideId, nProfileId, sTrimProfile, dExtraLen, nSolidLayerId)
-- creo i blocchi per le milling
local nMixedIntersGrp = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_MIXED_CURVES)
if bPrev then
local nMillingCrv = EgtGetFirstNameInGroup( nMixedIntersGrp, WIN_MIXED_MILLING .. '1')
local nMillStmId = CalcMixedSplitMillingSolid( nMillingCrv, nSplitId, nSolidLayerId, dExtraLen, true)
EgtSurfTmSubtract( nTrimStmId, nMillStmId)
EgtErase( nMillStmId)
end
if bNext then
local nMillingCrv = EgtGetLastNameInGroup( nMixedIntersGrp, WIN_MIXED_MILLING .. '1')
local nMillStmId = CalcMixedSplitMillingSolid( nMillingCrv, nSplitId, nSolidLayerId, dExtraLen, false)
EgtSurfTmSubtract( nTrimStmId, nMillStmId)
EgtErase( nMillStmId)
end
EgtSetStatus( nTrimStmId, GDB_ST.OFF)
EgtErase( nGuideId)
return nTrimStmId
end
---------------------------------------------------------------------
-- funzione che crea il solido di un pezzo di split coinvolto da cambio profilo
local function CalcMixedSplitSolid( nOutlineId, nSolidLayerId, nProfileLayerId, nGeoLayerId, dGeoWidth)
-- a) creo il solido di estrusione principale
local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
local nGuideId = CalcSolidGuide( nOutlineId, nSolidLayerId, nMainProfileId, nGeoLayerId)
local sSection = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_SECTION
local nMainExtrusionId = CreateMainSurf( nGuideId, nMainProfileId, sSection, nSolidLayerId)
-- creo una copia
local nOrigMainExtrusionId = EgtCopy( nMainExtrusionId, nSolidLayerId)
EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN)
EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF)
-- b) calcolo le superfici di trim con i controprofili sash e le curve di fresatura verificando se i tratti prev e next possono essere uniti per evitare di fare
-- booleane con superfici in parte sovrapposte
local vPrevOutlines = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'vi')
local vNextOutlines = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'vi')
local vPrevGeo = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
local vNextGeo = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
if vPrevOutlines[1] == vNextOutlines[#vNextOutlines] or vPrevOutlines[#vPrevOutlines] == vNextOutlines[1] then
-- se prev e next hanno una curva comune gestisco come unica superficie
local vCrvs
if vPrevOutlines[1] == vNextOutlines[#vNextOutlines] then
vNextOutlines[#vNextOutlines] = nil
vCrvs = EgtJoinTables( vNextOutlines, vPrevOutlines)
else
vPrevOutlines[#vPrevOutlines] = nil
vCrvs = EgtJoinTables( vPrevOutlines, vNextOutlines)
end
local nPrevProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_START)
local nTrimStmId = CreateMixedSplitTrimSurf( nOutlineId, vCrvs, nPrevProfileId, 2 * dGeoWidth, true, true, nSolidLayerId)
EgtSurfTmIntersect( nMainExtrusionId, nTrimStmId)
for i = 1, #vPrevGeo do
EgtSetInfo( vPrevGeo[i], WIN_REF_SURF, nTrimStmId)
end
for i = 1, #vNextGeo do
EgtSetInfo( vNextGeo[i], WIN_REF_SURF, nTrimStmId)
end
else
local nPrevProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_START)
local nTrimStmId1 = CreateMixedSplitTrimSurf( nOutlineId, vPrevOutlines, nPrevProfileId, 2 * dGeoWidth, true, false, nSolidLayerId)
EgtSurfTmIntersect( nMainExtrusionId, nTrimStmId1)
for i = 1, #vPrevGeo do
EgtSetInfo( vPrevGeo[i], WIN_REF_SURF, nTrimStmId1)
end
local nNextProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END)
local nTrimStmId2 = CreateMixedSplitTrimSurf( nOutlineId, vNextOutlines, nNextProfileId, 2 * dGeoWidth, false, true, nSolidLayerId)
EgtSurfTmIntersect( nMainExtrusionId, nTrimStmId2)
for i = 1, #vNextGeo do
EgtSetInfo( vNextGeo[i], WIN_REF_SURF, nTrimStmId2)
end
end
return nMainExtrusionId
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, nGeoLayerId, 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 nGuideId = CalcSolidGuide( nOutlineId, nSolidLayerId, nMainProfileId, nGeoLayerId)
local sSection = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_SECTION
local nMainExtrusionId = CreateMainSurf( nGuideId, 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 nGeoRight = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
TrimSolid( nGeoRight, nSolidLayerId, nMainExtrusionId, nGuideId, nMainProfileId)
local nGeoLeft = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
TrimSolid( nGeoLeft, nSolidLayerId, nMainExtrusionId, nGuideId, nMainProfileId)
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 - 0.05) * vtExtr)
-- piccola traslazione per non essere a filo con la superficie
EgtMove( nProcSolidId, 0.05 * 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( nPrevRight, nCurrLeft, nRefOutline, bCurrFullOrShort)
local vtZ
local ptOrig
if EgtGetType( nRefOutline) == GDB_TY.CRV_LINE then
vtZ = EgtEV( nRefOutline)
ptOrig = EgtIf( bCurrFullOrShort, EgtEP( nRefOutline), EgtSP( nRefOutline))
else
-- se pezzo ad arco, recupero la direzione dalla curva nel punto estremo del geo
local ptRef = EgtIf( bCurrFullOrShort, EgtSP( nPrevRight), EgtEP( nCurrLeft))
local _, ptInt, dPar = EgtPointCurveDist( ptRef, nRefOutline)
vtZ = EgtUV( nRefOutline, dPar, -1)
ptOrig = ptInt
end
local frDest = Frame3d( ptOrig, - vtZ)
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, 3000 * 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 i dowels tra due pezzi
local function CalcDowels( nOrigOutlineId, nOrigPrevOutlineId, bSashOrFrame, nBottomRail)
-- TODO correzione per non far uscire i dowels
-- 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_RAILOFFS, 'd')
else
nRefCrv = nPrevOutlineId
dOffs = EgtGetInfo( nPrevProfileId, WIN_RAILOFFS, 'd')
end
EgtOffsetCurve( nRefCrv, - dOffs)
end
-- recupero le curve di riferimento dei geo ( right per il prev e left per il corrente)
local nGeo = EgtGetFirstNameInGroup( nPart, WIN_GEO)
local nPrevGeo = EgtGetFirstNameInGroup( nPrevPart, WIN_GEO)
local vPrevGeoCrvs = EgtGetNameInGroup( nPrevGeo, WIN_GEO_RIGHT)
local nPrevRight = vPrevGeoCrvs[1]
for i = 2, #vPrevGeoCrvs do
local nRefOutline = EgtGetInfo( vPrevGeoCrvs[i], WIN_REF_OUTLINE, 'i')
if nRefOutline == nOrigOutlineId then
nPrevRight = vPrevGeoCrvs[i]
break
end
end
local vCurrGeoCrvs = EgtGetNameInGroup( nGeo, WIN_GEO_LEFT)
local nCurrLeft = vCurrGeoCrvs[1]
for i = 2, #vCurrGeoCrvs do
local nRefOutline = EgtGetInfo( vCurrGeoCrvs[i], WIN_REF_OUTLINE, 'i')
if nRefOutline == nOrigPrevOutlineId then
nCurrLeft = vCurrGeoCrvs[i]
break
end
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
if nBottomRail then
if EgtGetName( nOutlineId) == WIN_BOTTOM then
nJointType = WIN_PART_JNT.SHORT
else
nJointType = WIN_PART_JNT.FULL
end
else
local vJointTypes = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'vi')
local vPrevOutlines = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'vi')
for i = 1, #vPrevOutlines do
if vPrevOutlines[i] == nOrigPrevOutlineId then
nJointType = vJointTypes[i]
break
end
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( nPrevRight, nCurrLeft, nPrevOutlineId, true)
-- 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 EgtGetName( nOutlineId) == WIN_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 nOrigSurf = EgtGetInfo( nPrevRight, WIN_REF_SURF, 'i')
nTestSurf = EgtCopyGlob( nOrigSurf, nLayerId)
end
local nTestSurfInverted = EgtCopyGlob( nTestSurf, nLayerId)
EgtInvertSurf( nTestSurfInverted)
-- 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
for i = 1, #vDowels do
-- dowels per pezzo corrente ( full)
local dLenFull = CalcDowelLen( vDowels[i], sLenKey, true)
CreateDowel( vDowels[i], nLayerId, frOrig, frDest, - frDest: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, frDest, frDest:getVersZ(), nTestSurf, dLenShort, WIN_PRC_SIDETYPE.RIGHT, nPrevSolidId)
end
end
end
EgtErase( nTestSurf)
EgtErase( nTestSurfInverted)
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( nPrevRight, nCurrLeft, nOutlineId, false)
-- 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 EgtGetName( nPrevOutlineId) == WIN_BOTTOM then
if not nBottomRail then
sLenKey = WIN_DWL_BOTTOM_PARA_LEN
sPrevLenKey = WIN_DWL_BOTTOM_PERP_LEN
else
sLenKey = WIN_DWL_BOTTOMRAIL_PARA_LEN
sPrevLenKey = WIN_DWL_BOTTOMRAIL_PERP_LEN
end
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 nOrigSurf = EgtGetInfo( nCurrLeft, WIN_REF_SURF, 'i')
nTestSurf = EgtCopyGlob( nOrigSurf, nLayerId)
end
local nTestSurfInverted = EgtCopyGlob( nTestSurf, nLayerId)
EgtInvertSurf( nTestSurfInverted)
-- 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
for i = 1, #vDowels do
-- dowels per pezzo corrente ( short)
local dLenShort = CalcDowelLen( vDowels[i], sLenKey, false)
CreateDowel( vDowels[i], nLayerId, frOrig, frDest, - frDest: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, frDest, frDest:getVersZ(), nTestSurfInverted, dLenFull, WIN_PRC_SIDETYPE.IN, nPrevSolidId)
end
end
end
EgtErase( nTestSurf)
EgtErase( nTestSurfInverted)
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
-- TO DO : gestione split non lineare
-- 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 nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
local nGeoCrvId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN)
local sDowelSide = WIN_PRC_SIDETYPE.IN
-- se split verifico se interferisce con lato in o out del geo
if EgtGetName( nOutlineId) == WIN_SPLIT then
local _, _, nSide = EgtPointCurveDistSide( EgtMP( nSplitId), nOutlineId, Z_AX())
if nSide == 1 then
nGeoCrvId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT)
sDowelSide = WIN_PRC_SIDETYPE.OUT
end
end
-- calcolo il frame di destinazione
local ptOrig = EgtIf( bStartOrEnd, EgtSP( nSplitId), EgtEP( nSplitId))
local frDest = Frame3d( ptOrig, - 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)
CopyInfo( nSplitProfileCopyId, nSplitProfile, WIN_PROFILETYPE)
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 EgtGetName( nOutlineId) == WIN_BOTTOM then
-- verifico se ha bottomrails
local nBottomRails = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or 0
if nBottomRails == 0 then
sSplitLenKey = WIN_DWL_BOTTOM_PARA_LEN
sLenKey = WIN_DWL_BOTTOM_PERP_LEN
else
sSplitLenKey = WIN_DWL_RAILBOTTOM_PARA_LEN
sLenKey = WIN_DWL_RAILBOTTOM_PERP_LEN
end
elseif EgtGetName( nOutlineId) == WIN_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 vOutlines
if bStartOrEnd then
vOutlines = EgtGetInfo( nSplitId, WIN_PREV_OUTLINES, 'vi')
else
vOutlines = EgtGetInfo( nSplitId, WIN_NEXT_OUTLINES, 'vi')
end
nTestSurf = CreateMixedSplitTrimSurf( nSplitId, vOutlines, nProfileId, 100, bStartOrEnd, not bStartOrEnd, 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 = EgtIf( bStartOrEnd, - EgtSV( nSplitId), EgtSV( nSplitId))
-- 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
---------------------------------------------------------------------
-- 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 EgtGetInfo( nPrevOutline, WIN_EXTRA_CRV, 'b') do
nPrevOutline = EgtGetPrev( nPrevOutline)
end
while nOutline do
local bExtra = EgtGetInfo( nOutline, WIN_EXTRA_CRV, 'b') or false
if not bExtra then
-- 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
end
nOutline = EgtGetNext( nOutline)
end
elseif nAreaType == WIN_AREATYPES.SPLIT then
local nSplitType = EgtGetInfo( nAreaId, 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 nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT)
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
if nOutlineId < 0 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, 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)
-- calcolo offset per strip
local dDelta = EgtGetInfo( nProfileId, WIN_RAILOFFS, 'd') or 0
local dMinOffs = b3MainStrip:getMin():getX() - dDelta
local dMaxOffs = b3MainStrip:getMax():getX() - dDelta
local nMinOffsetId = EgtCopy( abs( nOutlineId), nSolidLayerId)
EgtOffsetCurve( nMinOffsetId, dMinOffs)
local nMaxOffsetId = EgtCopy( abs( nOutlineId), nSolidLayerId)
EgtOffsetCurve( nMaxOffsetId, dMaxOffs)
-- verifico se le curve vanno invertite nel caso di split
if nOutlineId < 0 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( nOutlineLayerId)
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 vOutlineCrvs = EgtGetAllInGroup( nOutlineLayerId)
local tabStrip = {}
for i = 1, #vOutlineCrvs do
local nOutlineId = EgtGetInfo( vOutlineCrvs[i], WIN_SOU_OUTLINE, 'i')
-- verifico se pezzo ausiliario da ignorare
local bExtra = EgtGetInfo( nOutlineId, WIN_EXTRA_CRV, 'b')
local nPartId = FindAssociatedPart( abs( nOutlineId), true)
-- recupero profilo
local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
local nStripId = GetStripNearestToOutline( nProfileId, nOutlineId)
-- recupero layer per solido
local nStripExtrusionId
if not bExtra then
local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID)
-- estrusione del fermavetro :
-- creazione della giuda
local nGuideId = EgtCurveCompo( nSolidLayerId, abs( nOutlineId), false)
local sProfileType = EgtGetInfo( nProfileId, WIN_PROFILETYPE)
if sProfileType == WIN_FILL_RAIL then
local dOffs = EgtGetInfo( nProfileId, WIN_RAILOFFS, 'd')
EgtOffsetCurve( nGuideId, - dOffs)
end
-- estensione : se in tangenza con le vicine estensione in tangenza altrimenti estensione standard
local nPrev = EgtGetPrev( vOutlineCrvs[i]) or EgtGetLastInGroup( nOutlineLayerId)
local nNext = EgtGetNext( vOutlineCrvs[i]) or EgtGetLastInGroup( nOutlineLayerId)
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)
nStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nSectionId, nGuideId, false, WIN_SURF_APPROX)
EgtSetName( nStripExtrusionId, WIN_SRF_STRIP)
EgtErase( nSectionId)
EgtErase( nGuideId)
end
-- curve limite del fermavetro
local nOffs1, nOffs2 = CreateStripGuideLines( nOutlineId, nStripId, nProfileId, nGrp)
EgtRelocateGlob( nOffs1, nGrp1)
EgtRelocateGlob( nOffs2, nGrp2)
EgtSetInfo( nOffs1, WIN_REF_OUTLINE, vOutlineCrvs[i])
EgtSetInfo( nOffs2, WIN_REF_OUTLINE, vOutlineCrvs[i])
tabStrip[vOutlineCrvs[i]] = { Offs1 = GDB_ID.NULL, Offs2 = GDB_ID.NULL, StripId = nStripExtrusionId}
end
-- taglio le curve limite dei fermavetri per individuare correttamente i pezzi con cui verranno tagliati
local vCrv1 = TrimOrderedCurves( EgtGetAllInGroup( nGrp1), true)
local vCrv2 = TrimOrderedCurves( EgtGetAllInGroup( nGrp2), true)
-- associo le curve trimmate alle curve geo corrispondenti
for i = 1, #vCrv1 do
local nOutlineRef = EgtGetInfo( vCrv1[i], WIN_REF_OUTLINE, 'i')
tabStrip[nOutlineRef].Offs1 = vCrv1[i]
end
for i = 1, #vCrv2 do
local nOutlineRef = EgtGetInfo( vCrv2[i], WIN_REF_OUTLINE, 'i')
tabStrip[nOutlineRef].Offs2 = vCrv2[i]
end
-- trim dei solidi fermavetro
for i = 1, #vOutlineCrvs do
if tabStrip[vOutlineCrvs[i]].StripId then
-- recupero solido del fermavetro
local nCrv = vOutlineCrvs[i]
local nStripId = tabStrip[nCrv].StripId
local nSolidLayerId = EgtGetParent( nStripId)
-- recupero le corrispondenti curve limite trimmate
local nCrvOffs1 = tabStrip[nCrv].Offs1
local nCrvOffs2 = tabStrip[nCrv].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_OUTLINE, 'i')
local nPrevCrv2 = EgtGetInfo( nPrev2, WIN_REF_OUTLINE, '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 nCurrCrv = tabStrip[nPrevCrv1].Offs2
nCurrCrv = EgtGetNext( nCurrCrv) or EgtGetFirstInGroup( nGrp2)
local vIds = {}
while nCurrCrv ~= nCrvOffs2 do
table.insert( vIds, nCurrCrv)
nCurrCrv = EgtGetNext( nCurrCrv) or EgtGetFirstInGroup( nGrp2)
end
local nCrvBorder = EgtCurveCompo( nGrp, vIds, false)
-- taglio
TrimStripSurfByCurve( nCrvBorder, nStripId, nSolidLayerId)
-- b) taglio che separa da pezzo 1
TrimStripSurfByPoints( EgtCP( nCrvBorder), EgtSP( nCrvOffs1), nStripId, nSolidLayerId, true)
EgtErase( nCrvBorder)
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_OUTLINE, 'i')
local nNextCrv2 = EgtGetInfo( nNext2, WIN_REF_OUTLINE, 'i')
if nNextCrv1 == nNextCrv2 then
TrimStripSurfByPoints( EgtEP( nCrvOffs1), EgtEP( nCrvOffs2), nStripId, nSolidLayerId)
else
local nCurrCrv = nCrvOffs2
nCurrCrv = EgtGetNext( nCurrCrv) or EgtGetFirstInGroup( nGrp2)
local vIds = {}
while nCurrCrv ~= tabStrip[nNextCrv1].Offs2 do
table.insert( vIds, nCurrCrv)
nCurrCrv = EgtGetNext( nCurrCrv) or EgtGetFirstInGroup( nGrp2)
end
local nCrvBorder = EgtCurveCompo( nGrp, vIds, false)
TrimStripSurfByCurve( nCrvBorder, nStripId, nSolidLayerId)
TrimStripSurfByPoints( EgtEP( nCrvOffs1), EgtCP( nCrvBorder), nStripId, nSolidLayerId)
EgtErase( nCrvBorder)
end
else
-- il pezzo scompare
EgtErase( nStripId)
end
end
end
EgtErase( nGrp)
EgtErase( nGrp1)
EgtErase( nGrp2)
end
----------------------------------------------------------------------------------
----------------------------- CALCOLO PEZZI ------------------------------------
----------------------------------------------------------------------------------
local function CalculateAreaParts( nFrameId)
-- recupero i pezzi del serramento
local vParts = {}
local vFillParts = {}
local vAuxParts = {} -- sono pezzi non fisicamente realizzabili che servono solo per i conti
local nPartId = EgtGetFirstPart( GDB_ID.ROOT)
while nPartId do
local nType = EgtGetInfo( nPartId, WIN_PART_TYPE, 'i')
if nType == WIN_PART_TYPES.FILL then
table.insert( vFillParts, nPartId)
else
local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
local bExtra = EgtGetInfo( nOutlineId, WIN_EXTRA_CRV, 'b') or false
if bExtra then
table.insert( vAuxParts, nPartId)
else
table.insert( vParts, { nId = nPartId, nOutlineId = nOutlineId})
end
end
nPartId = EgtGetNextPart( nPartId)
end
-- calcolo geo
for i = 1, #vParts do
CalcGeo( vParts[i].nId, vParts[i].nOutlineId)
end
-- calcolo cambio profilo sugli split di tipo mixed
for i = 1, #vParts do
if EgtGetName( vParts[i].nOutlineId) == WIN_SPLIT then
local nSplitType = EgtGetInfo( vParts[i].nOutlineId, WIN_SPLITTYPE, 'i')
if nSplitType == WIN_SPLITTYPES.MIXED then
CalcMixedCurves( vParts[i].nId, vParts[i].nOutlineId)
end
end
end
-- calcolo le lavorazioni associate ai profili
for i = 1, #vParts do
CalcProfilingProcessings( vParts[i].nId, vParts[i].nOutlineId)
end
-- calcolo il georaw per automatismo lavorazioni
for i = 1, #vParts do
CalcGeoRaw( vParts[i].nId, vParts[i].nOutlineId)
end
-- disegno solido
if s_bCalcSolid then
for i = 1, #vParts do
CalcSolid( vParts[i].nId, vParts[i].nOutlineId)
end
end
-- pezzi fill
for i = 1, #vFillParts do
local nAreaId = EgtGetInfo( vFillParts[i], WIN_AREA, 'i')
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
local nGeoLayerId = CalcFillGeo( vFillParts[i], nOutlineLayerId)
-- disegno solido
if s_bCalcSolid then
CalcFillSolid( vFillParts[i], nGeoLayerId)
end
-- calcolo fermavetro
CalcAreaStrip( nOutlineLayerId)
end
-- elimino i pezzi ausiliari
EgtErase( vAuxParts)
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 nFrameOutlineId = EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, '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, true)
-- 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 = 5 -- EgtGetInfo( nInfoGrp, WIN_DWL_DIAM, 'd')
local dDowelLen = 10 -- 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)
-- creo il GeoRaw per il pezzo ad arco
local nGeoRawLayerId = EgtGroup( nPartId)
EgtSetName( nGeoRawLayerId, WIN_GEO_RAW)
EgtSetStatus( nGeoRawLayerId, GDB_ST.OFF)
-- 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 nFrameOutlineId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i'))
local dDelta = ( EgtSP( nOutlineId) - EgtSP( nFrameOutlineId)) * 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 nFrameOutlineId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i'))
local dDelta = ( EgtSP( nOutlineId) - EgtSP( nFrameOutlineId)) * Z_AX()
if dDelta < GEO.EPS_SMALL then
return
end
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 = abs( b3Profile:getMin():getX() + 0.5 * b3Profile:getDimX())
-- correzione per caso speciale di telaio e ante allineate ( euristica)
local nParentAreaId = EgtGetParent( EgtGetParent( nOutlineId))
local nSashType = EgtGetInfo( nParentAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL
if nSashType == WIN_SASHTYPES.NULL then
local nFrameOutlineId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i'))
local dDelta = ( EgtSP( nOutlineId) - EgtSP( nFrameOutlineId)) * Z_AX()
if dDelta < GEO.EPS_SMALL then
dSide = dSide + 9
end
end
-- 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])
if dVal then
return dVal
else
break
end
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 sOptionHandleSide
for i = 1, #vOptions do
local vString = EgtSplitString( vOptions[i], '=')
if vString[1] == 'PosizioneManiglia' then
sOptionHandleSide = vString[2]
break
end
end
-- se non ho trovato l'opzione la recupero dalle opzioni di default ( simile a GetHandleHeigt)
if not sOptionHandleSide then
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'] == 'PosizioneManiglia' then
sOptionHandleSide = tabOptions['ParametriOpzioni']['Parametri'][i]['ValoreCorrente']
end
end
end
end
local sHandleSide = 'Sx'
local nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_RIGHT)
if sOptionHandleSide == 'destra' then
sHandleSide = 'Dx'
nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_LEFT)
elseif sOptionHandleSide == 'sopra' then
nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_TOP)
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 bLeftInactive = EgtGetInfo( nLeftId, 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)
-- 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 nSashProfileId = GetOutlineProfileId( nOutlineId)
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, true)
-- costruisco i riferimenti
local tFrame = {}
for i = 1, #vOutlineCopy do
-- 1) Riferimenti ANTA
local ptOrig = EgtEP( vOutlineCopy[i])
local sOrigName = string.char( string.byte( 'A') + #vOutlineCopy - i)
local vtDir = EgtEV( vOutlineCopy[i])
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[i], WIN_GAPDELTAZ, 'd')
local nFA2Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig - dGapDeltaZ * Z_AX(), - vtDir, vtDir ^ vtIn, vtIn))
EgtSetName( nFA2Id, sOrigName .. '.FA2')
local dGapDeltaZ2 = EgtGetInfo( vOutlineCopy[i], 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. Deve essere un elemento reale, quindi se fosse french split lo ignoro
local bFrenchSplit = EgtGetInfo( vOutlineCopy[i], WIN_CRV_ON_FRENCH_SPLIT, 'b')
if not bFrenchSplit then
local nSouId = EgtGetInfo( vOutlineCopy[i], WIN_SOU_OUTLINE, 'i')
-- ricavo aria lato telaio
local nFrameProfileId = GetOutlineProfileId( abs( nSouId))
local dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA, 'd')
if not dGapDeltaOut then
-- recupero informazione dal lato corretto ( split orizzontale)
if nSouId > 0 then
dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '2', 'd')
else
dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '1', 'd')
end
end
-- verifico il segno dell'offset
if nSouId < 0 then
dGapDeltaOut = - dGapDeltaOut
end
local nOutlineOutId = EgtCopy( abs( 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 nFrameOutlineId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, '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 nFrameAreaId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*')
local bSlide = EgtGetInfo( nFrameAreaId, WIN_SLIDE_WINDOW, 'b') or false
if bSlide then
-- le dimensioni per alzante scorrevole sono quelle del telaio
local nOutlineLayId = EgtGetFirstNameInGroup( 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 nSplitType = EgtGetInfo( nAreaId, 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
-- ( slide window ha una struttura di aree standard e forma rettangolare)
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 nSplitArea = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
local vSashAreas = EgtGetNameInGroup( nSplitArea, WIN_AREA .. '*')
for i = 1, #vSashAreas do
local nSashType = EgtGetInfo( vSashAreas[i], WIN_SASHTYPE, 'i')
if nSashType == WIN_SASHTYPES.SLIDE_FIXED then
local nGuideId = EgtCopyGlob( nOutlineId, nAuxGrp)
-- trim della guida con il geo dei pezzi vicini
local nOutlineLayerId = EgtGetFirstNameInGroup( vSashAreas[i], WIN_OUTLINE)
local nLeftCrv = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_LEFT)
local dParS = GetTrimParamByGeo( nGuideId, nLeftCrv, WIN_GEO_OUT)
local nRightCrv = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_RIGHT)
local dParE = GetTrimParamByGeo( nGuideId, nRightCrv, 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
local vParams = {}
-- calcolo i limiti del gocciolatoio in base ai pezzi vicini del telaio
local vPrevCrvs = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'vi')
local dParS = GetTrimParamByGeo( nOutlineId, vPrevCrvs[1], WIN_GEO_IN)
table.insert( vParams, dParS)
local vNextCrvs = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'vi')
local dParE = GetTrimParamByGeo( nOutlineId, vNextCrvs[1], WIN_GEO_IN)
table.insert( vParams, dParE)
-- calcolo eventuali interruzioni nel gocciolatoio per la presenza di montanti
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 nSplitType = EgtGetInfo( vStack[i], WIN_SPLITTYPE, 'i')
if nSplitType ~= WIN_SPLITTYPES.FRENCH then
local nSplitLayerId = EgtGetFirstNameInGroup( vStack[i], WIN_SPLIT)
local vCurrSplits = EgtGetAllInGroup( nSplitLayerId)
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
-- recupero l'intervallo di interruzione dello split sull'outline
local dParIn = GetTrimParamByGeo( nOutlineId, vCurrSplits[j], WIN_GEO_IN)
table.insert( vParams, dParIn)
local dParOut = GetTrimParamByGeo( nOutlineId, vCurrSplits[j], WIN_GEO_OUT)
table.insert( vParams, dParOut)
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
-- riordino i parametri ( non dovrebbero mai capitare parametri coincidenti)
table.sort( vParams)
for j = 1, #vParams, 2 do
-- ricavo la guida per il tratto di gocciolatoio
local nGuideId = EgtCopyParamRange( nOutlineId, vParams[j], vParams[j+1], nSolidLayId)
dLenTot = dLenTot + EgtCurveLength( nGuideId)
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
-- 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, true)
-- 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( nBottomId, 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, 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])
-- la curva right corrisponde al geo in del pezzo adiacente
local vNextOutlines = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'vi')
local nNextPart = FindAssociatedPart( abs( vNextOutlines[1]), false)
local nNextGeo = EgtGetFirstNameInGroup( nNextPart, WIN_GEO)
local nNextIn = EgtGetFirstNameInGroup( nNextGeo, WIN_GEO_IN)
vCrvs[2] = EgtCopyGlob( nNextIn, nPreviewGrp)
EgtInvertCurve( vCrvs[2])
-- 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)
-- la curva left corrisponde al geo in del pezzo adiacente
local vPrevOutlines = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'vi')
local nPrevPart = FindAssociatedPart( abs( vPrevOutlines[1]), false)
local nPrevGeo = EgtGetFirstNameInGroup( nPrevPart, WIN_GEO)
local nPrevIn = EgtGetFirstNameInGroup( nPrevGeo, WIN_GEO_IN)
vCrvs[4] = EgtCopyGlob( nPrevIn, nPreviewGrp)
EgtInvertCurve( vCrvs[4])
-- 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 dH = b3Surf:getDimY()
local vBottomRailDims = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL .. WIN_PART_DIM, 'vd')
local dTotDim = 0
for i = 1, #vBottomRailDims do
dTotDim = dTotDim + vBottomRailDims[i]
end
local dPos = 0
for i = 1, nBottomRail - 1 do
dPos = dPos + vBottomRailDims[i] * dH / dTotDim
local pt = b3Surf:getMin() + dPos * 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 nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i')
local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
-- recupero il tipo di giunzioni
local vStartJoints = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'vi')
local vEndJoints = EgtGetInfo( nOutlineId, WIN_ENDJOINT, 'vi')
local nAreaId
-- se pezzo semplice senza giunzioni short come preview posso considerare direttamente la regione del geo
if #vStartJoints == 1 and #vEndJoints == 1 and vStartJoints[1] ~= WIN_PART_JNT.SHORT and vEndJoints[1] ~= WIN_PART_JNT.SHORT then
local nGeoSurf = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_SURF)
nAreaId = EgtCopyGlob( nGeoSurf, nPreviewGrp)
EgtSetStatus( nAreaId, GDB_ST.ON)
-- altrimenti devo calcolare le curve che delimitano la regione ( in modo simile a quanto fatto in CreateGeoCurves)
else
local nGrpTmp = EgtGroup( nPreviewGrp)
local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN)
local b3Profile = GetProfileLocalBox( nProfileId)
-- a) curva out : ricalcolo curva del geo ( non posso utilizzare direttamente quella del geo perchè non deve avere estensioni)
local nOutId = EgtCopy( nOutlineId, nGrpTmp)
EgtOffsetCurve( nOutId, b3Profile:getMax():getX())
local nGeoOut = EgtGetFirstNameInGroup( nGeoLayerId, WIN_OUT)
CopyInfo( nOutId, nGeoOut, WIN_TANG_START, false)
CopyInfo( nOutId, nGeoOut, WIN_TANG_END, false)
-- b) curva in
local nInId = EgtCopy( nOutlineId, nGrpTmp)
EgtOffsetCurve( nInId, b3Profile:getMin():getX())
EgtInvertCurve( nInId)
local nGeoIn = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN)
CopyInfo( nInId, nGeoIn, WIN_TANG_START, false)
CopyInfo( nInId, nGeoIn, WIN_TANG_END, false)
-- c) curve left
local vGeoLeft = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
local vPrevOutlineId = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'vi')
local vPrevProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_START)
for i = 1, #vPrevOutlineId do
if vStartJoints[i] == WIN_PART_JNT.ANGLED then
-- recupero la bisettrice dal geo
for k = 1, #vGeoLeft do
if EgtGetInfo( vGeoLeft[k], WIN_REF_OUTLINE, 'i') == vPrevOutlineId[i] and not EgtExistsInfo( vGeoLeft[k], WIN_SEMI_PROFILE) then
EgtCopyGlob( vGeoLeft[k], nGrpTmp)
end
end
-- curva aux : considero l'out del pezzo precedente
local nCrvId = EgtCopyGlob( abs( vPrevOutlineId[1]), nGrpTmp)
local b3Profile = GetProfileLocalBox( vPrevProfileId[1])
EgtOffsetCurve( nCrvId, b3Profile:getMax():getX())
else
-- se è pezzo del telaio contro soglia lo tratto come se fosse full
if EgtGetName( nOutlineId) ~= WIN_SPLIT and EgtGetInfo( abs( vPrevOutlineId[i]), WIN_THRESHOLD, 'b') then
vStartJoints[i] = WIN_PART_JNT.FULL
end
if vStartJoints[i] == WIN_PART_JNT.SHORT then
local b3Profile = GetProfileLocalBox( vPrevProfileId[i])
local nCrvId = EgtCopy( abs( vPrevOutlineId[i]), nGrpTmp)
local dRailDelta = EgtGetInfo( vPrevProfileId[i], WIN_RAILOFFS, 'd') or 0
local dOffs = b3Profile:getMin():getX() - dRailDelta
if vPrevOutlineId[i] < 0 then
EgtInvertCurve( nCrvId)
dOffs = - b3Profile:getMax():getX()
end
EgtOffsetCurve( nCrvId, dOffs)
-- per un risultato graficamente migliore se il pezzo precedente è in tangenza con il vicino, impongo estensione in tangenza, altrimenti considero quella
-- calcolata dal geo
local nStartType = EgtGetInfo( abs( vPrevOutlineId[i]), WIN_STARTJOINT, 'i')
if nStartType == WIN_PART_JNT.ANGLED then
EgtSetInfo( nCrvId, WIN_TANG_START, true)
else
CopyInfo( nCrvId, vGeoLeft[i], WIN_TANG_START, false)
end
local nEndType = EgtGetInfo( abs( vPrevOutlineId[i]), WIN_ENDJOINT, 'i')
if nEndType == WIN_PART_JNT.ANGLED then
EgtSetInfo( nCrvId, WIN_TANG_END, true)
else
CopyInfo( nCrvId, vGeoLeft[i], WIN_TANG_END, false)
end
else -- full
-- considero l'out del pezzo precedente
local nCrvId = EgtCopy( abs( vPrevOutlineId[i]), nGrpTmp)
local b3Profile = GetProfileLocalBox( vPrevProfileId[i])
local dOffs = b3Profile:getMax():getX()
if vPrevOutlineId[i] < 0 then
EgtInvertCurve( nCrvId)
dOffs = - b3Profile:getMin():getX()
end
EgtOffsetCurve( nCrvId, dOffs)
CopyInfo( nCrvId, vGeoLeft[i], WIN_TANG_START, false)
CopyInfo( nCrvId, vGeoLeft[i], WIN_TANG_END, false)
end
end
end
-- d) curve right
local vGeoRight = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
local vNextOutlineId = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'vi')
local vNextProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_END)
for i = 1, #vNextOutlineId do
if vEndJoints[i] == WIN_PART_JNT.ANGLED then
-- recupero la bisettrice dal geo
local nCrvId
for k = 1, #vGeoRight do
if EgtGetInfo( vGeoRight[k], WIN_REF_OUTLINE, 'i') == vNextOutlineId[i] and not EgtExistsInfo( vGeoRight[k], WIN_SEMI_PROFILE) then
nCrvId = EgtCopyGlob( vGeoRight[k], nGrpTmp)
EgtRelocateGlob( nCrvId, nInId, GDB_IN.BEFORE)
end
end
-- curva aux
local nAuxCrv = EgtCopyGlob( abs( vNextOutlineId[i]), nGrpTmp)
local b3Profile = GetProfileLocalBox( vNextProfileId[i])
EgtOffsetCurve( nAuxCrv, b3Profile:getMax():getX())
EgtRelocateGlob( nAuxCrv, nInId, GDB_IN.BEFORE)
else
local nCrvId
-- se è pezzo del telaio contro soglia lo tratto come se fosse full
if EgtGetName( nOutlineId) ~= WIN_SPLIT and EgtGetInfo( abs( vNextOutlineId[i]), WIN_THRESHOLD, 'b') then
vEndJoints[i] = WIN_PART_JNT.FULL
end
if vEndJoints[i] == WIN_PART_JNT.SHORT then
nCrvId = EgtCopyGlob( abs( vNextOutlineId[i]), nGrpTmp)
local b3Profile = GetProfileLocalBox( vNextProfileId[i])
local dRailDelta = EgtGetInfo( vNextProfileId[i], WIN_RAILOFFS, 'd') or 0
local dOffs = b3Profile:getMin():getX() - dRailDelta
if vNextOutlineId[i] < 0 then
EgtInvertCurve( nCrvId)
dOffs = - b3Profile:getMax():getX()
end
EgtOffsetCurve( nCrvId, dOffs)
local nStartType = EgtGetInfo( abs( vNextOutlineId[i]), WIN_STARTJOINT, 'i')
if nStartType == WIN_PART_JNT.ANGLED then
EgtSetInfo( nCrvId, WIN_TANG_START, true)
else
CopyInfo( nCrvId, vGeoRight[i], WIN_TANG_START, false)
end
local nEndType = EgtGetInfo( abs( vNextOutlineId[i]), WIN_ENDJOINT, 'i')
if nEndType == WIN_PART_JNT.ANGLED then
EgtSetInfo( nCrvId, WIN_TANG_END, true)
else
CopyInfo( nCrvId, vGeoRight[i], WIN_TANG_END, false)
end
else -- full
local b3Profile = GetProfileLocalBox( vNextProfileId[i])
nCrvId = EgtCopyGlob( abs( vNextOutlineId[i]), nGrpTmp)
local dOffs = b3Profile:getMax():getX()
if vNextOutlineId[i] < 0 then
EgtInvertCurve( nCrvId)
dOffs = - b3Profile:getMin():getX()
end
EgtOffsetCurve( nCrvId, dOffs)
CopyInfo( nCrvId, vGeoRight[i], WIN_TANG_START, false)
CopyInfo( nCrvId, vGeoRight[i], WIN_TANG_END, false)
end
EgtRelocateGlob( nCrvId, nInId, GDB_IN.BEFORE)
end
end
local vIds = EgtGetAllInGroup( nGrpTmp)
nAreaId = CalcGeoRegion( vIds, nPreviewGrp)
EgtErase( nGrpTmp)
end
-- se pezzo scompare
if not nAreaId then
return
end
-- sistemo la regione
local nParentAreaId = EgtGetParent( EgtGetParent( nOutlineId))
local nAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i')
if nAreaType == WIN_AREATYPES.SASH then
-- se anta traslazione per gestire meglio i casi di telaio e ante allineati
EgtMove( nAreaId, Vector3d( 0, 0, - 0.1))
-- se anta con parte ricevente traslazione per evitare sovrapposizione con parte battente
local nSashType = EgtGetInfo( nParentAreaId, WIN_SASHTYPE, 'i')
if nSashType == WIN_SASHTYPES.INACTIVE or nSashType == WIN_SASHTYPES.INACTIVE_IN or nSashType == WIN_SASHTYPES.ACTIVE_OUT then
EgtMove( nAreaId, Vector3d( 0, 0, - 0.1))
elseif nSashType == WIN_SASHTYPES.INACTIVE_OUT then
EgtMove( nAreaId, Vector3d( 0, 0, - 0.2))
end
end
local color = EgtGetColor( nPartId)
EgtSetColor( nAreaId, color)
-- estraggo il contorno
local nCompoId = EgtExtractSurfFrChunkLoops( nAreaId, 0, nPreviewGrp)
EgtSetColor( nCompoId, EgtStdColor( 'BLACK'))
-- 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, nGeoLayerId, 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 CalcThresholdPreview( nAreaId, nPreviewGrp)
-- recupero il bottom del telaio
local nOutlineGrpId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
local nBottomId = EgtGetFirstNameInGroup( nOutlineGrpId, WIN_BOTTOM)
local nProfileId = GetOutlineProfileId( nBottomId, false)
local b3Profile = GetProfileLocalBox( nProfileId)
-- creo il rettangolo della soglia e lo posiziono sullo sfondo
local ptOrig = EgtSP( nBottomId)
local nSurfId = EgtSurfFrRectangle( nPreviewGrp, ptOrig, ptOrig + EgtCurveLength( nBottomId) * X_AX() + b3Profile:getDimX() * Y_AX())
EgtSetColor( nSurfId, Color3d( 128, 128, 128))
EgtMove( nSurfId, - 500 * Z_AX())
local nCompoId = EgtExtractSurfFrChunkLoops( nSurfId, 0, nPreviewGrp)
EgtSetColor( nCompoId, EgtStdColor( 'BLACK'))
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 nSplitType = EgtGetInfo( nAreaId, 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
-- preview soglia
local nOutlineGrpId = EgtGetFirstNameInGroup( nFrameId, WIN_OUTLINE)
local nBottomId = EgtGetFirstNameInGroup( nOutlineGrpId, WIN_BOTTOM)
local bThreshold = EgtGetInfo( nBottomId, WIN_THRESHOLD, 'b') or false
if bThreshold then
CalcThresholdPreview( nFrameId, nPreviewGrp)
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)
SetAreaProfiles( 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
---------------------------------------------------------------------
return WinCalculate
Reference in New Issue View Git Blame Copy Permalink