-- -- EEEEEEEEEE GGGGGG TTTTTTTTTTTTTT -- EEEEEEEEEE GGGGGGGGGG TTTTTTTTTTTTTT -- EEEE GGGG GGGG TTTT -- EEEE GGGG TTTT -- EEEEEEE GGGG GGGGGGG TTTT -- EEEEEEE GGGG GGGGGGG TTTT -- EEEE GGGG GGGG TTTT -- EEEE GGGG GGGG TTTT -- EEEEEEEEEE GGGGGGGGGG TTTT -- EEEEEEEEEE GGGGGG TTTT -- -- by Egalware s.r.l. -- Window project software by Egalware s.r.l. 2023/05/02 -- Tabella per definizione modulo local WinCalculate = {} -- Include require( 'EgtBase') require( 'WinConst') local s_dDowelTol = 1 local s_dSimplSolidApprox = 0.2 -- approssimazione lineare nel caso di solidi semplificati local s_nSashNbr = 0 -- contatore delle ante per assegnare nomi local s_bCalcSolid = false function WinCalculate.GetCalcSolid() return s_bCalcSolid end function WinCalculate.SetCalcSolid( bValue) s_bCalcSolid = bValue end local s_bSimplSolid = false function WinCalculate.SetSimplifiedSolid( bValue) s_bSimplSolid = bValue end local s_bCalcPreview = false function WinCalculate.SetCalcPreview( bValue) s_bCalcPreview = bValue end local s_bCalcHardwareKit = false function WinCalculate.SetCalcHardwareKit( bValue) s_bCalcHardwareKit = bValue end local s_bCalcHardwarePosition = false function WinCalculate.SetCalcHardwarePosition( bValue) s_bCalcHardwarePosition = bValue end local OutputKitList = {} local OutputPositionList = {} --------------------------------------------------------------------- -- 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 punto di intersezione fra due curve eventualmente estendendole local function FindIntersectionPoint( nCrv1, nCrv2, ptRef) local ptInt -- se archi, cerco intersezioni tra le circonferenze if EgtGetType( nCrv1) == GDB_TY.CRV_ARC and EgtGetType( nCrv2) == GDB_TY.CRV_ARC then -- trovo intersezione tra le due circonferenze local nCircle1 = EgtCircle( GDB_ID.ROOT, EgtCP( nCrv1), EgtArcRadius( nCrv1)) local nCircle2 = EgtCircle( GDB_ID.ROOT, EgtCP( nCrv2), EgtArcRadius( nCrv2)) ptInt = EgtIP( nCircle1, nCircle2, ptRef) EgtModifyCurveStartPoint( nCrv1, ptInt) EgtModifyCurveEndPoint( nCrv2, ptInt) EgtErase( nCircle1) EgtErase( nCircle2) elseif EgtGetType( nCrv1) == GDB_TY.CRV_ARC or EgtGetType( nCrv2) == GDB_TY.CRV_ARC then local nLine = EgtIf( EgtGetType( nCrv1) == GDB_TY.CRV_LINE, nCrv1, nCrv2) local nArc = EgtIf( nLine == nCrv1, nCrv2, nCrv1) -- creo circonferenza corrispondente all'arco local nCircle = EgtCircle( GDB_ID.ROOT, EgtCP( nArc), EgtArcRadius( nArc)) -- prolungo la linea dal lato opportuno local dDist1 = dist( EgtSP( nLine), ptRef) local dDist2 = dist( EgtEP( nLine), ptRef) if dDist1 < dDist2 then EgtExtendCurveStartByLen( nLine, 10000) else EgtExtendCurveEndByLen( nLine, 10000) end -- trovo le intersezioni tra retta e circonferenza local nId1, nPoints = EgtCurveCurveInters( nCircle, nLine, GDB_ID.ROOT) if nPoints == 1 then ptInt = EgtSP( nId1) EgtErase( nId1) else -- conservo quello più vicino al punto di riferimento local ptInt1 = EgtSP( nId1) local ptInt2 = EgtSP( nId1 + 1) local ptNewRef = EgtIf( nArc == nCrv2, EgtEP( nArc), EgtSP( nArc)) local dDist1 = dist( ptNewRef, ptInt1) local dDist2 = dist( ptNewRef, ptInt2) if dDist1 < dDist2 + GEO.EPS_SMALL then ptInt = ptInt1 else ptInt = ptInt2 end EgtErase( nId1) EgtErase( nId1 + 1) end EgtErase( nCircle) -- allungo l'arco per arrivare al punto di intersezione if nArc == nCrv2 then EgtModifyCurveEndPoint( nArc, ptInt) else EgtModifyCurveStartPoint( nArc, ptInt) end else ptInt = EgtIP( nCrv1, nCrv2, ORIG()) if not ptInt then -- tento estendendo le curve EgtExtendCurveStartByLen( nCrv1, 10000) EgtExtendCurveEndByLen( nCrv1, 10000) EgtExtendCurveStartByLen( nCrv2, 10000) EgtExtendCurveEndByLen( nCrv2, 10000) ptInt = EgtIP( nCrv1, nCrv2, ORIG()) end end return ptInt end --------------------------------------------------------------------- -- funzione che data una lista di curve ordinate che creano una curva chiusa, -- ne estende/taglia i contorni per ottenere una curva chiusa continua local function TrimAndOrientOrderedCurves( vCrvs, bOrient) local IntersCurveList = {} local LastCurveInters -- ciclo sulle curve per ottenere lista intersezioni for i = 1, #vCrvs do -- recupero la precedente local nPrevIndex = EgtIf( i == 1, #vCrvs, i - 1) -- calcolo intersezione local ptInters = FindIntersectionPoint( vCrvs[i], vCrvs[ nPrevIndex], EgtSP( vCrvs[i])) if LastCurveInters then LastCurveInters.EndInters = Point3d( ptInters) end local NewCurveInters = { CurveId = vCrvs[i], StartInters = Point3d( ptInters)} table.insert( IntersCurveList, NewCurveInters) LastCurveInters = NewCurveInters end IntersCurveList[#IntersCurveList].EndInters = IntersCurveList[1].StartInters -- ciclo per tagliare ed orientare for nIntersCurveIndex = 1, #IntersCurveList do local CurveInters = IntersCurveList[nIntersCurveIndex] local dStartParam = EgtCurveParamAtPoint( CurveInters.CurveId, CurveInters.StartInters, 100 * GEO.EPS_SMALL) local dEndParam = EgtCurveParamAtPoint( CurveInters.CurveId, CurveInters.EndInters, 100 * GEO.EPS_SMALL) EgtTrimCurveStartEndAtParam( CurveInters.CurveId, min( dStartParam, dEndParam), max( dStartParam, dEndParam)) if bOrient and dStartParam > dEndParam then EgtInvertCurve( CurveInters.CurveId) end end end --------------------------------------------------------------------- local function TrimSplitWithOutline( nSplitId) -- estendo agli estremi ( TO DO : gestire caso di split non lineare) EgtExtendCurveStartByLen( nSplitId, 50) EgtExtendCurveEndByLen( nSplitId, 50) -- lo taglio con outline local nStartIntersId = EgtGetInfo( nSplitId, WIN_SPLIT_STARTINTERS, 'i') local nOutlineId = EgtGetInfo( nStartIntersId, WIN_COPY, 'i') local ptStartInters = EgtIP( nSplitId, nOutlineId, EgtSP( nSplitId)) local dStartInters = EgtCurveParamAtPoint( nSplitId, ptStartInters) EgtTrimCurveStartAtParam( nSplitId, dStartInters) local nEndIntersId = EgtGetInfo( nSplitId, WIN_SPLIT_ENDINTERS, 'i') nOutlineId = EgtGetInfo( nEndIntersId, WIN_COPY, 'i') local ptEndInters = EgtIP( nSplitId, nOutlineId, EgtSP( nSplitId)) local dEndInters = EgtCurveParamAtPoint( nSplitId, ptEndInters) EgtTrimCurveEndAtParam( nSplitId, dEndInters) end --------------------------------------------------------------------- -- funzione che data una curva di outline restituisce l'id del suo profilo local function GetOutlineProfileId( nOutlineId, bForceBottomRail, nProfileType) -- ciclo fino a trovare il primo parent che abbia un AreaType definito ( frame o sash) local nParentId = EgtGetParent( nOutlineId) local nAreaType = WIN_AREATYPES.NULL while nParentId and ( nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL) do nParentId = EgtGetParent( nParentId) nAreaType = EgtGetInfo( nParentId or GDB_ID.NULL, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL end -- recupero il gruppo contenente il profilo local nProfilesGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) local nLayerId if nAreaType == WIN_AREATYPES.FRAME then nLayerId = EgtGetFirstNameInGroup( nProfilesGrpId, WIN_FRAME) elseif nAreaType == WIN_AREATYPES.SASH then nLayerId = EgtGetFirstNameInGroup( nProfilesGrpId, WIN_SASH) end -- recupero il nome del profilo local sProfileName = EgtGetInfo( nOutlineId, WIN_PROFILETYPE) -- controlli per bottomrail if EgtGetName( nOutlineId) == WIN_BOTTOM and bForceBottomRail then local nBottomRailTot = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or 0 if nBottomRailTot > 0 then sProfileName = WIN_FILL_RAIL end elseif nProfileType == WIN_PRF.BOTTOMRAIL then sProfileName = WIN_RAIL elseif nProfileType == WIN_PRF.BOTTOMRAIL_FINAL then sProfileName = WIN_FILL_RAIL end -- recupero il profilo return EgtGetFirstNameInGroup( nLayerId, sProfileName) end --------------------------------------------------------------------- -- funzione che recupera il pezzo associato ad un outline local function FindAssociatedPart( nOutlineId, bUseBottomRail) local nCrvId = nOutlineId local nPartId = EgtGetInfo( nCrvId, WIN_REF_PART, 'i') if not nPartId then -- cerco la prima curva da cui deriva che ha un pezzo associato local nBaseOutline = EgtGetInfo( nOutlineId, WIN_COPY, 'i') while not nPartId do -- recupero il base outline da cui deriva nBaseOutline = EgtGetInfo( nBaseOutline, WIN_SOU, 'i') -- verifico se ha un profilo associato ( e quindi un pezzo) local sProfileType = EgtGetInfo( nBaseOutline, WIN_PROFILETYPE) if sProfileType then -- recupero l'outline associato nCrvId = EgtGetInfo( nBaseOutline, WIN_COPY, 'i') nPartId = EgtGetInfo( nCrvId, WIN_REF_PART, 'i') end end end -- se serve bottomrail verifico se presente if bUseBottomRail then local vBottomRailParts = EgtGetInfo( nCrvId, WIN_REF_BOTTOMRAIL_PART, 'vi') if vBottomRailParts then nPartId = vBottomRailParts[#vBottomRailParts] end end return nPartId end --------------------------------------------------------------------- -- funzione che calcola il box di un profilo ( guardando la sua curva Ref) rispetto al suo frame local function GetProfileLocalBox( nProfileId) -- recupero il frame del profilo local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) local frFrame = EgtFR( nFrameId, GDB_ID.ROOT) -- recupero il Ref del profilo e ne calcolo il box local nRefId = EgtGetFirstNameInGroup( nProfileId, WIN_REF) local b3Box = EgtGetBBoxRef( nRefId, GDB_BB.STANDARD, frFrame, GDB_RT.GLOB) return b3Box end ---------------------------------------------------------------------------------- ----------------------------- CALCOLO DEI PROFILI ------------------------------ ---------------------------------------------------------------------------------- -- funzione che restituisce il primo tipo di area definito tra le sottoaree che si generano da nAreaId local function GetAreaChildrenType( nAreaId) local vStack = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*') or {} local i = 1 while vStack[i] do local nType = EgtGetInfo( vStack[i], WIN_AREATYPE, 'i') -- appena trovo un tipo definito esco if nType == WIN_AREATYPES.FILL then return WIN_CHILDREN_TYPES.FILL elseif nType == WIN_AREATYPES.SASH then return WIN_CHILDREN_TYPES.SASH else -- altrimenti analizzo le sottoaree local vSubAreas = EgtGetNameInGroup( vStack[i], WIN_AREA .. '*') or {} vStack = EgtJoinTables( vStack, vSubAreas) end i = i + 1 end -- se non trovo un tipo definito return WIN_CHILDREN_TYPES.NULL end --------------------------------------------------------------------- local function GetClosestAreaChildrenType( nAreaId) local nChildrenType = WIN_CHILDREN_TYPES.NULL local nType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') while nChildrenType == WIN_CHILDREN_TYPES.NULL and nType ~= WIN_AREATYPES.FRAME do nAreaId = EgtGetParent( nAreaId) nType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') nChildrenType = GetAreaChildrenType( nAreaId) end return nChildrenType end --------------------------------------------------------------------- -- funzione che verifica la tipologia delle curve figlie di una curva local function GetChildrenType( nCrvId) local vStack = EgtGetInfo( nCrvId, WIN_CHILD, 'vi') or {} local i = 1 local vFillChildren = {} local vSashChildren = {} while vStack[i] do -- verifico se la sua area è di tipo sash o fill local nAreaId = EgtGetParent( EgtGetParent( vStack[i])) local nType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') if nType == WIN_AREATYPES.FILL then table.insert( vFillChildren, vStack[i]) elseif nType == WIN_AREATYPES.SASH then table.insert( vSashChildren, vStack[i]) else -- recupero i suoi figli local vChildren = EgtGetInfo( vStack[i], WIN_CHILD, 'vi') or {} if #vChildren == 0 then -- se non ha figli, per non creare problemi nel caso di cambio profilo ( in cui è necessario conoscere la struttura completa), -- assegno come tipologia quella dell'area più "vicina" nella struttura delle aree local nCurrType = GetClosestAreaChildrenType( nAreaId) if nCurrType == WIN_CHILDREN_TYPES.FILL then table.insert( vFillChildren, vStack[i]) elseif nCurrType == WIN_CHILDREN_TYPES.SASH then table.insert( vSashChildren, vStack[i]) end end -- aggiungo i suoi figli tra gli elementi da analizzare vStack = EgtJoinTables( vStack, vChildren) end -- aggiorno il contatore i = i + 1 end -- salvo i figli individuati come info della curva EgtSetInfo( nCrvId, WIN_SASH_CHILDREN, vSashChildren) EgtSetInfo( nCrvId, WIN_FILL_CHILDREN, vFillChildren) if #vFillChildren > 0 and #vSashChildren > 0 then return WIN_CHILDREN_TYPES.MIXED -- cambio profilo elseif #vFillChildren > 0 then return WIN_CHILDREN_TYPES.FILL elseif #vSashChildren > 0 then return WIN_CHILDREN_TYPES.SASH else return WIN_CHILDREN_TYPES.NULL end end --------------------------------------------------------------------- -- funzione che identifica il tipo di split ( null, mullion, french, mixed) local function GetSplitType( nSplitLayerId) local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') -- se non ha split specifico impostato verifico se ha sash prima o dopo per capire se è di tipo mullion if not nSplitType or nSplitType == WIN_SPLITTYPES.NULL then local nParentAreaId = EgtGetParent( nSplitLayerId) local nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL while nParentAreaId and nParentAreaType ~= WIN_AREATYPES.SASH do nParentAreaId = EgtGetParent( nParentAreaId) nParentAreaType = EgtGetInfo( nParentAreaId or GDB_ID.NULL, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL end -- se dentro anta è di tipo null, se non è dentro anta devo verificare le tipologie dei figli if not nParentAreaId or nParentAreaType ~= WIN_AREATYPES.SASH then local nSplitId = EgtGetFirstInGroup( nSplitLayerId) local nChildrenType = GetChildrenType( nSplitId) if nChildrenType == WIN_CHILDREN_TYPES.MIXED then nSplitType = WIN_SPLITTYPES.MIXED elseif nChildrenType == WIN_CHILDREN_TYPES.SASH or nChildrenType == WIN_CHILDREN_TYPES.NULL then nSplitType = WIN_SPLITTYPES.MULLION end end end if not nSplitType then nSplitType = WIN_SPLITTYPES.NULL end EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, nSplitType) return nSplitType end --------------------------------------------------------------------- -- funzione che imposta i tipi di profilo per gli split local function CalcSplitProfileType( nSplitLayerId, nAreaId) local nSplitId = EgtGetFirstInGroup( nSplitLayerId) -- verifico il tipo di split local nSplitType = GetSplitType( nSplitLayerId) if nSplitType == WIN_SPLITTYPES.MULLION then -- verifico direzione per dare nome local vtMedia = ( ( EgtEV( nSplitId) - EgtSV( nSplitId)) / 2) if not vtMedia:normalize() then vtMedia = EgtSV( nSplitId) end if abs( vtMedia:getX()) > abs( vtMedia:getY()) then EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_HORIZONTAL) else EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_VERTICAL) end elseif nSplitType == WIN_SPLITTYPES.NULL then -- verifico se interno ad anta o a frame local nParentAreaId = 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 -- assegno tipo di profilo allo split if nParentAreaType == WIN_AREATYPES.SASH then EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_SPLIT) else EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_FRAME_SPLIT) end elseif nSplitType == WIN_SPLITTYPES.MIXED then EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_MIXED_SPLIT) EgtSetInfo( nSplitId, 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( nSplitId, WIN_SASH_CHILDREN, 'i') local nRefCrv = EgtGetNext( nSashChild) or EgtGetPrev( nSashChild) local _, _, nSide = EgtPointCurveDistSide( EgtMP( nRefCrv), nSplitId, Z_AX()) -- se si trova a destra, lo split va invertito if nSide == 1 then EgtInvertCurve( nSplitId) -- scambio le info di intersezione local vStartInters = EgtGetInfo( nSplitId, WIN_SPLIT_STARTINTERS, 'vi') local vEndInters = EgtGetInfo( nSplitId, WIN_SPLIT_ENDINTERS, 'vi') EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, vEndInters) EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, vStartInters) end end -- se split di tipo french non ha profilo assegnato perchè non ha un pezzo associato end --------------------------------------------------------------------- local function FindAdjacentSashType( nSplitId, nSouId) -- recupero l'altro child dello split local vSplitChildren = EgtGetInfo( nSplitId, WIN_CHILD, 'vi') local vChildren = EgtIf( vSplitChildren[1] == nSouId, {vSplitChildren[2]}, {vSplitChildren[1]}) -- cerco il suo primo figlio di tipo sash local nAreaType local nArea repeat vChildren = EgtGetInfo( vChildren[1], WIN_CHILD, 'vi') if vChildren then nArea = EgtGetParent( EgtGetParent( vChildren[1])) nAreaType = EgtGetInfo( nArea or GDB_ID.NULL, WIN_AREATYPE, 'i') end until not vChildren or nAreaType == WIN_AREATYPES.SASH -- recupero il sash type local nSashType = EgtGetInfo( nArea or GDB_ID.NULL, WIN_SASHTYPE, 'i') return nSashType end --------------------------------------------------------------------- -- funzione che imposta i tipi di profilo in base al tipo di pezzi local function CalcProfileType( nAreaId) local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') -- FRAME if nAreaType == WIN_AREATYPES.FRAME then -- gestione soglia local sThreshold = EgtGetInfo( nAreaId, WIN_THRESHOLD_PROFILE) or WIN_BOTTOM local bThreshold = ( sThreshold == WIN_THRESHOLD) -- assegno il profilo alle curve di outline local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) while nOutlineId do local sName = EgtGetName( nOutlineId) -- recupero il tipo dei figli local nChildrenType = GetChildrenType( nOutlineId) -- a) se non definiti gestisco come anta o fixed if nChildrenType == WIN_CHILDREN_TYPES.NULL then local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0 if nBottomRail > 0 then -- se bottomrail gestisco come fixed bThreshold = false if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL .. '_' .. sThreshold) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_TOP) end else -- se no bottomrail gestisco come anta if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH .. '_' .. sThreshold) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_TOP) end end -- b) se anta elseif nChildrenType == WIN_CHILDREN_TYPES.SASH then EgtRemoveInfo( nAreaId, WIN_BOTTOMRAIL) -- verifico tipologia di anta contro cui poggia local vChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi') local nSashArea = EgtGetParent( EgtGetParent( vChildren[1])) local nSashType = EgtGetInfo( nSashArea, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL -- b1) alzante scorrevole if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE or nSashType == WIN_SASHTYPES.SLIDE_FIXED or nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then EgtSetInfo( nAreaId, WIN_SLIDE_WINDOW, true) if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE .. '_' .. sThreshold) -- se le ante contro cui poggia sono tutte mobili devo aggiornare il profilo if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK .. '_' .. sThreshold) elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then for i = 2, #vChildren do local nSashArea = EgtGetParent( EgtGetParent( vChildren[i])) local nSashType = EgtGetInfo( nSashArea, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK .. '_' .. sThreshold) break elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then break end end end elseif sName == WIN_TOP then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_TOP) else if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED) end end -- b2) standard else if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH .. '_' .. sThreshold) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_TOP) end end -- c) se riempimento elseif nChildrenType == WIN_CHILDREN_TYPES.FILL then bThreshold = false if sName == WIN_BOTTOM then -- verifico presenza bottomrail local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0 if nBottomRail == 0 then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED .. '_' .. sThreshold) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL .. '_' .. sThreshold) end else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_TOP) end -- d) se cambio profilo elseif nChildrenType == WIN_CHILDREN_TYPES.MIXED then EgtRemoveInfo( nAreaId, WIN_BOTTOMRAIL) bThreshold = false EgtSetInfo( nOutlineId, WIN_PRF_CHANGE, true) if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_MIXED_BOTTOM) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_MIXED_TOP) end end nOutlineId = EgtGetNext( nOutlineId) end -- assegno info soglia if bThreshold then EgtSetInfo( nAreaId, WIN_THRESHOLD, true) end -- verifico se ci sono split e ne assegno il profilo local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) if nSplitLayerId then CalcSplitProfileType( nSplitLayerId, nAreaId) end -- SPLIT elseif nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then -- verifico se ci sono split e ne assegno il profilo local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) if nSplitLayerId then CalcSplitProfileType( nSplitLayerId, nAreaId) end -- SASH elseif nAreaType == WIN_AREATYPES.SASH then -- verifico tipologia di anta ( battente, ricevente, alzante scorrevole) local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL -- verifico se bottomrail local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0 -- imposto profili sash local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) while nOutlineId do local sName = EgtGetName( nOutlineId) -- se non è definita tipologia if nSashType == WIN_SASHTYPES.NULL then if sName == WIN_BOTTOM then if nBottomRail == 0 then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL_BOTTOM) end else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) end else -- verifico se deriva da una curva di split di tipo french ( e quindi deve avere profilo speciale e.g. battente/ricevente) local nSouId = EgtGetInfo( nOutlineId, WIN_SOU, 'i') local nSouPrevId local nSplitType repeat nSouPrevId = nSouId nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') if nSouId then local sName = EgtGetName( nSouId) if sName == WIN_SPLIT then local nParentId = EgtGetParent( nSouId) nSplitType = EgtGetInfo( nParentId, WIN_SPLITTYPE, 'i') end end until not nSouId or nSplitType == WIN_SPLITTYPES.FRENCH if nSplitType == WIN_SPLITTYPES.FRENCH then -- setto info sulla curva per ricordare che deriva da un french split ( utile nel calcolo degli outlines) EgtSetInfo( nOutlineId, WIN_CRV_ON_FRENCH_SPLIT, true) -- a) battente/ricevente if nSashType == WIN_SASHTYPES.ACTIVE then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE) elseif nSashType == WIN_SASHTYPES.INACTIVE then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_INACTIVE) elseif nSashType == WIN_SASHTYPES.ACTIVE_OUT or nSashType == WIN_SASHTYPES.INACTIVE_OUT then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_OUT) elseif nSashType == WIN_SASHTYPES.ACTIVE_IN or nSashType == WIN_SASHTYPES.INACTIVE_IN then -- devo verificare il tipo dell'anta adiacente local nAdjSashType = FindAdjacentSashType( nSouId, nSouPrevId) if nSashType == WIN_SASHTYPES.ACTIVE_IN then if nAdjSashType == WIN_SASHTYPES.ACTIVE_OUT then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_IN) else -- adiacente è inactive EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE) end elseif nSashType == WIN_SASHTYPES.INACTIVE_IN then if nAdjSashType == WIN_SASHTYPES.INACTIVE_OUT then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_IN) else -- adiacente è active EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_INACTIVE) end end -- b) alzante scorrevole elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then local nAdjSashType = FindAdjacentSashType( nSouId, nSouPrevId) if nAdjSashType == WIN_SASHTYPES.SLIDE_MOVABLE then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_ACTIVE_IN) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_ACTIVE) end elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_INACTIVE) elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_INACTIVE) end else -- a) alzante scorrevole if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_BOTTOM) elseif sName == WIN_TOP then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_TOP) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_SIDE) end elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_BOTTOM) elseif sName == WIN_TOP then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_TOP) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_SIDE) end elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_BOTTOM) elseif sName == WIN_TOP then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_TOP) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_SIDE) end -- b) standard else if sName == WIN_BOTTOM then -- verifico se bottomrail if nBottomRail == 0 then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL_BOTTOM) end else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) end end end end nOutlineId = EgtGetNext( nOutlineId) end -- verifico se ci sono split local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) if nSplitLayerId then -- assegno tipo di profilo local nSplitId = EgtGetFirstInGroup( nSplitLayerId) EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_SPLIT) end end end --------------------------------------------------------------------- -- funzione che cicla ricorsivamente su aree e sottoaree per impostare i tipi di profilo local function CalculateAreaProfileType( nAreaId) -- calcolo i profili per l'area corrente CalcProfileType( nAreaId) -- calcolo i profili per le eventuali sottoaree local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') while nChildAreaId do CalculateAreaProfileType( nChildAreaId) nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*') end end ---------------------------------------------------------------------------------- ------------------------------ CALCOLO OUTLINE --------------------------------- ---------------------------------------------------------------------------------- -- funzione che calcola l'outline dall'area outline ( base outline) local function CalculateOutlineFromAreaOutline( nAreaId) local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') -- recupero il base outline e creo gruppo per outline local nAreaOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) local nOutlineLayerId = EgtGroup( nAreaId) EgtSetName( nOutlineLayerId, WIN_OUTLINE) EgtSetStatus( nOutlineLayerId, GDB_ST.OFF) CopyInfo( nOutlineLayerId, nAreaOutlineLayerId, WIN_JOINTS) -- FRAME if nAreaType == WIN_AREATYPES.FRAME then -- sistemo le info local nAreaOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId) while nAreaOutlineId do local nOutlineId = EgtCopyGlob( nAreaOutlineId, nOutlineLayerId) EgtSetInfo( nAreaOutlineId, WIN_COPY, nOutlineId) EgtSetInfo( nOutlineId, WIN_COPY, nAreaOutlineId) -- se bottom riporto informazione dei bottomrail e soglia if EgtGetName( nOutlineId) == WIN_BOTTOM then CopyInfo( nOutlineId, nAreaId, WIN_BOTTOMRAIL) CopyInfo( nOutlineId, nAreaId, WIN_THRESHOLD) end nAreaOutlineId = EgtGetNext( nAreaOutlineId) end -- se presente, copio split local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) if nBaseSplitLayerId then local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId) EgtSetName( nSplitLayerId, WIN_SPLIT) EgtSetStatus( nSplitLayerId, GDB_ST.OFF) local nBaseSplitId = EgtGetFirstInGroup( nBaseSplitLayerId) local nSplitId = EgtGetFirstInGroup( nSplitLayerId) EgtSetInfo( nBaseSplitId, WIN_COPY, nSplitId) EgtSetInfo( nSplitId, WIN_COPY, nBaseSplitId) end -- SPLIT elseif nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then -- recupero outline di livello precedente e lo copio pezzo per pezzo local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId) while nBaseOutlineId do -- recupero la curva di outline corrispondente alla curva del base outline da cui deriva e la copio local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) -- se deriva da split devo aggiornare il nome e setto il riferimento local sSouName = EgtGetName( nSouId) if sSouName == WIN_SPLIT then local sBaseName = EgtGetName( nBaseOutlineId) EgtSetName( nOutlineId, sBaseName) EgtSetInfo( nOutlineId, WIN_REF_SPLIT, nSouId) end -- sistemo le info EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId) EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId) EgtRemoveInfo( nOutlineId, WIN_CHILD) nBaseOutlineId = EgtGetNext( nBaseOutlineId) end -- taglio tutti i contorni TrimAndOrientOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true) -- se presente, copio split local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) if nBaseSplitLayerId then local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId) EgtSetName( nSplitLayerId, WIN_SPLIT) EgtSetStatus( nSplitLayerId, GDB_ST.OFF) local nBaseSplitId = EgtGetFirstInGroup( nBaseSplitLayerId) local nSplitId = EgtGetFirstInGroup( nSplitLayerId) EgtSetInfo( nBaseSplitId, WIN_COPY, nSplitId) EgtSetInfo( nSplitId, WIN_COPY, nBaseSplitId) EgtRemoveInfo( nSplitId, WIN_SOU) -- lo taglio con outline TrimSplitWithOutline( nSplitId) -- recupero tipo di profilo local sSplitProfile = EgtGetInfo( nSplitId, WIN_PROFILETYPE) -- se split interno ad anta devo alzarlo in z come l'anta che lo contiene if sSplitProfile == WIN_SASH_SPLIT then -- recupero l'anta local nSashAreaId = EgtGetParent( nAreaId) local nAreaType = EgtGetInfo( nSashAreaId, WIN_AREATYPE, 'i') while nAreaType ~= WIN_AREATYPES.SASH do nSashAreaId = EgtGetParent( nSashAreaId) nAreaType = EgtGetInfo( nSashAreaId, WIN_AREATYPE, 'i') end local nSashBaseOutlineLayerId = EgtGetFirstNameInGroup( nSashAreaId, WIN_AREAOUTLINE) local nSashBaseOutlineId = EgtGetFirstInGroup( nSashBaseOutlineLayerId) -- recupero il profilo dell'anta local sSashProfile = EgtGetInfo( nSashBaseOutlineId, WIN_PROFILETYPE) local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH) local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile) -- calcolo offset sulla z dell'anta local dSashZOffset = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd') -- sposto Split in Z EgtMove( nSplitId, Z_AX() * dSashZOffset) end end -- SASH elseif nAreaType == WIN_AREATYPES.SASH then -- recupero se anta battente ricevente local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL -- recupero gruppo profili anta e telaio local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH) local nFrameProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_FRAME) -- ciclo su profilo disegnato anta local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId) while nBaseOutlineId do -- recupero la curva di outline del base outline da cui deriva e la copio local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) -- recupero profilo local sSashProfile = EgtGetInfo( nBaseOutlineId, WIN_PROFILETYPE) local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile) -- calcolo offset sulla z dell'anta local dSashZOffset = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd') -- sposto anta in Z EgtMove( nOutlineId, Z_AX() * dSashZOffset) -- sistemo le info EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId) EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId) EgtSetInfo( nOutlineId, WIN_PROFILETYPE, sSashProfile) if EgtGetName( nOutlineId) == WIN_BOTTOM then CopyInfo( nOutlineId, nAreaId, WIN_BOTTOMRAIL) end EgtRemoveInfo( nOutlineId, WIN_PRF_CHANGE) EgtRemoveInfo( nOutlineId, WIN_REF_SPLIT) EgtRemoveInfo( nOutlineId, WIN_THRESHOLD) -- verifico se outline e' segmento battente o ricevente ( che quindi deriva da split di tipo french) local bOnFrenchSplit = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b') or false -- se outline non è segmento battente o ricevente necessita di offset if not bOnFrenchSplit then -- recupero a ritroso il profilo dell'elemento del frame su cui poggia local nFrameBaseOutlineId = nSouId local sFrameProfile = EgtGetInfo( nFrameBaseOutlineId, WIN_PROFILETYPE) while not sFrameProfile and nFrameBaseOutlineId do nFrameBaseOutlineId = EgtGetInfo( nFrameBaseOutlineId, WIN_SOU , 'i') sFrameProfile = EgtGetInfo( nFrameBaseOutlineId or GDB_ID.NULL, WIN_PROFILETYPE) end local nFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileLayerId, sFrameProfile) -- calcolo il box del riferimento del profilo del frame local b3FrameProfile = GetProfileLocalBox( nFrameProfileId) -- calcolo offset perpendicolare local sOverlapInfo = EgtIf( EgtGetName( nOutlineId) == WIN_BOTTOM, WIN_SASH_BOTTOM_OVERLAP, WIN_SASH_TOP_OVERLAP) local dOverlap = EgtGetInfo( nFrameProfileId, sOverlapInfo, 'd') local dSashPerpOffset = abs( b3FrameProfile:getMin():getX()) - dOverlap -- faccio offset EgtOffsetCurve( nOutlineId, - dSashPerpOffset) end nBaseOutlineId = EgtGetNext( nBaseOutlineId) end -- accorcio gli offset TrimAndOrientOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true) -- se presente, copio split local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) if nBaseSplitLayerId then local nBaseSplitId = EgtGetFirstInGroup( nBaseSplitLayerId) -- creo copia local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId) EgtSetName( nSplitLayerId, WIN_SPLIT) EgtSetStatus( nSplitLayerId, GDB_ST.OFF) local nSplitId = EgtGetFirstInGroup( nSplitLayerId) EgtSetInfo( nBaseSplitId, WIN_COPY, nSplitId) EgtSetInfo( nSplitId, WIN_COPY, nBaseSplitId) EgtRemoveInfo( nSplitId, WIN_SOU) -- la taglio con outline TrimSplitWithOutline( nSplitId) -- calcolo offset sulla z dal profilo dell'anta local nPrevId = EgtGetInfo( nBaseSplitId, WIN_SPLIT_STARTINTERS, 'i') local sSashProfile = EgtGetInfo( nPrevId, WIN_PROFILETYPE) local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile) local dSplitZOffset = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd') -- sposto split in Z EgtMove( nSplitId, Z_AX() * dSplitZOffset) end -- FILL elseif nAreaType == WIN_AREATYPES.FILL then -- ciclo su BaseArea riempimento local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId) while nBaseOutlineId do -- recupero la curva di outline del base outline da cui deriva e la copio local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) -- sistemo le info EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId) EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId) -- recupero a ritroso il profilo dell'elemento su cui poggia ( anta, split o frame) local nParentBaseOutlineId = nSouId local sParentProfile = EgtGetInfo( nParentBaseOutlineId, WIN_PROFILETYPE) while not sParentProfile and nParentBaseOutlineId do nParentBaseOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_SOU , 'i') sParentProfile = EgtGetInfo( nParentBaseOutlineId or GDB_ID.NULL, WIN_PROFILETYPE) end local nParentOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_COPY, 'i') local nParentProfileId = GetOutlineProfileId( nParentOutlineId, true) sParentProfile = EgtGetName( nParentProfileId) -- calcolo il box del riferimento del profilo del frame local b3FrameProfile = GetProfileLocalBox( nParentProfileId) -- calcolo offset perpendicolare e sulla z dell'anta local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd') local bMixedSplit = ( EgtGetInfo( nParentOutlineId, WIN_PRF_CHANGE, 'b') or false) and EgtGetName( nParentOutlineId) == WIN_SPLIT local dDimRef = EgtIf( bMixedSplit, b3FrameProfile:getMax():getX(), b3FrameProfile:getMin():getX()) local dFillPerpOffset = abs( dDimRef) - dOverlap if sParentProfile == WIN_FILL_RAIL then -- se bottom rail considero la distanza necessaria per il numero di bottomrail richiesti local nBottomRails = EgtGetInfo( nParentOutlineId, WIN_BOTTOMRAIL, 'i') local dRailDelta1 = EgtGetInfo( nParentProfileId, WIN_RAILDELTA .. '1', 'd') local dRailDelta2 = EgtGetInfo( nParentProfileId, WIN_RAILDELTA .. '2', 'd') dFillPerpOffset = dFillPerpOffset + dRailDelta1 + ( nBottomRails - 1) * dRailDelta2 end -- faccio offset EgtOffsetCurve( nOutlineId, - dFillPerpOffset) -- movimento in z local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd') EgtMove( nOutlineId, Z_AX() * dFillZOffset) nBaseOutlineId = EgtGetNext( nBaseOutlineId) end -- accorcio gli offset TrimAndOrientOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true) end end --------------------------------------------------------------------- -- funzione che cicla ricorsivamente su aree e sottaree per calcolare gli outlines local function CalculateAreaOutline( nAreaId) -- calcolo outlines per l'area corrente CalculateOutlineFromAreaOutline( nAreaId) -- calcolo outlines per le eventuali sottoaree local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') while nChildAreaId do CalculateAreaOutline( nChildAreaId) nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*') end end ---------------------------------------------------------------------------------- ------------------------ FUNZIONI AUX PER CALCOLO PEZZI ------------------------ ---------------------------------------------------------------------------------- -- funzione che restituisce il WIN_PRF in base al nome della curva local function GetOutlineProfileType( nOutlineId, bForceBottomRail, nBottomRail) -- ricavo tipo dal nome local sName = EgtGetName( nOutlineId) local nProfileType = WIN_PRF.NULL if sName == WIN_TOP then nProfileType = WIN_PRF.TOP elseif sName == WIN_BOTTOM then local nBottomRailTot = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or 0 if bForceBottomRail and nBottomRailTot > 0 then nProfileType = WIN_PRF.BOTTOMRAIL_FINAL elseif nBottomRail then -- verifico se bottomrail intermedio o finale if nBottomRail == nBottomRailTot then nProfileType = WIN_PRF.BOTTOMRAIL_FINAL else nProfileType = WIN_PRF.BOTTOMRAIL end else nProfileType = WIN_PRF.BOTTOM end elseif sName == WIN_LEFT then nProfileType = WIN_PRF.LEFT elseif sName == WIN_RIGHT then nProfileType = WIN_PRF.RIGHT elseif sName == WIN_SPLIT then nProfileType = WIN_PRF.SPLIT end return nProfileType end --------------------------------------------------------------------- -- funzione che calcola gli outline precedenti e successivi nel caso di split local function GetSplitOtherOutline( nSplitId, nSurfSplit, nOutlineId, bPrevOrNext) local vOutlineIds = {} -- verifico se devo controllare la curva precedente o successiva dell'outline corrente local nCrv local bPrevOutline = false local ptRef = EgtIf( bPrevOrNext, EgtSP( nSplitId), EgtEP( nSplitId)) local dPar = EgtCurveParamAtPoint( nOutlineId, ptRef) local dLenInt = EgtCurveLengthAtParam( nOutlineId, dPar) local dLenTot = EgtCurveLength( nOutlineId) -- se l'intersezione è più vicina alla fine dell'outline devo controllare il suo next, altrimenti il suo prev if abs( dLenTot - dLenInt) < dLenInt then nCrv = EgtGetNext( nOutlineId) or EgtGetFirstInGroup( EgtGetParent( nOutlineId)) else bPrevOutline = true nCrv = EgtGetPrev( nOutlineId) or EgtGetLastInGroup( EgtGetParent( nOutlineId)) end -- recupero il geo associato e costruisco superficie test local nPartId = FindAssociatedPart( nCrv, true) local nGeoId = EgtGetFirstNameInGroup( nPartId, WIN_GEO) local nGeoOut = EgtGetFirstNameInGroup( nGeoId, WIN_GEO_OUT) local nGeoIn = EgtGetFirstNameInGroup( nGeoId, WIN_GEO_IN) local nCrv1 = EgtCopyGlob( nGeoOut, nGeoId) local nCrv2 = EgtCopyGlob( nGeoIn, nGeoId) local nCompoTest = EgtCurveCompo( nGeoId, nCrv1) local dParTest = 0.2 if bPrevOutline then -- considero solo la parte finale del pezzo EgtTrimCurveStartAtParam( nCompoTest, 1 - dParTest) EgtAddCurveCompoLine( nCompoTest, EgtSP( nCrv2)) EgtTrimCurveEndAtParam( nCrv2, dParTest) else -- considero solo la parte iniziale del pezzo EgtTrimCurveEndAtParam( nCompoTest, dParTest) EgtTrimCurveStartAtParam( nCrv2, 1 - dParTest) EgtAddCurveCompoLine( nCompoTest, EgtSP( nCrv2)) end EgtAddCurveCompoCurve( nCompoTest, nCrv2) EgtCloseCurveCompo( nCompoTest) local nSurfTest = EgtSurfFlatRegion( nGeoId, { nCompoTest}) -- verifico se le due regioni interferiscono if EgtSurfFrTestExternal( nSurfSplit, nSurfTest) then vOutlineIds = { nOutlineId} else -- aggiungo la curva trovata tra le curve di outline da considerare rispettando l'ordinamento if bPrevOutline then vOutlineIds = { nCrv, nOutlineId} else vOutlineIds = { nOutlineId, nCrv} end end EgtErase( nCompoTest) EgtErase( nSurfTest) return vOutlineIds end --------------------------------------------------------------------- -- funzione che recupera gli outline precedenti e successivi local function GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) local vPrevOutlineId = {} local vNextOutlineId = {} if nProfileType ~= WIN_PRF.SPLIT then vPrevOutlineId = { EgtGetPrev( nOutlineId) or EgtGetLastInGroup( nOutlineLayerId)} vNextOutlineId = { EgtGetNext( nOutlineId) or EgtGetFirstInGroup( nOutlineLayerId)} else -- se split recupero tutte le curve di base outline che lo tagliano local vPrevBaseOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'vi') for i = 1, #vPrevBaseOutlineId do -- recupero l'outline associato al base outline che lo taglia table.insert( vPrevOutlineId, EgtGetInfo( vPrevBaseOutlineId[i], WIN_COPY, 'i')) end local vNextBaseOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'vi') for i = 1, #vNextBaseOutlineId do table.insert( vNextOutlineId, EgtGetInfo( vNextBaseOutlineId[i], WIN_COPY, 'i')) end -- se lo split è tagliato da una sola curva di base outline, verifico se coinvolge altre curve if #vPrevBaseOutlineId == 1 or #vNextBaseOutlineId == 1 then -- costruisco una regione approssimata per il pezzo dello split local nGrp = EgtGetParent( nOutlineId) local nSplitProfileId = GetOutlineProfileId( nOutlineId, false) local b3Profile = GetProfileLocalBox( nSplitProfileId) local nCrvOut = EgtCopyGlob( nOutlineId, nGrp) local nCrvIn = EgtCopyGlob( nOutlineId, nGrp) EgtOffsetCurve( nCrvOut, b3Profile:getMax():getX()) EgtOffsetCurve( nCrvIn, b3Profile:getMin():getX()) EgtInvertCurve( nCrvIn) local nCompoTest = EgtCurveCompo( nGrp, nCrvOut) EgtAddCurveCompoLine( nCompoTest, EgtSP( nCrvIn)) EgtAddCurveCompoCurve( nCompoTest, nCrvIn) EgtCloseCurveCompo( nCompoTest) local nSurfTest = EgtSurfFlatRegion( nGrp, nCompoTest) -- se necessario aggiorno il prev if #vPrevBaseOutlineId == 1 and EgtGetName( vPrevBaseOutlineId[1]) ~= WIN_SPLIT then vPrevOutlineId = GetSplitOtherOutline( nOutlineId, nSurfTest, vPrevOutlineId[1], true) end -- se necessario aggiorno il next if #vNextOutlineId == 1 and EgtGetName( vNextBaseOutlineId[1]) ~= WIN_SPLIT then vNextOutlineId = GetSplitOtherOutline( nOutlineId, nSurfTest, vNextOutlineId[1], false) end EgtErase( nSurfTest) EgtErase( nCompoTest) end end return vPrevOutlineId, vNextOutlineId end --------------------------------------------------------------------- -- funzione che restituisce il tipo di controprofilo dell'outline adiacente local function GetProfileCtrIn( nPrevOutlineId, nOutlineId, nPrevProfileId) local sPrevCtrIn = WIN_CTRIN -- gestione particolare del caso di split o cambio profilo if not EgtGetFirstNameInGroup( nPrevProfileId, sPrevCtrIn) then local nRefSplitId = EgtGetInfo( nPrevOutlineId, WIN_REF_SPLIT, 'i') if nRefSplitId or EgtGetName( nPrevOutlineId) == WIN_SPLIT then -- 1) split -- verifico da quale lato dello split originale si trova l'outline per decidere quale controprofilo considerare local _, _, nSide = EgtPointCurveDistSide( EgtMP( nOutlineId), nRefSplitId or nPrevOutlineId, Z_AX()) if nSide == 1 then sPrevCtrIn = WIN_CTRIN .. '1' -- dx else sPrevCtrIn = WIN_CTRIN .. '2' -- sx end else -- 2) pezzo del telaio con cambio profilo -- il profilo da usare dipende dal pezzo corrente: se ha figli di tipo fill allora è legato alla parte fill del cambio profilo, se ha figli di tipo sash è legato alla parte sash, -- se ha entrambe le tipologie di figli allora è mixed split e va considerata la parte sash ( perchè è quella utilizzata per tagliare il pezzo) local vSashChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi') if vSashChildren then sPrevCtrIn = WIN_SASH .. WIN_CTRIN else sPrevCtrIn = WIN_FILL .. WIN_CTRIN end end end return sPrevCtrIn end --------------------------------------------------------------------- -- funzione che crea la superficie corrispondente al Geo di un pezzo gestendo i casi di autointersezione local function CreateGeoArea( nGeoLayId, nDestLayId, bKeepBorder) -- recupero le curve left e right e verifico se hanno orientamento coerente ( quindi non generano autointersezioni) local bAutointers = false local vLeft = EgtGetNameInGroup( nGeoLayId, WIN_LEFT) local vRight = EgtGetNameInGroup( nGeoLayId, WIN_RIGHT) if #vLeft == 2 and not AreSamePointApprox( EgtEP( vLeft[1]), EgtSP( vLeft[2])) then bAutointers = true -- se orientamento non coerente devo ignorare la prima curva vLeft[1] = GDB_ID.NULL end if #vRight == 2 and not AreSamePointApprox( EgtEP( vRight[1]), EgtSP( vRight[2])) then bAutointers = true -- se orientamento non coerente devo ignorare la seconda curva vRight[2] = GDB_ID.NULL end local nCompoId if not bAutointers then -- se no autointersezioni costruisco il bordo del geo usando direttamente le sue curve local vCrvs = EgtGetAllInGroup( nGeoLayId) nCompoId = EgtCurveCompo( nDestLayId, vCrvs, false) else -- nel caso di autointersezione devo ignorare le curve left e right con orientamento non coerente local vGeoCrvs = {} local nOutId = EgtGetFirstNameInGroup( nGeoLayId, WIN_GEO_OUT) vGeoCrvs[1] = EgtCopyGlob( nOutId, nDestLayId) for i = 1, #vRight do if vRight[i] ~= GDB_ID.NULL then table.insert( vGeoCrvs, EgtCopyGlob( vRight[i], nDestLayId)) end end local nInId = EgtGetFirstNameInGroup( nGeoLayId, WIN_GEO_IN) table.insert( vGeoCrvs, EgtCopyGlob( nInId, nDestLayId)) for i = 1, #vLeft do if vLeft[i] ~= GDB_ID.NULL then table.insert( vGeoCrvs, EgtCopyGlob( vLeft[i], nDestLayId)) end end -- taglio le curve TrimAndOrientOrderedCurves( vGeoCrvs, false) -- creo compo nCompoId = EgtCurveCompo( nDestLayId, vGeoCrvs) end local nArea = EgtSurfFlatRegion( nDestLayId, nCompoId) if not bKeepBorder then EgtErase( nCompoId) end return nArea end ---------------------------------------------------------------------------------- -------------------------------- GEO ------------------------------------------- ---------------------------------------------------------------------------------- -- funzione che dato il tipo di pezzo e di giunzione, restituisce se e' corto, lungo o angolato local function CalcPartJointType( nProfileType, JointType) if JointType == WIN_JNT.ANGLED then return WIN_PART_JNT.ANGLED end if nProfileType == WIN_PRF.BOTTOMRAIL or nProfileType == WIN_PRF.BOTTOMRAIL_FINAL or nProfileType == WIN_PRF.SPLIT then return WIN_PART_JNT.SHORT elseif nProfileType == WIN_PRF.BOTTOM or nProfileType == WIN_PRF.TOP then if JointType == WIN_JNT.FULL_H then return WIN_PART_JNT.FULL elseif JointType == WIN_JNT.FULL_V then return WIN_PART_JNT.SHORT end elseif nProfileType == WIN_PRF.LEFT or nProfileType == WIN_PRF.RIGHT then if JointType == WIN_JNT.FULL_V then return WIN_PART_JNT.FULL elseif JointType == WIN_JNT.FULL_H then return WIN_PART_JNT.SHORT end end end --------------------------------------------------------------------- -- funzione che calcola e salva nel profilo il delta del bottomrail corrente rispetto alla sua curva di outline local function SaveRailDelta( nProfileId, nBottomRail) local dDelta1 = EgtGetInfo( nProfileId, WIN_RAILDELTA .. '1', 'd') local dDelta2 = EgtGetInfo( nProfileId, WIN_RAILDELTA .. '2', 'd') local dOffs = dDelta1 + ( nBottomRail - 1) * dDelta2 EgtSetInfo( nProfileId, WIN_RAILDELTA, dOffs) end --------------------------------------------------------------------- -- funzione che crea il gruppo con i profili di un pezzo local function CalcProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutlineId, nProfileType, nBottomRail) -- creo gruppo per i profili local nProfileLayerId = EgtGroup( nPartId) EgtSetName( nProfileLayerId, WIN_PROFILE) EgtSetStatus( nProfileLayerId, GDB_ST.OFF) -- recupero profilo principale e ne creo copia local nOrigMainProfileId = GetOutlineProfileId( nOutlineId, false, nProfileType) local nMainProfileId = EgtCopy( nOrigMainProfileId, nProfileLayerId) local sMainProfileType = EgtGetName( nMainProfileId) EgtSetInfo( nMainProfileId, WIN_PRF_TYPE, sMainProfileType) EgtSetName( nMainProfileId, WIN_PRF_MAIN) -- se bottomrail salvo info per scostamento dall'outline if sMainProfileType == WIN_FILL_RAIL or sMainProfileType == WIN_RAIL then SaveRailDelta( nMainProfileId, nBottomRail) end -- recupero profili start e ne creo copia -- se il tipo corrente è split il pezzo va tagliato con il bottomrail, altrimenti con il bottom for i = 1, #vPrevOutlineId do local nOrigStartProfileId = GetOutlineProfileId( vPrevOutlineId[i], nProfileType == WIN_PRF.SPLIT) local nStartProfileId = EgtCopy( nOrigStartProfileId, nProfileLayerId) local sStartProfileType = EgtGetName( nStartProfileId) EgtSetInfo( nStartProfileId, WIN_PRF_TYPE, sStartProfileType) EgtSetName( nStartProfileId, WIN_PRF_START) if sStartProfileType == WIN_FILL_RAIL then local nBottomRailTot = EgtGetInfo( vPrevOutlineId[i], WIN_BOTTOMRAIL, 'i') SaveRailDelta( nStartProfileId, nBottomRailTot) end end -- recupero profili end e ne creo copia for i = 1, #vNextOutlineId do local nOrigEndProfileId = GetOutlineProfileId( vNextOutlineId[i], nProfileType == WIN_PRF.SPLIT) local nEndProfileId = EgtCopy( nOrigEndProfileId, nProfileLayerId) local sEndProfileType = EgtGetName( nEndProfileId) EgtSetInfo( nEndProfileId, WIN_PRF_TYPE, sEndProfileType) EgtSetName( nEndProfileId, WIN_PRF_END) if sEndProfileType == WIN_FILL_RAIL then local nBottomRailTot = EgtGetInfo( vPrevOutlineId[i], WIN_BOTTOMRAIL, 'i') SaveRailDelta( nEndProfileId, nBottomRailTot) end end -- recupero le info di pinzaggio dal profilo di estrusione CopyInfo( nPartId, nMainProfileId, WIN_PRC_OFFY_1, 0) CopyInfo( nPartId, nMainProfileId, WIN_PRC_OFFZ_1, 0) CopyInfo( nPartId, nMainProfileId, WIN_PRC_OFFY_2, 0) CopyInfo( nPartId, nMainProfileId, WIN_PRC_OFFZ_2, 0) CopyInfo( nPartId, nMainProfileId, WIN_PRC_CLAMPV_1, 0) CopyInfo( nPartId, nMainProfileId, WIN_PRC_CLAMPV_2, 0) return nProfileLayerId end --------------------------------------------------------------------- local function GetDeltaProfile( nProfileId, sCtrIn) local dCPDelta = 0 local nSectionFrId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) local frSectionFrame = EgtFR( nSectionFrId, GDB_ID.ROOT) local nCPId = EgtGetFirstNameInGroup( nProfileId, sCtrIn) local b3CP = EgtGetBBoxRef( nCPId, GDB_BB.STANDARD, frSectionFrame) if sCtrIn == WIN_CTRIN .. 1 then dCPDelta = abs( b3CP:getMin():getX()) else dCPDelta = abs( b3CP:getMax():getX()) end -- se bottomrail considero anche scostamento dall'outline local sProfileType = EgtGetInfo( nProfileId, WIN_PRF_TYPE) if sProfileType == WIN_FILL_RAIL then local dDelta = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd') dCPDelta = dCPDelta + dDelta end return dCPDelta end --------------------------------------------------------------------- -- funzione che crea le curve del geo local function CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStartPartJointType, nEndPartJointType, nGeoLayerId, nProfileLayerId) local nCurrProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) -- calcolo spostamento della curva iniziale dovuto a posizione riferimento local b3CurrProfileFrame = GetProfileLocalBox( nCurrProfileId) local dCurrOffset = b3CurrProfileFrame:getMax():getX() local sProfileType = EgtGetInfo( nCurrProfileId, WIN_PRF_TYPE) if sProfileType == WIN_FILL_RAIL or sProfileType == WIN_RAIL then -- scostamento extra legato al bottomrail local dDelta = EgtGetInfo( nCurrProfileId, WIN_RAILDELTA, 'd') dCurrOffset = dCurrOffset - dDelta end -- creo copie degli outline e le offsetto opportunamente -- curva out local nOutId = EgtCopy( nOutlineId, nGeoLayerId) EgtOffsetCurve( nOutId, dCurrOffset) EgtSetName( nOutId, WIN_GEO_OUT) local nSemiProfileOut = EgtGetFirstNameInGroup( nCurrProfileId, WIN_OUT) or EgtGetFirstNameInGroup( nCurrProfileId, WIN_IN .. '1') EgtSetInfo( nOutId, WIN_SEMI_PROFILE, nSemiProfileOut) -- cruva 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) -- curve left local vPrevProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_START) for i = 1, #vPrevOutlineId do local nPrevCurveId local nPrevSemiProfile if nStartPartJointType == WIN_PART_JNT.ANGLED then -- calcolo la bisettrice local vtMedia = ( ( EgtSV( nOutlineId) - EgtEV( vPrevOutlineId[i])) / 2) if not vtMedia:normalize() then vtMedia = EgtSV( nOutlineId) vtMedia:rotate( Z_AX(), 90) end nPrevCurveId = EgtLinePVL( nGeoLayerId, EgtSP( nOutlineId), vtMedia, 3 * b3CurrProfileFrame:getDimX()) EgtInvertCurve( nPrevCurveId) else nPrevCurveId = EgtCopy( vPrevOutlineId[i], nGeoLayerId) if nStartPartJointType == WIN_PART_JNT.SHORT then local sCtrIn = GetProfileCtrIn( vPrevOutlineId[i], nOutlineId, vPrevProfileId[i]) local dCPDelta = GetDeltaProfile( vPrevProfileId[i], sCtrIn) EgtOffsetCurve( nPrevCurveId, - dCPDelta) -- ricavo il semiprofilo associato nPrevSemiProfile = EgtGetFirstNameInGroup( vPrevProfileId[i], sCtrIn) else nPrevSemiProfile = EgtGetFirstNameInGroup( vPrevProfileId[i], WIN_OUT) end end EgtSetName( nPrevCurveId, WIN_GEO_LEFT) EgtSetInfo( nPrevCurveId, WIN_SEMI_PROFILE, nPrevSemiProfile) EgtSetInfo( nPrevCurveId, WIN_REF_OUTLINE, vPrevOutlineId[i]) EgtRelocateGlob( nPrevCurveId, nGeoLayerId, GDB_IN.LAST_SON) end -- curve right local vNextProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_END) for i = 1, #vNextOutlineId do local nNextCurveId local nNextSemiProfile if nEndPartJointType == WIN_PART_JNT.ANGLED then -- calcolo la bisettrice local vtMedia = ( ( EgtSV( vNextOutlineId[i]) - EgtEV( nOutlineId)) / 2) if not vtMedia:normalize() then vtMedia = EgtEV( nOutlineId) vtMedia:rotate( Z_AX(), 90) end nNextCurveId = EgtLinePVL( nGeoLayerId, EgtEP( nOutlineId), vtMedia, 3 * b3CurrProfileFrame:getDimX()) else nNextCurveId = EgtCopy( vNextOutlineId[i], nGeoLayerId) if nEndPartJointType == WIN_PART_JNT.SHORT then local sCtrIn = GetProfileCtrIn( vNextOutlineId[i], nOutlineId, vNextProfileId[i]) local dCPDelta = GetDeltaProfile( vNextProfileId[i], sCtrIn) EgtOffsetCurve( nNextCurveId, - dCPDelta) -- ricavo il semiprofilo associato nNextSemiProfile = EgtGetFirstNameInGroup( vNextProfileId[i], sCtrIn) else nNextSemiProfile = EgtGetFirstNameInGroup( vNextProfileId[i], WIN_OUT) end end EgtSetName( nNextCurveId, WIN_GEO_RIGHT) EgtSetInfo( nNextCurveId, WIN_SEMI_PROFILE, nNextSemiProfile) EgtSetInfo( nNextCurveId, WIN_REF_OUTLINE, vNextOutlineId[i]) EgtRelocateGlob( nNextCurveId, nInId, GDB_IN.BEFORE) end local vIds = EgtGetAllInGroup( nGeoLayerId) -- trim delle curve TrimAndOrientOrderedCurves( vIds, false) -- 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( nGeoLayerId, GDB_BB.STANDARD, frRef) EgtSetInfo( nGeoLayerId, WIN_GEOLEN, b3Ref:getDimX()) end end --------------------------------------------------------------------- -- funzione che calcola l'ingombro dei pezzi del telaio local function CalcFrameGeo( nPartId, nOutlineId, nOutlineCrvNbr, nOutlineLayerId, nProfileType, nBottomRail) -- creo layer per ingombro local nGeoLayerId = EgtGroup( nPartId) EgtSetName( nGeoLayerId, WIN_GEO) -- recupero outline precedenti e successivi ( solo nel caso di split possono essere più di uno) local vPrevOutlineId, vNextOutlineId = GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) EgtSetInfo( nOutlineId, WIN_PREV_OUTLINES, vPrevOutlineId) EgtSetInfo( nOutlineId, WIN_NEXT_OUTLINES, vNextOutlineId) -- recupero il tipo di giunzioni local nStartJointType local nEndJointType local nProfileTypeS = nProfileType local nProfileTypeE = nProfileType if nProfileType == WIN_PRF.SPLIT or nProfileType == WIN_PRF.BOTTOMRAIL or nProfileType == WIN_PRF.BOTTOMRAIL_FINAL then -- non serve settare dei valori per StartJointType ed EndJointType perchè in CalcPartJointType la loro giunzione viene settata a short else -- recupero i joints opportuni dal vettore local vJoints = EgtGetInfo( nOutlineLayerId, WIN_JOINTS, 'vi') if EgtGetName( nOutlineId) == WIN_BOTTOM then nStartJointType = vJoints[1] nEndJointType = vJoints[2] elseif EgtGetName( nOutlineId) == WIN_RIGHT then nStartJointType = vJoints[2] nEndJointType = vJoints[3] elseif EgtGetName( nOutlineId) == WIN_TOP then nStartJointType = vJoints[3] nEndJointType = vJoints[4] -- correzioni per caso a triangolo if EgtGetName( vPrevOutlineId[1]) == WIN_BOTTOM then nStartJointType = vJoints[2] nEndJointType = vJoints[3] -- il lato top deve essere trattato come un left/right nel calcolo della giunzione nProfileTypeS = WIN_PRF.LEFT end if EgtGetName( vNextOutlineId[1]) == WIN_BOTTOM then nStartJointType = vJoints[3] nEndJointType = vJoints[1] nProfileTypeE = WIN_PRF.LEFT end elseif EgtGetName( nOutlineId) == WIN_LEFT then nStartJointType = vJoints[4] or vJoints[3] -- ( vJoints[3] per gestire caso a triangolo) nEndJointType = vJoints[1] end -- se giunzione diversa da bisettrice e arco a tutto sesto oppure elementi entrambi dello stesso tipo, forzo il tipo a bisettrice if nStartJointType ~= WIN_JNT.ANGLED and ( AreSameVectorApprox( EgtEV( vPrevOutlineId[1]), EgtSV( nOutlineId)) or EgtGetName( nOutlineId) == EgtGetName( vPrevOutlineId[1])) then nStartJointType = WIN_JNT.ANGLED end if nEndJointType ~= WIN_JNT.ANGLED and ( AreSameVectorApprox( EgtEV( nOutlineId), EgtSV( vNextOutlineId[1])) or EgtGetName( nOutlineId) == EgtGetName( vNextOutlineId[1])) then nEndJointType = WIN_JNT.ANGLED end end -- calcolo il tipo di giunzione per la parte local nStartPartJointType = CalcPartJointType( nProfileTypeS, nStartJointType) local nEndPartJointType = CalcPartJointType( nProfileTypeE, nEndJointType) -- nel caso di incontro con soglia la giunzione deve essere full if EgtGetInfo( vPrevOutlineId[1], WIN_THRESHOLD, 'b') then nStartPartJointType = WIN_JNT.FULL end if EgtGetInfo( vNextOutlineId[1], WIN_THRESHOLD, 'b') then nEndPartJointType = WIN_JNT.FULL end -- salvo il valore dei joints su outline -- se bottomrail è sicuramente short quindi non salvo il valore che sovrascriverebbe quello del pezzo bottom ( che potrebbe essere short o full) if nProfileType ~= WIN_PRF.BOTTOMRAIL and nProfileType ~= WIN_PRF.BOTTOMRAIL_FINAL then EgtSetInfo( nOutlineId, WIN_STARTJOINT, nStartPartJointType) EgtSetInfo( nOutlineId, WIN_ENDJOINT, nEndPartJointType) end -- creo il gruppo con i profili del pezzo local nProfileLayerId = CalcProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutlineId, nProfileType, nBottomRail) -- creo lati dell'outline CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStartPartJointType, nEndPartJointType, nGeoLayerId, nProfileLayerId) end --------------------------------------------------------------------- -- funzione che calcola l'ingombro del fill local function CalcFillGeo( nPartId, nOutlineLayerId) -- creo layer per ingombro local nGeoLayerId = EgtGroup( nPartId) EgtSetName( nGeoLayerId, WIN_GEO) -- copio lati da Outline local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) while nOutlineId do EgtCopy( nOutlineId, nGeoLayerId) nOutlineId = EgtGetNext( nOutlineId) end -- recupero e salvo spessore vetro local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) local nSashProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH) local dGlassThickness = EgtGetInfo( nSashProfileId, WIN_GLASSTHICKNESS, 'd') EgtSetInfo( nGeoLayerId, WIN_GLASSTHICKNESS, dGlassThickness) -- verifico forma e salvataggio info associate local nCompo = EgtCurveCompo( nGeoLayerId, EgtGetAllInGroup( nGeoLayerId), false) local bRect, ptTest, vtEdge1, vtEdge2 = EgtCurveIsARectangle( nCompo) EgtSetInfo( nGeoLayerId, WIN_GLASS_RECT, bRect) if bRect then EgtSetInfo( nGeoLayerId, WIN_GEOWIDTH, vtEdge1:len()) EgtSetInfo( nGeoLayerId, WIN_GEOHEIGHT, vtEdge2:len()) else -- se non è rettangolare salvo le dimensioni del suo box orientato in modo ottimale local _, dDim1, dDim2 = EgtCurveMinAreaRectangleXY( nCompo) EgtSetInfo( nGeoLayerId, WIN_GEOWIDTH, dDim1) EgtSetInfo( nGeoLayerId, WIN_GEOHEIGHT, dDim2) end EgtErase( nCompo) return nGeoLayerId end ---------------------------------------------------------------------------------- ----------------------- CURVE AUX PER CAMBIO PROFILO ----------------------------- ---------------------------------------------------------------------------------- -- funzione che individua e crea i diversi tratti uniformi della curva di outline local function CalcMixedOutlines( nPartId, nOutlineId) -- creo gruppo dove salvare i sottotratti local nGrp = EgtGroup( nPartId) EgtSetName( nGrp, WIN_MIXED_OUTLINES) EgtSetStatus( nGrp, GDB_ST.OFF) -- recupero i tratti di tipo sash e li concateno local vSashChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi') local vSash = {} for i = 1, #vSashChildren do local nCrv = EgtCopyGlob( vSashChildren[i], nGrp) table.insert( vSash, nCrv) end local nCrvS, nCntS = EgtCurveCompoByReorder( nGrp, vSash, EgtSP( nOutlineId)) for nId = nCrvS, nCrvS + nCntS - 1 do EgtSetName( nId, WIN_SASH) end -- recupero i tratti di tipo fill e li concateno local vFillChildren = EgtGetInfo( nOutlineId, WIN_FILL_CHILDREN, 'vi') local vFill = {} for i = 1, #vFillChildren do local nCrv = EgtCopyGlob( vFillChildren[i], nGrp) table.insert( vFill, nCrv) end local nCrvF, nCntF = EgtCurveCompoByReorder( nGrp, vFill, EgtSP( nOutlineId)) for nId = nCrvF, nCrvF + nCntF - 1 do EgtSetName( nId, WIN_FILL) end -- riordino le curve nel gruppo per ricostruire l'outline EgtReorderCurvesInGroup( nGrp, EgtSP( nOutlineId)) -- creo associazione tra le sottocurve di outline e gli split che le separano : -- recupero tutti gli split coinvolti local nBaseOutline = EgtGetInfo( nOutlineId, WIN_COPY, 'i') local vStack = { nBaseOutline} local vSplitIds = {} local i = 1 while vStack[i] do -- recupero il tipo di area local nAreaId = EgtGetParent( EgtGetParent( vStack[i])) local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') if nAreaType ~= WIN_AREATYPES.SASH and nAreaType ~= WIN_AREATYPES.FILL then -- salvo il suo eventuale split local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) if nSplitLayerId then local nSplitId = EgtGetFirstInGroup( nSplitLayerId) table.insert( vSplitIds, nSplitId) end -- analizzo eventuali figli local vChildren = EgtGetInfo( vStack[i], WIN_CHILD, 'vi') or {} vStack = EgtJoinTables( vStack, vChildren) end i = i + 1 end -- associo le curve con lo split che le taglia nel loro punto finale local vCrvs = EgtGetAllInGroup( nGrp) for i = 1, #vSplitIds do local ptS = EgtSP( vSplitIds[i]) local ptE = EgtEP( vSplitIds[i]) for j = 1, #vCrvs - 1 do local ptTest = EgtEP( vCrvs[j]) if AreSamePointApprox( ptS, ptTest) then EgtSetInfo( vSplitIds[i], WIN_MIXED_REF_START, vCrvs[j]) EgtSetInfo( vCrvs[j], WIN_MIXED_SPLIT_REF, vSplitIds[i]) break elseif AreSamePointApprox( ptE, ptTest) then EgtSetInfo( vSplitIds[i], WIN_MIXED_REF_END, vCrvs[j]) EgtSetInfo( vCrvs[j], WIN_MIXED_SPLIT_REF, vSplitIds[i]) break end end end return nGrp end --------------------------------------------------------------------- -- funzione che crea la curva di riferimento sulla giunzione tra il pezzo di split e il pezzo di telaio con cambio profilo local function CalcMixedIntersections( nPartId, nOutline, vOutlines) local nGrp = EgtGroup( nPartId) EgtSetName( nGrp, WIN_MIXED_INTERSECTIONS) EgtSetStatus( nGrp, GDB_ST.OFF) -- recupero il profilo dell'outline local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) for i = 1, #vOutlines - 1 do -- recupero la curva di split che separa i due tratti di outline local nSplitId = EgtGetInfo( vOutlines[i], WIN_MIXED_SPLIT_REF, 'i') local nSplitProfileId = GetOutlineProfileId( nSplitId, false) -- verifico ordinamento local bSashFill = ( EgtGetName( vOutlines[i]) == WIN_SASH) -- ricavo il punto di incontro tra le due parti dei profili che vanno contro il vetro local nCrv1 = EgtCopyGlob( nSplitId, nGrp) local dDeltaFixedSplit = EgtGetInfo( nSplitProfileId, WIN_FIXED_REF, 'd') EgtOffsetCurve( nCrv1, dDeltaFixedSplit) local nCrv2 = EgtCopyGlob( nOutline, nGrp) local dDeltaFixedFrame = EgtGetInfo( nMainProfileId, WIN_FIXED_REF, 'd') EgtOffsetCurve( nCrv2, - dDeltaFixedFrame) local ptRef1 = EgtIP( nCrv1, nCrv2, ORIG()) -- ricavo il punto di incontro tra il taglio a 45° e la parte del telaio contro anta -- TO DO : capire come gestire correttamente la rotazione nel caso di arco local dParRef = EgtCurveParamAtPoint( nCrv2, ptRef1) local vtDir45 = EgtUV( nCrv2, dParRef, -1) vtDir45:rotate( Z_AX(), EgtIf( bSashFill, 225, -45)) local nCrv3 = EgtLinePVL( nGrp, ptRef1, vtDir45, 100) local nCrv4 = EgtCopyGlob( nOutline, nGrp) local dDeltaSashFrame = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '1', 'd') EgtOffsetCurve( nCrv4, - dDeltaSashFrame) local ptRef2 = EgtIP( nCrv3, nCrv4, ORIG()) -- curva di intersezione da usare come riferimento per i conti successivi local nCrv = EgtCurveCompoFromPoints( nGrp, { ptRef1, ptRef2}) -- calcolo il raccordo local dRad = EgtGetInfo( nMainProfileId, WIN_RAD_REF .. '1', 'd') local dParFillet = EgtCurveParamAtPoint( nCrv4, ptRef2) dParFillet = dParFillet + EgtIf( bSashFill, -10, 10) * GEO.EPS_SMALL local nFillet = EgtCurveFillet( nGrp, nCrv, EgtUP( nCrv1, 0.9), nCrv4, EgtUP( nCrv4, dParFillet), dRad, true) or GDB_ID.NULL EgtAddCurveCompoCurve( nCrv, nFillet) -- cancello curve di costruzione EgtErase( { nCrv1, nCrv2, nCrv3, nCrv4}) -- assegno riferimento EgtSetInfo( vOutlines[i], WIN_MIXED_INTERS_REF, nCrv) end end --------------------------------------------------------------------- -- funzione che calcola curve ausiliarie per la gestione del cambio profilo local function CalcMixedFrameCurves( nPartId, nOutlineId) -- calcolo i sottotratti uniformi della curva di outline local nOutlinesGrp = CalcMixedOutlines( nPartId, nOutlineId) local vCrvs = EgtGetAllInGroup( nOutlinesGrp) -- calcolo le curve di intersezione con gli split CalcMixedIntersections( nPartId, nOutlineId, vCrvs) end ---------------------------------------------------------------------------------- --------------------------- PROFILING PROCESSINGS -------------------------------- ---------------------------------------------------------------------------------- -- funzione che copia sulla curva di lavorazione le informazioni prese dal semiprofilo corrispondente local function GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile) if nSemiProfile then -- setto info di lavorazione EgtSetInfo( nCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) -- setto info con il tipo di profiling local sName = EgtGetName( nCrv) if sName == WIN_GEO_LEFT or sName == WIN_GEO_RIGHT then EgtSetInfo( nCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.HEAD) else EgtSetInfo( nCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.LONGITUDINAL) end -- recupero le info di lavorazione dal semiprofilo if sName == WIN_GEO_OUT or sName == WIN_GEO_IN then -- recupero la fase solo se si tratta di in o out CopyInfo( nCrv, nSemiProfile, WIN_PRC_PHASE) end local nTools = EgtGetInfo( nSemiProfile, WIN_PRC_NTOOLS , 'i') or 0 EgtSetInfo( nCrv, WIN_PRC_NTOOLS, nTools) for j = 1, nTools do CopyInfo( nCrv, nSemiProfile, WIN_PRC_TOOL_NAME .. '_' .. tostring(j)) CopyInfo( nCrv, nSemiProfile, WIN_PRC_OFFL .. '_' .. tostring(j)) CopyInfo( nCrv, nSemiProfile, WIN_PRC_OFFR .. '_' .. tostring(j)) end else -- se non ha semiprofilo associato è un taglio EgtSetInfo( nCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.CUT) end end --------------------------------------------------------------------- -- funzione che calcola la prima lavorazione per l'innesto dello split sul telaio nel caso di cambio profilo local function CalcMixedFrameMilling1( nIntersCrv, nOutlineId, nMainProfileId, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId) local dOffs = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '1', 'd') local dDepth = EgtGetInfo( nMainProfileId, WIN_SASH_DEPTH .. '1', 'd') local dFilletRad = EgtGetInfo( nMainProfileId, WIN_RAD_REF .. '1', 'd') -- primo tratto : taglio a 45° e fillet local nCrv1 = EgtCopyGlob( nIntersCrv, nProcLayerId) EgtExtendCurveStartByLen( nCrv1, 100) -- calcolo il tratto di outline local nCrv2 = EgtCopyGlob( nOutlineId, nProcLayerId) EgtOffsetCurve( nCrv2, - dOffs) if bSashFill then EgtInvertCurve( nCrv2) end local dParS = EgtCurveParamAtPoint( nCrv2, EgtEP( nCrv1)) local ptEnd = EgtIP( nCrv2, nSplitRef, ORIG()) local dParE = EgtCurveParamAtPoint( nCrv2, ptEnd) EgtTrimCurveStartEndAtParam( nCrv2, dParS, dParE) -- tratto di uscita a 45° local vtDir2 = EgtEV( nCrv2) vtDir2:rotate( Z_AX(), EgtIf( bSashFill, - 45, 45)) local nCrv3 = EgtLinePVL( nProcLayerId, ptEnd, vtDir2, 100) -- creo fillet local nFillet = EgtCurveFillet( nProcLayerId, nCrv2, EgtUP( nCrv2, 0.9), nCrv3, EgtUP( nCrv3, 0.1), dFilletRad, true) -- creo curva di lavorazione local nMillingCrv = EgtCurveCompo( nProcLayerId, {nCrv1, nCrv2, nFillet, nCrv3}) if bSashFill then EgtInvertCurve( nMillingCrv) end EgtModifyCurveThickness( nMillingCrv, - dDepth) -- setto info di lavorazione EgtSetInfo( nMillingCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) EgtSetInfo( nMillingCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC) EgtSetInfo( nMillingCrv, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.IN) EgtTrimCurveWithRegion( nMillingCrv, nSurfGeoId, true, false) end --------------------------------------------------------------------- -- funzione che calcola la seconda lavorazione per l'innesto dello split sul telaio nel caso di cambio profilo local function CalcMixedFrameMilling2( nIntersCrv, nOutlineId, nMainProfileId, nSplitProfileId, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId) local dOffs = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '2', 'd') local dDepth = EgtGetInfo( nMainProfileId, WIN_SASH_DEPTH .. '2', 'd') local dFilletRad = EgtGetInfo( nMainProfileId, WIN_RAD_REF .. '2', 'd') local dExtraDist = EgtGetInfo( nMainProfileId, WIN_EXTRA_DIST, 'd') local nCrv1 = EgtCopyGlob( nIntersCrv, nProcLayerId) EgtExtendCurveStartByLen( nCrv1, 100) -- calcolo il primo tratto di outline local nCrv2 = EgtCopyGlob( nOutlineId, nProcLayerId) EgtOffsetCurve( nCrv2, - dOffs + dExtraDist) if bSashFill then EgtInvertCurve( nCrv2) end -- taglio i due tratti per unirli local pt1 = EgtIP( nCrv1, nCrv2, ORIG()) local dParE1 = EgtCurveParamAtPoint( nCrv1, pt1) EgtTrimCurveEndAtParam( nCrv1, dParE1) local dParS2 = EgtCurveParamAtPoint( nCrv2, pt1) EgtTrimCurveStartAtParam( nCrv2, dParS2) -- calcolo fillet local nFillet1 = EgtCurveFillet( nProcLayerId, nCrv1, EgtUP( nCrv1, 0.9), nCrv2, EgtUP( nCrv2, 0.1), dFilletRad, true) -- calcolo il secondo tratto di outline local nCrv3 = EgtCopyGlob( nOutlineId, nProcLayerId) EgtOffsetCurve( nCrv3, - dOffs) if bSashFill then EgtInvertCurve( nCrv3) end local nSplitRef2 = EgtCopyGlob( nSplitRef, nProcLayerId) local dOffs1 = EgtGetInfo( nSplitProfileId, WIN_SASH_REF .. '1', 'd') local dOffs2 = EgtGetInfo( nSplitProfileId, WIN_SASH_REF .. '2', 'd') EgtOffsetCurve( nSplitRef2, dOffs2 - dOffs1) local pt2 = EgtIP( nCrv3, nSplitRef2, ORIG()) local pt3 = EgtIP( nCrv3, nSplitRef, ORIG()) local dParS3 = EgtCurveParamAtPoint( nCrv3, pt2) local dParE3 = EgtCurveParamAtPoint( nCrv3, pt3) EgtTrimCurveStartEndAtParam( nCrv3, dParS3, dParE3) EgtErase( nSplitRef2) -- calcolo il raccordo tra i due tratti di outline : è arco di raggio dFilletRad, tangente a nCrv2 e con punto finale pt2 -- calcolo il centro dell'arco local nCircleTmp = EgtCircle( nProcLayerId, pt2, dFilletRad) local nCrvTmp = EgtCopyGlob( nOutlineId, nProcLayerId) EgtOffsetCurve( nCrvTmp, - dOffs + dExtraDist - dFilletRad) local ptC = EgtIP( nCircleTmp, nCrvTmp, EgtIf( bSashFill, EgtEP( nCrvTmp), EgtSP( nCrvTmp))) EgtErase( {nCircleTmp, nCrvTmp}) local nFillet2 = EgtArcC2PEx( nProcLayerId, ptC, EgtSP( nCrv2), GDB_PT.TG, nCrv2, pt2) -- taglio il primo tratto di outline per collegarlo al raccordo local dParE2 = EgtCurveParamAtPoint( nCrv2, EgtSP( nFillet2)) EgtTrimCurveEndAtParam( nCrv2, dParE2) -- tratto di uscita a 45° local vtDir2 = EgtEV( nCrv3) vtDir2:rotate( Z_AX(), EgtIf( bSashFill, - 45, 45)) local nCrv4 = EgtLinePVL( nProcLayerId, EgtEP( nCrv3), vtDir2, 100) -- creo fillet local nFillet3 = EgtCurveFillet( nProcLayerId, nCrv3, EgtUP( nCrv3, 0.9), nCrv4, EgtUP( nCrv4, 0.1), dFilletRad, true) or GDB_ID.NULL -- creo curva di lavorazione local nMillingCrv = EgtCurveCompo( nProcLayerId, {nCrv1, nFillet1, nCrv2, nFillet2, nCrv3, nFillet3, nCrv4}) if bSashFill then EgtInvertCurve( nMillingCrv) end EgtModifyCurveThickness( nMillingCrv, - dDepth) -- setto info di lavorazione EgtSetInfo( nMillingCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) EgtSetInfo( nMillingCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC) EgtSetInfo( nMillingCrv, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.IN) EgtTrimCurveWithRegion( nMillingCrv, nSurfGeoId, true, false) end --------------------------------------------------------------------- -- funzione che calcola le lavorazioni di profiling per un pezzo di telaio con cambio profilo local function CalcMixedFrameProfilingProcessings( nPartId, nProcLayerId, nGeoLayerId, nMainProfileId, nSurfGeoId) -- a) lavorazioni profili -- per le lavorazioni dei profili out, left, right e in comune si usano le corrispondenti curve del geo local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId) for i = 1, #vGeoCrvs do -- copio curva local nCrv = EgtCopyGlob( vGeoCrvs[i], nProcLayerId) EgtModifyCurveThickness( nCrv, 0) -- recupero il semiprofilo associato local nSemiProfile = EgtGetInfo( nCrv, WIN_SEMI_PROFILE, 'i') GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile) end -- lavorazioni dei sottotratti in di sash e fill local nOutlinesGrp = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_OUTLINES) local vCrvs = EgtGetAllInGroup( nOutlinesGrp) local b3Profile = GetProfileLocalBox( nMainProfileId) local dOffs = b3Profile:getMin():getX() for i = #vCrvs, 1, -1 do -- calcolo la curva di lavorazione local nCrv = EgtCopyGlob( vCrvs[i], nProcLayerId) EgtOffsetCurve( nCrv, dOffs) EgtInvertCurve( nCrv) nCrv = EgtTrimCurveWithRegion( nCrv, nSurfGeoId, true, true) -- setto le info di lavorazione dal semiprofilo local nSemiProfile = EgtGetFirstNameInGroup( nMainProfileId, EgtGetName( vCrvs[i]) .. WIN_IN) GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile) -- sistemo info di lavorazione EgtSetInfo( nCrv, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.MIXED) EgtSetInfo( nCrv, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.IN) -- TO DO : calcolo di AddLen ? end -- b) lavorazioni sulle intersezioni con gli split local nIntersGrp = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_INTERSECTIONS) local vInters = EgtGetAllInGroup( nIntersGrp) local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i') for i = 1, #vInters do local bSashFill = ( EgtGetName( vCrvs[i]) == WIN_SASH) -- recupero lo split associato e creo la curva di riferimento per le fresature local nSplitId = EgtGetInfo( vCrvs[i], WIN_MIXED_SPLIT_REF, 'i') local nSplitProfileId = GetOutlineProfileId( nSplitId, false) local dRefSplit = EgtGetInfo( nSplitProfileId, WIN_SASH_REF .. '2', 'd') local nSplitRef = EgtCopyGlob( nSplitId, nProcLayerId) EgtOffsetCurve( nSplitRef, - dRefSplit) -- Fresatura 1 CalcMixedFrameMilling1( vInters[i], nOutlineId, nMainProfileId, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId) -- Fresatura 2 CalcMixedFrameMilling2( vInters[i], nOutlineId, nMainProfileId, nSplitProfileId, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId) EgtErase( nSplitRef) end end --------------------------------------------------------------------- -- funzione che calcola le lavorazioni di profiling nel caso di uno split coinvolto da cambio profilo local function CalcMixedSplitProfilingProcessings( nSplitId, nProcLayerId, nGeoLayerId) -- a) lavorazione dei profili local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId) for i = 1, #vGeoCrvs do -- copio la curva local nCrvId = EgtCopyGlob( vGeoCrvs[i], nProcLayerId) EgtModifyCurveThickness( nCrvId, 0) -- recupero il semiprofilo associato ( per left e right è stato salvato il profilo di tipo sash) local nSemiProfileId = EgtGetInfo( nCrvId, WIN_SEMI_PROFILE, 'i') -- setto le info dal semiprofilo GetProcessingInfoFromSemiProfile( nCrvId, nSemiProfileId) end -- b) tagli a 45° -- left local nMixedLeft = EgtGetInfo( nSplitId, WIN_MIXED_REF_START, 'i') local nIntersLeft = EgtGetInfo( nMixedLeft, WIN_MIXED_INTERS_REF, 'i') local nMillingLeft = EgtCopyGlob( nIntersLeft, nProcLayerId) -- recupero profondità local vOutlineLeft = EgtGetInfo( nSplitId, WIN_PREV_OUTLINES, 'vi') local nProfileLeft = GetOutlineProfileId( vOutlineLeft[1], false) local dDepthLeft = EgtGetInfo( nProfileLeft, WIN_SASH_DEPTH .. '2', 'd') EgtModifyCurveThickness( nMillingLeft, - dDepthLeft) -- setto info di lavorazione EgtSetInfo( nMillingLeft, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) EgtSetInfo( nMillingLeft, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC) EgtSetInfo( nMillingLeft, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.LEFT) -- right local nMixedRight = EgtGetInfo( nSplitId, WIN_MIXED_REF_END, 'i') local nIntersRight = EgtGetInfo( nMixedRight, WIN_MIXED_INTERS_REF, 'i') local nMillingRight = EgtCopyGlob( nIntersRight, nProcLayerId) -- recupero profondità local vOutlineRight = EgtGetInfo( nSplitId, WIN_NEXT_OUTLINES, 'vi') local nProfileRight = GetOutlineProfileId( vOutlineRight[1], false) local dDepthRight = EgtGetInfo( nProfileRight, WIN_SASH_DEPTH .. '2', 'd') EgtModifyCurveThickness( nMillingRight, - dDepthRight) EgtInvertCurve( nMillingRight) -- setto info di lavorazione EgtSetInfo( nMillingRight, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) EgtSetInfo( nMillingRight, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC) EgtSetInfo( nMillingRight, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.RIGHT) end --------------------------------------------------------------------- -- funzione che calcola le lavorazioni di profiling local function CalcProfilingProcessings( nPartId, nOutlineId) -- creo gruppo delle lavorazioni local nProcLayerId = EgtGroup( nPartId) EgtSetName( nProcLayerId, WIN_PRC) EgtSetStatus( nProcLayerId, GDB_ST.OFF) -- recupero il geo e creo la superficie associata per limitare le lavorazioni local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO) local nSurfGeo = CreateGeoArea( nGeoLayerId, nProcLayerId, false) EgtSurfFrOffset( nSurfGeo, 50 * GEO.EPS_SMALL) -- recupero il gruppo dei profili local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) -- recupero le info di sovramateriale dal profilo CopyInfo( nPartId, nMainProfileId, WIN_PRC_OVERMAT_IN, 0) CopyInfo( nPartId, nMainProfileId, WIN_PRC_OVERMAT_OUT, 0) CopyInfo( nPartId, nMainProfileId, WIN_PRC_OVERMAT_LEFT, 0) CopyInfo( nPartId, nMainProfileId, WIN_PRC_OVERMAT_RIGHT, 0) -- calcolo lavorazioni dei profili local bChangeProfile = EgtGetInfo( nOutlineId, WIN_PRF_CHANGE, 'b') or false if bChangeProfile then -- 1) caso cambio profilo : telaio o split if EgtGetName( nOutlineId) == WIN_SPLIT then CalcMixedSplitProfilingProcessings( nOutlineId, nProcLayerId, nGeoLayerId) else CalcMixedFrameProfilingProcessings( nPartId, nProcLayerId, nGeoLayerId, nMainProfileId, nSurfGeo) end else -- 2) caso standard -- recupero tutte le curve del geo local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId) for i = 1, #vGeoCrvs do -- copio curva local nCrvId = EgtCopyGlob( vGeoCrvs[i], nProcLayerId) EgtModifyCurveThickness( nCrvId, 0) -- recupero il semiprofilo associato local nSemiProfileId = EgtGetInfo( nCrvId, WIN_SEMI_PROFILE, 'i') -- setto le info dal semiprofilo GetProcessingInfoFromSemiProfile( nCrvId, nSemiProfileId) end end -- calcolo eventuali lavorazioni per strip local vStripDist = EgtGetInfo( nMainProfileId, WIN_STRIP_DIST, 'vi') or {} for i = 1, #vStripDist do local nStripCut = EgtCopyGlob( nOutlineId, nProcLayerId) EgtOffsetCurve( nStripCut, vStripDist[i]) -- modifico la curva in modo che sia a filo del geo EgtExtendCurveStartByLen( nStripCut, 1000) EgtExtendCurveEndByLen( nStripCut, 1000) nStripCut = EgtTrimCurveWithRegion( nStripCut, nSurfGeo, true, false) -- aggiusto orientamento per essere coerente con il geo corrispondente if vStripDist[i] < 0 then EgtInvertCurve( nStripCut) end -- setto info di lavorazione EgtSetName( nStripCut, WIN_PRC_TYPE.STRIP_CUT) EgtSetInfo( nStripCut, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.STRIP_CUT) end EgtErase( nSurfGeo) -- verifico se anta ricevente ( info necessaria per ottimizzazione lavorazioni) local nAreaId = EgtGetParent( EgtGetParent( nOutlineId)) local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') if nAreaType == WIN_AREATYPES.SASH then local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') if nSashType == WIN_SASHTYPES.INACTIVE or nSashType == WIN_SASHTYPES.INACTIVE_IN then local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') local bOnFrenchSplit = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b') if bOnFrenchSplit then EgtSetInfo( nPartId, WIN_SASHTYPE, WIN_INACTIVE) end end end end --------------------------------------------------------------------- -- funzione che calcola gli elementi ausiliari per la creazione del grezzo nell'automatismo delle lavorazioni local function CalcGeoRaw( nPartId) local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO) local nGeoRawLayerId = EgtCopyGlob( nGeoLayerId, nPartId) EgtSetName( nGeoRawLayerId, WIN_GEO_RAW) EgtSetStatus( nGeoRawLayerId, GDB_ST.OFF) -- recupero le curve del geo local nOut = EgtGetFirstNameInGroup( nGeoRawLayerId, WIN_GEO_OUT) local nIn = EgtGetFirstNameInGroup( nGeoRawLayerId, WIN_GEO_IN) local vRight = EgtGetNameInGroup( nGeoRawLayerId, WIN_GEO_RIGHT) local vLeft = EgtGetNameInGroup( nGeoRawLayerId, WIN_GEO_LEFT) -- verifico se le curve right e left hanno direzioni coerenti if #vRight == 2 and not AreSamePointApprox( EgtEP( vRight[1]), EgtSP( vRight[2])) then -- la seconda curva va ignorata EgtErase( vRight[2]) vRight = { vRight[1]} end if #vLeft == 2 and not AreSamePointApprox( EgtEP( vLeft[1]), EgtSP( vLeft[2])) then -- la prima curva va ignorata EgtErase( vLeft[1]) vLeft = { vLeft[2]} end -- 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') -- applico i sovramateriali EgtOffsetCurve( nOut, dOvermatOut) for i = 1, #vRight do EgtOffsetCurve( vRight[i], dOvermatRight) end EgtOffsetCurve( nIn, dOvermatIn) for i = 1, #vLeft do EgtOffsetCurve( vLeft[i], dOvermatLeft) end -- creo la composita del grezzo a partire dalle curve local vCrvs = EgtGetAllInGroup( nGeoRawLayerId) TrimAndOrientOrderedCurves( vCrvs, false) local nCompo = EgtCurveCompo( nGeoRawLayerId, vCrvs) -- aggiungo spessore local dDimH = EgtGetInfo( nGeoLayerId, WIN_GEOHEIGHT, 'd') EgtModifyCurveThickness( nCompo, - dDimH) -- creo frame ausiliario local vtX = EgtSV( nCompo) local frGeo = Frame3d( EgtSP( nCompo), vtX, Z_AX() ^ vtX, Z_AX()) local nFrameId = EgtFrame( nGeoRawLayerId, frGeo) EgtSetName( nFrameId, WIN_PRC_FRAME) end ---------------------------------------------------------------------------------- ---------------------------------- SOLIDO ---------------------------------------- ---------------------------------------------------------------------------------- -- funzione che costruisce una superficie estrudendo il nSectionId lungo l'outline local function CreateProfileSurfById( nOutlineId, nProfileId, nSectionId, dExtraLen, nLayerId) -- creo guida con estensione in tangenza local nGuideId = EgtCopy( nOutlineId, nLayerId) if EgtGetType( nGuideId) == GDB_TY.CRV_LINE then EgtExtendCurveStartByLen( nGuideId, dExtraLen) EgtExtendCurveEndByLen( nGuideId, dExtraLen) else nGuideId = EgtCurveCompo( nLayerId, nGuideId) EgtAddCurveCompoLineTg( nGuideId, dExtraLen) EgtAddCurveCompoLineTg( nGuideId, dExtraLen, false) end -- correzione nel caso di bottomrail local sProfileType = EgtGetInfo( nProfileId, WIN_PRF_TYPE) if sProfileType == WIN_RAIL or sProfileType == WIN_FILL_RAIL then local dOffs = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd') EgtOffsetCurve( nGuideId, - dOffs) end -- verifico se necessaria inversione della guida nel caso sia curva "virtuale" ( ovvero in area null o split) che deriva da pezzo di split local nRefSplitId = EgtGetInfo( nOutlineId, WIN_REF_SPLIT, 'i') if nRefSplitId then -- recupero base outline per confrontarlo con lo split da cui deriva local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') -- recupero vettore tangente nel punto medio del base outline local ptM = EgtMP( nBaseOutlineId) local vtM = EgtMV( nBaseOutlineId) -- recupero vettore tangente nello stesso punto della curva di split da cui deriva local dRefSplitPar = EgtCurveParamAtPoint( nRefSplitId, ptM) local vtMRefSplit = EgtUV( nRefSplitId, dRefSplitPar, -1) -- se i due vettori non sono orientati nella stessa direzione inverto la guida if not AreSameVectorApprox( vtM, vtMRefSplit) then EgtInvertCurve( nGuideId) end end -- recupero il profilo da estrudere local nSectionRefId = EgtCopyGlob( nSectionId, nLayerId) -- posiziono la sezione di estrusione sulla guida : -- recupero frame del profilo local nProfileFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) local frProfile = EgtFR( nProfileFrameId, GDB_ID.ROOT) frProfile:invert() -- calcolo il frame di destinazione sulla guida local frDest = Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId), GDB_RT.GLOB) -- posiziono con i riferimenti EgtTransform( nSectionRefId, frProfile, GDB_RT.GLOB) EgtTransform( nSectionRefId, frDest, GDB_RT.GLOB) -- creo la superfice di estrusione local nStmId = EgtSurfTmSwept( nLayerId, nSectionRefId, nGuideId, false, WIN_SURF_APPROX) EgtErase( nGuideId) EgtErase( nSectionRefId) return nStmId end --------------------------------------------------------------------- -- come CreateProfileSurfById ma riceve il nome della sezione da estrudere local function CreateProfileSurf( nOutlineId, nProfileId, sSectionName, dExtraLen, nLayerId) -- recupero l'id della sezione da estrudere local nSectionId = EgtGetFirstNameInGroup( nProfileId, sSectionName) if not nSectionId then return end return CreateProfileSurfById( nOutlineId, nProfileId, nSectionId, dExtraLen, nLayerId) end --------------------------------------------------------------------- -- funzione che crea la superficie di trim per il solido local function CreateTrimSurf( nGeoId, nProfileId, dGeoWidth, nLayerId) -- recupero profilo di riferimento dalla curva geo local nOrigTrimProfileId = EgtGetInfo( nGeoId, WIN_SEMI_PROFILE, 'i') -- 1) minizinken if not nOrigTrimProfileId then local nGuideId = EgtCopy( nGeoId, nLayerId) EgtExtendCurveStartByLen( nGuideId, 4 * dGeoWidth) EgtExtendCurveEndByLen( nGuideId, 4 * dGeoWidth) EgtMove( nGuideId, Z_AX()) local b3Profile = GetProfileLocalBox( nProfileId) local nTrimSurf = EgtSurfTmByExtrusion( nLayerId, nGuideId, - Z_AX() * ( b3Profile:getDimY() + 2), WIN_SURF_APPROX) EgtInvertSurf( nTrimSurf) EgtErase( nGuideId) return nTrimSurf -- 2) controprofilo else -- recupero il controprofilo da estrudere local sTrimProfileName = EgtGetName( nOrigTrimProfileId) sTrimProfileName = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_OFST .. sTrimProfileName -- recupero la curva di outline associata alla curva di geo local nRefOutline = EgtGetInfo( nGeoId, WIN_REF_OUTLINE, 'i') -- calcolo la superficie di estrusione return CreateProfileSurf( nRefOutline, nProfileId, sTrimProfileName, 4 * dGeoWidth, nLayerId) end end --------------------------------------------------------------------- -- funzione che crea le superfici di trim per uno split coinvolto da cambio profilo ( controprofilo della parte sash del telaio e taglio a 45°) local function CreateMixedSplitTrimSurf( nMixedOutlineId, nProfileId, dExtraLen, nLayerId) -- estrudo il controprofilo di tipo sash local nPartId = EgtGetParent( EgtGetParent( nMixedOutlineId)) local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i') local sTrimProfile = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_OFST .. WIN_SASH .. WIN_CTRIN local nTrimStmId = CreateProfileSurf( nOutlineId, nProfileId, sTrimProfile, dExtraLen, nLayerId) -- creo il solido da intersecare con il controprofilo per il taglio a 45° local nIntersCrvId = EgtGetInfo( nMixedOutlineId, WIN_MIXED_INTERS_REF, 'i') local nGuideId = EgtCopyGlob( nIntersCrvId, nLayerId) local bSashFill = ( EgtGetName( nMixedOutlineId) ~= WIN_SASH) local vtDirH = EgtSV( nGuideId) vtDirH:rotate( Z_AX(), EgtIf( bSashFill, -135, 135)) local vtDirV = EgtSV( nGuideId) vtDirV:rotate( Z_AX(), EgtIf( bSashFill, -45, 45)) EgtAddCurveCompoLine( nGuideId, EgtEP( nGuideId) + dExtraLen * vtDirV) EgtAddCurveCompoLine( nGuideId, EgtSP( nGuideId) + dExtraLen * vtDirH, false) EgtAddCurveCompoLine( nGuideId, EgtSP( nGuideId) + dExtraLen * vtDirV, false) EgtCloseCurveCompo( nGuideId) EgtMove( nGuideId, 0.01 * Z_AX()) if bSashFill then EgtInvertCurve( nGuideId) end local dDepth = EgtGetInfo( nProfileId, WIN_SASH_DEPTH .. '2', 'd') local nCutStmId = EgtSurfTmByRegionExtrusion( nLayerId, nGuideId, - ( dDepth + 2) * Z_AX()) -- creo una superficie di trim unica EgtSurfTmSubtract( nTrimStmId, nCutStmId) EgtErase( { nGuideId, nCutStmId}) return nTrimStmId end --------------------------------------------------------------------- -- funzione che crea il solido di estrusione principale local function CreateMainSurf( nOutlineId, dExtraLen, nProfileId, sSectionName, nLayerId) -- curva guida local nGuideId = EgtCopy( nOutlineId, nLayerId) EgtSetName( nGuideId, WIN_MAINGUIDE) EgtSetStatus( nGuideId, GDB_ST.OFF) EgtExtendCurveStartByLen( nGuideId, dExtraLen) EgtExtendCurveEndByLen( nGuideId, dExtraLen) -- se bottomrail sposto opportunamente l'outline local sProfileType = EgtGetInfo( nProfileId, WIN_PRF_TYPE) if sProfileType == WIN_RAIL or sProfileType == WIN_FILL_RAIL then local dOffs = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd') EgtOffsetCurve( nGuideId, -dOffs) end -- posiziono il profilo sulla curva guida : -- recupero il frame del profilo local nProfileFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) local frInvert = EgtFR( nProfileFrameId) frInvert:invert() -- lo applico a tutte le geometrie del profilo EgtTransform( EgtGetAllInGroup( nProfileId), frInvert) -- assegno come riferimento del profilo il punto start dell'outline EgtChangeGroupFrame( nProfileId, Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId))) -- recupero outline del profilo Main e lo estrudo local nSectionId = EgtGetFirstNameInGroup( nProfileId, sSectionName) local nMainExtrusionId = EgtSurfTmSwept( nLayerId, nSectionId, nGuideId, false, WIN_SURF_APPROX) EgtSetName( nMainExtrusionId, WIN_SRF_MAIN) return nMainExtrusionId end --------------------------------------------------------------------- -- funzione che crea il solido di un pezzo di telaio con cambio profilo local function CalcMixedFrameSolid( nOutlineId, nSolidLayerId, nProfileLayerId, nGeoLayerId, dGeoWidth) -- a) SOLIDO PRINCIPALE local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) -- creo i solidi corrispondenti ai diversi sottotratti uniformi del pezzo local nMixedOutlinesGrp = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_MIXED_OUTLINES) local vMixedOutlines = EgtGetAllInGroup( nMixedOutlinesGrp) local vMainExtrusions = {} for i = 1, #vMixedOutlines do local sSection = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. EgtGetName( vMixedOutlines[i]) .. WIN_SECTION local nMainExtrusionId = CreateMainSurf( vMixedOutlines[i], 2 * dGeoWidth, nMainProfileId, sSection, nSolidLayerId) table.insert( vMainExtrusions, nMainExtrusionId) end -- taglio i sottopezzi nei punti di intersezione per unirli local nMixedIntersectionsGrp = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_MIXED_INTERSECTIONS) local vIntersections = EgtGetAllInGroup( nMixedIntersectionsGrp) for i = 1, #vIntersections do -- creo la superficie di separazione tra i due sottopezzi local bSashFill = ( EgtGetName( vMixedOutlines[i]) == WIN_SASH) local vtDirS = EgtSV( vIntersections[i]) vtDirS:rotate( Z_AX(), EgtIf( bSashFill, -135, 135)) local vtDirE = EgtSV( vIntersections[i]) vtDirE:rotate( Z_AX(), EgtIf( bSashFill, 45, -45)) local nCrvTrim = EgtCurveCompo( nSolidLayerId, vIntersections[i], false) EgtAddCurveCompoLine( nCrvTrim, EgtSP( nCrvTrim) + dGeoWidth * vtDirS, false) EgtAddCurveCompoLine( nCrvTrim, EgtEP( nCrvTrim) + dGeoWidth * vtDirE) EgtMove( nCrvTrim, Z_AX()) local nStmTrim = EgtSurfTmByExtrusion( nSolidLayerId, nCrvTrim, - 2 * dGeoWidth * Z_AX()) -- taglio i due sottopezzi EgtSurfTmSubtract( vMainExtrusions[i+1], nStmTrim) EgtInvertSurf( nStmTrim) EgtSurfTmSubtract( vMainExtrusions[i], nStmTrim) EgtErase( nCrvTrim) EgtErase( nStmTrim) end -- unisco i sottopezzi in una sola superficie for i = 2, #vMainExtrusions do EgtSurfTmAdd( vMainExtrusions[1], vMainExtrusions[i]) EgtErase( vMainExtrusions[i]) end -- creo una copia dell'estrusione principale ( usata per ferramenta) local nOrigMainExtrusionId = EgtCopy( vMainExtrusions[1], nSolidLayerId) EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN) EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF) -- come guida tengo solo una copia della curva di outline local vMainGuideIds = EgtGetNameInGroup( nSolidLayerId, WIN_MAINGUIDE) EgtErase( vMainGuideIds) local nMainGuideId = EgtCopyGlob( nOutlineId, nSolidLayerId) EgtSetName( nMainGuideId, WIN_MAINGUIDE) EgtSetStatus( nMainGuideId, GDB_ST.OFF) -- b) TRIM START local nPrevGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_LEFT) local nStartProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_START) local nTrimSurfStart = CreateTrimSurf( nPrevGeoId, nStartProfileId, dGeoWidth, nSolidLayerId) EgtSetName( nTrimSurfStart, WIN_SRF_START) EgtSetStatus( nTrimSurfStart, GDB_ST.OFF) EgtSurfTmIntersect( vMainExtrusions[1], nTrimSurfStart) -- c) TRIM END local nNextGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) local nEndProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END) local nTrimSurfEnd = CreateTrimSurf( nNextGeoId, nEndProfileId, dGeoWidth, nSolidLayerId) EgtSetName( nTrimSurfEnd, WIN_SRF_END) EgtSetStatus( nTrimSurfEnd, GDB_ST.OFF) EgtSurfTmIntersect( vMainExtrusions[1], nTrimSurfEnd) return vMainExtrusions[1] end --------------------------------------------------------------------- -- funzione che crea il solido di un pezzo di split coinvolto da cambio profilo local function CalcMixedSplitSolid( nOutlineId, nSolidLayerId, nProfileLayerId, dGeoWidth) -- a) creo il solido di estrusione principale local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) local sSection = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_SECTION local nMainExtrusionId = CreateMainSurf( nOutlineId, 2 * dGeoWidth, nMainProfileId, sSection, nSolidLayerId) -- creo una copia local nOrigMainExtrusionId = EgtCopy( nMainExtrusionId, nSolidLayerId) EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN) EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF) -- b) trim start local nPrevProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_START) local nPrevMixedOutline = EgtGetInfo( nOutlineId, WIN_MIXED_REF_START, 'i') local nStmTrimStart = CreateMixedSplitTrimSurf( nPrevMixedOutline, nPrevProfileId, dGeoWidth, nSolidLayerId) EgtSetName( nStmTrimStart, WIN_SRF_START) EgtSetStatus( nStmTrimStart, GDB_ST.OFF) EgtSurfTmIntersect( nMainExtrusionId, nStmTrimStart) -- c) trim end local nNextProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END) local nNextMixedOutline = EgtGetInfo( nOutlineId, WIN_MIXED_REF_END, 'i') local nStmTrimEnd = CreateMixedSplitTrimSurf( nNextMixedOutline, nNextProfileId, dGeoWidth, nSolidLayerId) EgtSetName( nStmTrimEnd, WIN_SRF_END) EgtSetStatus( nStmTrimEnd, GDB_ST.OFF) EgtSurfTmIntersect( nMainExtrusionId, nStmTrimEnd) 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, dGeoWidth) else return CalcMixedFrameSolid( nOutlineId, nSolidLayerId, nProfileLayerId, nGeoLayerId, dGeoWidth) end end -- a) creo il solido di estrusione principale local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) local sSection = EgtIf( s_bSimplSolid, WIN_SIMPLIFIED, '') .. WIN_SECTION local nMainExtrusionId = CreateMainSurf( nOutlineId, 2 * dGeoWidth, nMainProfileId, sSection, nSolidLayerId) -- creo una copia ( usata per calcolo ferramenta) local nOrigMainExtrusionId = EgtCopy( nMainExtrusionId, nSolidLayerId) EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN) EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF) -- b) trim con i controprofili sullo start local vPrevGeoId = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT) local vStartProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_START) for i = 1, #vPrevGeoId do -- creo la superficie di trim local nTrimSurf = CreateTrimSurf( vPrevGeoId[i], vStartProfileId[i], dGeoWidth, nSolidLayerId) EgtSetStatus( nTrimSurf, GDB_ST.OFF) EgtSetName( nTrimSurf, WIN_SRF_START) -- eseguo intersezione per ottenere un solido unico ( tagliare le due superfici con EgtSurfTmCut e poi unirle potrebbe creare piccoli buchi legati alle diverse approssimazioni) EgtSurfTmIntersect( nMainExtrusionId, nTrimSurf) end -- c) trim con i controprofili sull'end local vNextGeoId = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) local vEndProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_END) for i = 1, #vNextGeoId do -- creo la superficie di trim local nTrimSurf = CreateTrimSurf( vNextGeoId[i], vEndProfileId[i], dGeoWidth, nSolidLayerId) EgtSetStatus( nTrimSurf, GDB_ST.OFF) EgtSetName( nTrimSurf, WIN_SRF_END) -- eseguo intersezione per ottenere un solido unico EgtSurfTmIntersect( nMainExtrusionId, nTrimSurf) end return nMainExtrusionId end --------------------------------------------------------------------- -- funzione che crea il solido del Fill local function CalcFillSolid( nPartId, nOutlineLayerId, nGeoLayerId) -- creo layer per solido local nSolidLayerId = EgtGroup( nPartId) EgtSetName( nSolidLayerId, WIN_SOLID) -- creo compo di outline local vOutlineList = EgtGetAllInGroup( nOutlineLayerId) local nCompoOutlineId = EgtCurveCompoByChain( nSolidLayerId, vOutlineList, EgtSP( vOutlineList[1]), false) -- recupero spessore vetro local dGlassThickness = EgtGetInfo( nGeoLayerId, WIN_GLASSTHICKNESS, 'd') local nSurfId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nCompoOutlineId, Z_AX() * dGlassThickness) EgtErase( nCompoOutlineId) end ---------------------------------------------------------------------------------- -- funzione che aggiorna il solido principale con quello associato ad una lavorazione partendo dalla sua curva local function UpdateSolidWithProcessingSurf( nProcId, nSolidId, nLayerId) if not EgtCurveIsClosed( nProcId) then return end local vtExtr = EgtCurveExtrusion( nProcId) local dThick = EgtCurveThickness( nProcId) local nRefCrv = nProcId -- se solidi semplificati approssimo in modo grossolano per velocizzare operazioni di subtract ( soprattuto su archi) if s_bSimplSolid then nRefCrv = EgtCopyGlob( nProcId, nLayerId) EgtApproxCurve( nRefCrv, GDB_CA.LINES, s_dSimplSolidApprox) end local nProcSolidId = EgtSurfTmByRegionExtrusion( nLayerId, nRefCrv, dThick * vtExtr) -- sottraggo al solido EgtSurfTmSubtract( nSolidId, nProcSolidId) EgtErase( nProcSolidId) if s_bSimplSolid then EgtErase( nRefCrv) end end ---------------------------------------------------------------------------------- --------------------------------- PREVIEW ---------------------------------------- ---------------------------------------------------------------------------------- local function CalcBottomRailPreview( nPreviewGrp, nOutlineId, nBottomRail, nProfileGrp, nGeoGrp, color) -- costruisco box complessivo degli zoccoli local vCrvs = {} -- la curva out corrisponde al geo in del pezzo bottom local nPartGeoIn = EgtGetFirstNameInGroup( nGeoGrp, WIN_GEO_IN) vCrvs[1] = EgtCopyGlob( nPartGeoIn, nPreviewGrp) local vNextOutlines = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'vi') local vEndProfiles = EgtGetNameInGroup( nProfileGrp, WIN_PRF_END) local b3ProfileEnd = GetProfileLocalBox( vEndProfiles[1]) vCrvs[2] = EgtCopyGlob( vNextOutlines[1], nPreviewGrp) EgtOffsetCurve( vCrvs[2], b3ProfileEnd:getMin():getX()) -- la curva in corrisponde al geo in dell'ultimo bottomrail local vBottomRails = EgtGetInfo( nOutlineId, WIN_REF_BOTTOMRAIL_PART, 'vi') local nBottomRailPart = vBottomRails[#vBottomRails] local nGeoLayer = EgtGetFirstNameInGroup( nBottomRailPart, WIN_GEO) local nGeoIn = EgtGetFirstNameInGroup( nGeoLayer, WIN_GEO_IN) vCrvs[3] = EgtCopyGlob( nGeoIn, nPreviewGrp) local vPrevOutlines = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'vi') local vStartProfiles = EgtGetNameInGroup( nProfileGrp, WIN_PRF_START) local b3ProfileStart = GetProfileLocalBox( vStartProfiles[1]) vCrvs[4] = EgtCopyGlob( vPrevOutlines[1], nPreviewGrp) EgtOffsetCurve( vCrvs[4], b3ProfileStart:getMin():getX()) -- creo il bordo TrimAndOrientOrderedCurves( vCrvs, true) local nCrvId = EgtCurveCompo( nPreviewGrp, vCrvs, false) EgtSetColor( nCrvId, EgtStdColor( 'BLACK')) EgtModifyCurveThickness( nCrvId, 0) -- creo la regione local nAreaId = EgtSurfFlatRegion( nPreviewGrp, {nCrvId}) EgtSetColor( nAreaId, color) EgtRelocateGlob( nCrvId, nAreaId, GDB_IN.AFTER) -- creo linee di divisione tra gli zoccoli if nBottomRail > 1 then local dLen = EgtCurveLength( vCrvs[1]) local dStep = 1 / nBottomRail for i = 1, nBottomRail - 1 do local pt = EgtUP( vCrvs[4], i * dStep) 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 nGeoGrp = EgtGetFirstNameInGroup( nPartId, WIN_GEO) local nProfileGrp = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) -- gruppo temporaneo per i conti local nGrpTmp = EgtGroup( nPreviewGrp) -- curva out è il geo out tranne nel caso di sash active/inactive per le quali considero l'outline per evitare sovrapposizioni local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') local bOnSplit = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b') if bOnSplit then local nCrv = EgtCopyGlob( nOutlineId, nGrpTmp) EgtSetName( nCrv, WIN_GEO_OUT) -- setto il nome per la funzione CreateGeoArea else local nGeoOut = EgtGetFirstNameInGroup( nGeoGrp, WIN_GEO_OUT) EgtCopyGlob( nGeoOut, nGrpTmp) end -- curva right local nEndJoint = EgtGetInfo( nOutlineId, WIN_ENDJOINT, 'i') if nEndJoint == WIN_PART_JNT.SHORT then -- se giunzione short per evitare sovrapposizioni devo fermarla al box del pezzo adiacente local vNextOutlines = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'vi') local vEndProfiles = EgtGetNameInGroup( nProfileGrp, WIN_PRF_END) for i = 1, #vNextOutlines do local nCrv = EgtCopyGlob( vNextOutlines[i], nGrpTmp) local b3Profile = GetProfileLocalBox( vEndProfiles[i]) local dOffs = b3Profile:getMin():getX() EgtOffsetCurve( nCrv, dOffs) EgtSetName( nCrv, WIN_RIGHT) end else -- altrimenti posso utilizzare la curva del geo local vGeoRight = EgtGetNameInGroup( nGeoGrp, WIN_RIGHT) for i = 1, #vGeoRight do EgtCopyGlob( vGeoRight[i], nGrpTmp) end end -- curva in local nGeoIn = EgtGetFirstNameInGroup( nGeoGrp, WIN_GEO_IN) EgtCopyGlob( nGeoIn, nGrpTmp) -- curva left local nStartJoint = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'i') if nStartJoint == WIN_PART_JNT.SHORT then local vPrevOutlines = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'vi') local vStartProfiles = EgtGetNameInGroup( nProfileGrp, WIN_PRF_START) for i = 1, #vPrevOutlines do local nCrv = EgtCopyGlob( vPrevOutlines[i], nGrpTmp) local b3Profile = GetProfileLocalBox( vStartProfiles[i]) local dOffs = b3Profile:getMin():getX() EgtOffsetCurve( nCrv, dOffs) EgtSetName( nCrv, WIN_LEFT) end else local vGeoLeft = EgtGetNameInGroup( nGeoGrp, WIN_LEFT) for i = 1, #vGeoLeft do EgtCopyGlob( vGeoLeft[i], nGrpTmp) end end -- eventuale trim delle curve se non ho considerato tutte le curve del geo if nStartJoint == WIN_PART_JNT.SHORT or nEndJoint == WIN_PART_JNT.SHORT or bOnSplit then TrimAndOrientOrderedCurves( EgtGetAllInGroup( nGrpTmp), true) end -- creo il bordo e la regione local nAreaId = CreateGeoArea( nGrpTmp, nPreviewGrp, true) local color = EgtGetColor( nPartId) EgtSetColor( nAreaId, color) local nCrvId = EgtGetPrev( nAreaId or GDB_ID.NULL) or GDB_ID.NULL EgtRelocateGlob( nCrvId, nAreaId, GDB_IN.AFTER) EgtSetColor( nCrvId, EgtStdColor( 'BLACK')) EgtModifyCurveThickness( nCrvId, 0) EgtErase( nGrpTmp) -- se bottom aggiungo anche eventuale preview del bottomrail if EgtGetName( nOutlineId) == WIN_BOTTOM then local nBottomRail = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or 0 if nBottomRail > 0 then CalcBottomRailPreview( nPreviewGrp, nOutlineId, nBottomRail, nProfileGrp, nGeoGrp, color) end end end ---------------------------------------------------------------------------------- local function CalcFillPreview( nPartId, nPreviewGrp) -- creo bordo a partire dall'outline local nAreaId = EgtGetInfo( nPartId, WIN_AREA, 'i') local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) local vOutlineList = EgtGetAllInGroup( nOutlineLayerId) local nCompoOutlineId = EgtCurveCompoByChain( nPreviewGrp, vOutlineList, EgtSP( vOutlineList[1]), false) -- creo area local nSurfId = EgtSurfFlatRegion( nPreviewGrp, {nCompoOutlineId}) EgtSetColor( nSurfId, EgtGetColor( nPartId)) EgtErase( nCompoOutlineId) end ---------------------------------------------------------------------------------- local function 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 end ---------------------------------------------------------------------------------- ---------------------------------- DOWELS ---------------------------------------- ---------------------------------------------------------------------------------- -- funzione che recupera la lunghezza del dowel local function CalcDowelLen( nDowelId, sKey, bFullOrShort) local sDefaultKey = EgtIf( bFullOrShort, WIN_DWL_TOP_PERP_LEN, WIN_DWL_TOP_PARA_LEN) local dLen = EgtGetInfo( nDowelId, sKey, 'd') or EgtGetInfo( nDowelId, sDefaultKey, 'd') dLen = dLen + s_dDowelTol return dLen end --------------------------------------------------------------------- -- funzione che calcola il riferimento dove posizionare i dowels local function CreateDowelFrameDest( nRefProfileType, nPrevGeo, nGeo, nRefOutline, bCurrFullOrShort, bSashOrFrame) -- 1) la direzione z è determinata dal pezzo short local vtZ if EgtGetType( nRefOutline) == GDB_TY.CRV_LINE then vtZ = EgtEV( nRefOutline) else -- se pezzo ad arco, recupero la direzione dalla curva nel punto estremo del geo local nGeoRefCrv if bCurrFullOrShort then nGeoRefCrv = EgtGetFirstNameInGroup( nPrevGeo, WIN_RIGHT) else nGeoRefCrv = EgtGetFirstNameInGroup( nGeo, WIN_LEFT) end local ptInt = EgtIP( nGeoRefCrv, nRefOutline, ORIG()) local dPar = EgtCurveParamAtPoint( nRefOutline, ptInt, 100 * GEO.EPS_SMALL) vtZ = EgtUV( nRefOutline, dPar, -1) end local frDest = Frame3d( ORIG(), - vtZ) -- 2) punto di origine local nPrevRight = EgtGetFirstNameInGroup( nPrevGeo, WIN_GEO_RIGHT) local ptRef1 = EgtIf( bCurrFullOrShort, EgtSP( nPrevRight), EgtEP( nPrevRight)) local nLeft = EgtGetFirstNameInGroup( nGeo, WIN_GEO_LEFT) local ptRef2 = EgtIf( bCurrFullOrShort, EgtSP( nLeft), EgtEP( nLeft)) -- riporto i punti sulla curva di outline su cui va posizionato il profilo con le spine local _, ptInt1 = EgtPointCurveDist( ptRef1, nRefOutline) local _, ptInt2 = EgtPointCurveDist( ptRef2, nRefOutline) -- nel caso di telaio conviene tenere il punto più "interno" visto che la correzione sarà fatta verso l'esterno -- nel caso di anta conviene tenere quello più "esterno" visto che la correzione sarà fatta verso l'interno ptInt1:toLoc( frDest) ptInt2:toLoc( frDest) local ptInt if ptInt1:getX() > ptInt2:getX() then ptInt = EgtIf( bSashOrFrame, Point3d( ptInt1), Point3d( ptInt2)) else ptInt = EgtIf( bSashOrFrame, Point3d( ptInt2), Point3d( ptInt1)) end ptInt:toGlob( frDest) -- modifico il punto di origine del frame nel punto individuato frDest:move( ptInt - ORIG()) return frDest end --------------------------------------------------------------------- -- funzione che posiziona il dowel tramite i riferimenti local function PositionDowel( nDowelId, frOrig, frDest, vtDir, nSurfId) -- posiziono il dowel utilizzando i riferimenti EgtTransform( nDowelId, frOrig, GDB_RT.GLOB) EgtTransform( nDowelId, frDest, GDB_RT.GLOB) EgtMove( nDowelId, 300 * vtDir) -- creo il tool corrispondente al dowel local dRad = EgtArcRadius( nDowelId) EgtCAvSetStdTool( s_dDowelTol, 2 * dRad, 0) -- calcolo spostamento per posizionarlo in corrispondenza della superficie local dStart = EgtCAvToolPosStm( EgtCP( nDowelId), - vtDir, nSurfId, - vtDir) EgtMove( nDowelId, - dStart * vtDir) end --------------------------------------------------------------------- -- funzione che crea il dowel e lo sottrae al solido local function CreateDowel( nOrigDowelId, nLayerId, frOrig, frDest, vtDir, nTestSurfId, dLen, sDowelSide, nMainExtrusionId) -- vtDir rivolta verso interno del pezzo local nDowelId = EgtCopyGlob( nOrigDowelId, nLayerId) EgtSetColor( nDowelId, Color3d( 128, 128, 128)) -- posiziono il dowel PositionDowel( nDowelId, frOrig, frDest, vtDir, nTestSurfId) -- assegno estrusione e spessore EgtModifyCurveExtrusion( nDowelId, - vtDir) EgtModifyCurveThickness( nDowelId, - dLen) -- setto info di lavorazione EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) EgtSetInfo( nDowelId, WIN_PRC_SIDE, sDowelSide) -- eventuale aggiornamento del solido if nMainExtrusionId then UpdateSolidWithProcessingSurf( nDowelId, nMainExtrusionId, nLayerId) end return nDowelId end --------------------------------------------------------------------- -- funzione che calcola la correzione da applicare al frame dei dowels per evitare che fuoriescano dal pezzo da un lato visibile ( esterno per ante ed interno per telaio) local function CalcDowelFrameCorrection( nOutlineId, nPrevOutlineId, nDowelRef, frOrig, frDest, nTestSurfPos, nTestSurfPosPrev, nTestSurf, vtMove, nLayerId, dLen, dPrevLen) local dMove = 0 -- se le curve sono due linee non serve correzione if EgtGetType( nOutlineId) == GDB_TY.CRV_LINE and EgtGetType( nPrevOutlineId) == GDB_TY.CRV_LINE then return dMove end -- 1) verifico posizione per il pezzo corrente -- posiziono il dowel local nDowel1 = EgtCopyGlob( nDowelRef, nLayerId) PositionDowel( nDowel1, frOrig, frDest, - frDest:getVersZ(), nTestSurfPos) -- verifico se la faccia di fondo fuoriesce dalla superficie di test local dMove1 = EgtCAvToolPosStm( EgtCP( nDowel1) - frDest:getVersZ() * dLen, frDest:getVersZ(), nTestSurf, vtMove) -- 2) verifico posizione per il pezzo precedente -- posiziono il dowel local nDowel2 = EgtCopyGlob( nDowelRef, nLayerId) PositionDowel( nDowel2, frOrig, frDest, frDest:getVersZ(), nTestSurfPosPrev) -- verifico se la faccia di fondo fuoriesce dalla superficie di test local dMove2 = EgtCAvToolPosStm( EgtCP( nDowel2) + frDest:getVersZ() * dPrevLen, - frDest:getVersZ(), nTestSurf, vtMove) EgtErase( nDowel1) EgtErase( nDowel2) -- calcolo la correzione complessiva dMove = max( dMove1, dMove2) + s_dDowelTol return dMove end --------------------------------------------------------------------- -- funzione che calcola i dowels tra due pezzi local function CalcDowels( nOrigOutlineId, nOrigPrevOutlineId, bSashOrFrame, nBottomRail) -- se soglia non ci sono dowels if EgtGetInfo( nOrigOutlineId, WIN_THRESHOLD, 'b') or EgtGetInfo( nOrigPrevOutlineId, WIN_THRESHOLD, 'b') then return end -- recupero i pezzi local nPart = EgtGetInfo( nOrigOutlineId, WIN_REF_PART, 'i') local nPrevPart = EgtGetInfo( nOrigPrevOutlineId, WIN_REF_PART, 'i') if nBottomRail then if EgtGetName( nOrigOutlineId) == WIN_BOTTOM then local vParts = EgtGetInfo( nOrigOutlineId, WIN_REF_BOTTOMRAIL_PART, 'vi') nPart = vParts[nBottomRail] else local vParts = EgtGetInfo( nOrigPrevOutlineId, WIN_REF_BOTTOMRAIL_PART, 'vi') nPrevPart = vParts[nBottomRail] end end -- recupero i layer delle lavorazioni local nLayerId = EgtGetFirstNameInGroup( nPart, WIN_PRC) local nPrevLayerId = EgtGetFirstNameInGroup( nPrevPart, WIN_PRC) -- recupero i profili local nProfileLay = EgtGetFirstNameInGroup( nPart, WIN_PROFILE) local nProfileId = EgtGetFirstNameInGroup( nProfileLay, WIN_PRF_MAIN) local nPrevProfileLay = EgtGetFirstNameInGroup( nPrevPart, WIN_PROFILE) local nPrevProfileId = EgtGetFirstNameInGroup( nPrevProfileLay, WIN_PRF_MAIN) -- copio curve outlines local nOutlineId = EgtCopyGlob( nOrigOutlineId, nLayerId) local nPrevOutlineId = EgtCopyGlob( nOrigPrevOutlineId, nLayerId) if nBottomRail then -- eventuale offset per bottomrail local dOffs local nRefCrv if EgtGetName( nOutlineId) == WIN_BOTTOM then nRefCrv = nOutlineId dOffs = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd') else nRefCrv = nPrevOutlineId dOffs = EgtGetInfo( nPrevProfileId, WIN_RAILDELTA, 'd') end EgtOffsetCurve( nRefCrv, - dOffs) end -- recupero i geo local nGeo = EgtGetFirstNameInGroup( nPart, WIN_GEO) local nPrevGeo = EgtGetFirstNameInGroup( nPrevPart, WIN_GEO) -- recupero i tipi di profilo local nPrevProfileType = GetOutlineProfileType( nPrevOutlineId, false, nBottomRail) local nProfileType = GetOutlineProfileType( nOutlineId, false, nBottomRail) -- caso particolare del triangolo : se lato top contro bottom il top deve essere gestito come un left/right if nProfileType == WIN_PRF.TOP and nPrevProfileType == WIN_PRF.BOTTOM then nProfileType = WIN_PRF.RIGHT elseif nProfileType == WIN_PRF.BOTTOM and nPrevProfileType == WIN_PRF.TOP then nPrevProfileType = WIN_PRF.LEFT end -- recupero i solidi local nPrevSolidId, nSolidId, nPrevSolidLay, nSolidLay if s_bCalcSolid then nSolidLay = EgtGetFirstNameInGroup( nPart, WIN_SOLID) nSolidId = EgtGetFirstNameInGroup( nSolidLay, WIN_SRF_MAIN) nPrevSolidLay = EgtGetFirstNameInGroup( nPrevPart, WIN_SOLID) nPrevSolidId = EgtGetFirstNameInGroup( nPrevSolidLay, WIN_SRF_MAIN) end -- recupero il tipo di giunzione local nJointType = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'i') if nBottomRail then if EgtGetName( nOutlineId) == WIN_BOTTOM then nJointType = WIN_PART_JNT.SHORT else nJointType = WIN_PART_JNT.FULL end end if nJointType == WIN_PART_JNT.ANGLED then -- TO DO elseif nJointType == WIN_PART_JNT.FULL then -- calcolo il riferimento del profilo local nFrameProfile = EgtGetFirstNameInGroup( nPrevProfileId, WIN_SECTIONFRAME) local frOrig = EgtFR( nFrameProfile, GDB_ID.ROOT) frOrig:invert() -- calcolo il riferimento su cui posizionare i dowels local frDest = CreateDowelFrameDest( nPrevProfileType, nPrevGeo, nGeo, nPrevOutlineId, true, bSashOrFrame) -- recupero info con la lunghezza ( dipendono dal profilo del pezzo full quindi dal corrente) local sLenKey = WIN_DWL_TOP_PERP_LEN local sPrevLenKey = WIN_DWL_TOP_PARA_LEN if nProfileType == WIN_PRF.BOTTOM then sLenKey = WIN_DWL_BOTTOM_PERP_LEN sPrevLenKey = WIN_DWL_BOTTOM_PARA_LEN elseif EgtExistsInfo( nPart, WIN_SASHTYPE) then -- verifico se è inactive sash dalla info settata per lavorazione sLenKey = WIN_DWL_INACTIVE_PERP_LEN sPrevLenKey = WIN_DWL_INACTIVE_PARA_LEN end -- superficie test per il posizionamento dei dowels : è la superficie in del pezzo full local nTestSurf if not s_bCalcSolid or s_bSimplSolid then local sCtrIn = WIN_OFST .. GetProfileCtrIn( nOrigOutlineId, nPrevOutlineId, nProfileId) -- controprofilo in del pezzo corrente nTestSurf = CreateProfileSurf( nOrigOutlineId, nProfileId, sCtrIn, 100, nLayerId) else -- è la superficie che viene utilizzata per trimmare l'end del pezzo prev local nOrigSurf = EgtGetFirstNameInGroup( nPrevSolidLay, WIN_SRF_END) nTestSurf = EgtCopyGlob( nOrigSurf, nLayerId) end local nTestSurfInverted = EgtCopyGlob( nTestSurf, nLayerId) EgtInvertSurf( nTestSurfInverted) -- superficie test per la traslazione dei dowels local nTestSurf2 if bSashOrFrame then -- se anta la superficie da cui non fuoriuscire è quella esterna del pezzo short, ovvero la superficie usata per trimmare lo start del pezzo corrente if not s_bCalcSolid or s_bSimplSolid then nTestSurf2 = CreateProfileSurf( nOrigPrevOutlineId, nPrevProfileId, WIN_OFST .. WIN_OUT, 100, nLayerId) else local nOrigSurf = EgtGetFirstNameInGroup( nSolidLay, WIN_SRF_START) nTestSurf2 = EgtCopyGlob( nOrigSurf, nLayerId) end EgtInvertSurf( nTestSurf2) else -- se telaio la superficie da cui non fuoriuscire è quella interna del pezzo short local sCtrIn2 = WIN_OFST .. GetProfileCtrIn( nOrigPrevOutlineId, nOutlineId, nPrevProfileId) nTestSurf2 = CreateProfileSurf( nOrigPrevOutlineId, nPrevProfileId, sCtrIn2, 100, nLayerId) end -- direzione per la traslazione dei dowels local vtMove = EgtIf( bSashOrFrame, - frDest:getVersX(), frDest:getVersX()) -- analizzo le singole file di dowels for k = 0, 3 do -- recupero i dowels della fila k-esima local vDowels = EgtGetNameInGroup( nPrevProfileId, WIN_DOWEL .. 'Row' .. tostring( k)) if #vDowels > 0 then -- recupero il dowel nella posizione più problematica ( per le ante è quello più esterno, per il telaio quello più interno) local nDowelRef = EgtIf( bSashOrFrame, vDowels[1], vDowels[#vDowels]) -- calcolo correzione da applicare al frame affinchè i dowels non fuoriescano da un lato visibile ( esterno per ante ed interno per telaio) local dLenCurr = CalcDowelLen( nDowelRef, sLenKey, true) local dLenPrev = CalcDowelLen( nDowelRef, sPrevLenKey, false) local dMove = CalcDowelFrameCorrection( nOutlineId, nPrevOutlineId, nDowelRef, frOrig, frDest, nTestSurfInverted, nTestSurf, nTestSurf2, vtMove, nLayerId, dLenCurr, dLenPrev) local frDestDowel = Frame3d( frDest) frDestDowel:move( dMove * vtMove) for i = 1, #vDowels do -- dowels per pezzo corrente ( full) local dLenFull = CalcDowelLen( vDowels[i], sLenKey, true) CreateDowel( vDowels[i], nLayerId, frOrig, frDestDowel, - frDestDowel:getVersZ(), nTestSurfInverted, dLenFull, WIN_PRC_SIDETYPE.IN, nSolidId) -- dowels per prezzo precedente ( short) local dLenShort = CalcDowelLen( vDowels[i], sPrevLenKey, false) CreateDowel( vDowels[i], nPrevLayerId, frOrig, frDestDowel, frDestDowel:getVersZ(), nTestSurf, dLenShort, WIN_PRC_SIDETYPE.RIGHT, nPrevSolidId) end end end EgtErase( nTestSurf) EgtErase( nTestSurfInverted) EgtErase( nTestSurf2) elseif nJointType == WIN_PART_JNT.SHORT then -- calcolo il riferimento del profilo local nFrameProfile = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) local frOrig = EgtFR( nFrameProfile, GDB_ID.ROOT) frOrig:invert() -- calcolo il riferimento su cui posizionare i dowels local frDest = CreateDowelFrameDest( nProfileType, nPrevGeo, nGeo, nOutlineId, false, bSashOrFrame) -- recupero info con la lunghezza ( dipendono dal profilo del pezzo full, quindi da prezzo prev) local sLenKey = WIN_DWL_TOP_PARA_LEN local sPrevLenKey = WIN_DWL_TOP_PERP_LEN if nPrevProfileType == WIN_PRF.BOTTOM then sLenKey = WIN_DWL_BOTTOM_PARA_LEN sPrevLenKey = WIN_DWL_BOTTOM_PERP_LEN elseif nPrevProfileType == WIN_PRF.BOTTOMRAIL or nPrevProfileType == WIN_PRF.BOTTOMRAIL_FINAL then sLenKey = WIN_DWL_BOTTOMRAIL_PARA_LEN sPrevLenKey = WIN_DWL_BOTTOMRAIL_PERP_LEN elseif EgtExistsInfo( nPrevPart, WIN_SASHTYPE) then -- verifico se è inactive sash dalla info settata per lavorazione sLenKey = WIN_DWL_INACTIVE_PARA_LEN sPrevLenKey = WIN_DWL_INACTIVE_PERP_LEN end -- superficie test per il posizionamento dei dowels -- è il controprofilo in del pezzo full quindi è la stessa superficie che viene utilizzata per trimmare lo start del pezzo corrente local nTestSurf if not s_bCalcSolid or s_bSimplSolid then local sCtrIn = WIN_OFST .. GetProfileCtrIn( nOrigPrevOutlineId, nOutlineId, nPrevProfileId) -- controprofilo del pezzo full nTestSurf = CreateProfileSurf( nOrigPrevOutlineId, nPrevProfileId, sCtrIn, 100, nLayerId) else local nOrigSurf = EgtGetFirstNameInGroup( nSolidLay, WIN_SRF_START) nTestSurf = EgtCopyGlob( nOrigSurf, nLayerId) end local nTestSurfInverted = EgtCopyGlob( nTestSurf, nLayerId) EgtInvertSurf( nTestSurfInverted) -- superficie test per la traslazione dei dowels local nTestSurf2 if bSashOrFrame then if not s_bCalcSolid or s_bSimplSolid then nTestSurf2 = CreateProfileSurf( nOrigOutlineId, nProfileId, WIN_OFST .. WIN_OUT, 100, nLayerId) else local nOrigSurf = EgtGetFirstNameInGroup( nPrevSolidLay, WIN_SRF_END) nTestSurf2 = EgtCopyGlob( nOrigSurf, nLayerId) end EgtInvertSurf( nTestSurf2) else local sCtrIn2 = WIN_OFST .. GetProfileCtrIn( nOutlineId, nPrevOutlineId, nProfileId) -- controprofilo del pezzo short nTestSurf2 = CreateProfileSurf( nOrigOutlineId, nProfileId, sCtrIn2, 100, nLayerId) end -- direzione per la traslazione dei dowels local vtMove = EgtIf( bSashOrFrame, - frDest:getVersX(), frDest:getVersX()) -- analizzo le singole file di dowels for k = 0, 3 do -- recupero i dowels sulla fila k-esima local vDowels = EgtGetNameInGroup( nProfileId, WIN_DOWEL .. 'Row' .. tostring(k)) if #vDowels > 0 then -- recupero il dowel nella posizione più problematica ( per le ante è quello più esterno, per il telaio quello più interno) local nDowelRef = EgtIf( bSashOrFrame, vDowels[1], vDowels[#vDowels]) -- calcolo correzione da applicare al frame affinchè i dowels non fuoriescano da un lato visibile ( esterno per ante ed interno per telaio) local dLenCurr = CalcDowelLen( nDowelRef, sLenKey, false) local dLenPrev = CalcDowelLen( nDowelRef, sPrevLenKey, true) local dMove = CalcDowelFrameCorrection( nOutlineId, nPrevOutlineId, nDowelRef, frOrig, frDest, nTestSurf, nTestSurfInverted, nTestSurf2, vtMove, nLayerId, dLenCurr, dLenPrev) local frDestDowel = Frame3d( frDest) frDestDowel:move( dMove * vtMove) for i = 1, #vDowels do -- dowels per pezzo corrente ( short) local dLenShort = CalcDowelLen( vDowels[i], sLenKey, false) CreateDowel( vDowels[i], nLayerId, frOrig, frDestDowel, - frDestDowel:getVersZ(), nTestSurf, dLenShort, WIN_PRC_SIDETYPE.LEFT, nSolidId) -- dowels per prezzo precedente ( full) local dLenFull = CalcDowelLen( vDowels[i], sPrevLenKey, true) CreateDowel( vDowels[i], nPrevLayerId, frOrig, frDestDowel, frDestDowel:getVersZ(), nTestSurfInverted, dLenFull, WIN_PRC_SIDETYPE.IN, nPrevSolidId) end end end EgtErase( nTestSurf) EgtErase( nTestSurfInverted) EgtErase( nTestSurf2) end EgtErase( nOutlineId) EgtErase( nPrevOutlineId) end --------------------------------------------------------------------- -- funzione che calcola i dowels tra uno split e i pezzi sui cui poggia local function CalcSplitDowels( nSplitId, vOutlines, bStartOrEnd) -- TO DO : da gestire incrocio dowels di tre pezzi -- recupero il pezzo dello split local nSplitPart = EgtGetInfo( nSplitId, WIN_REF_PART, 'i') -- recupero il profilo originale dello split e il suo frame local nSplitProfile = GetOutlineProfileId( nSplitId, false) local nSplitProfileFrameId = EgtGetFirstNameInGroup( nSplitProfile, WIN_SECTIONFRAME) local frOrig = EgtFR( nSplitProfileFrameId, GDB_ID.ROOT) frOrig:invert() -- recupero il gruppo delle lavorazioni local nSplitLayerId = EgtGetFirstNameInGroup( nSplitPart, WIN_PRC) -- recupero eventuale solido e superifici usate per il suo trim local nSplitSolidId, vTestSurf if s_bCalcSolid then local nSplitSolidLayerId = EgtGetFirstNameInGroup( nSplitPart, WIN_SOLID) nSplitSolidId = EgtGetFirstNameInGroup( nSplitSolidLayerId, WIN_SRF_MAIN) vTestSurf = EgtGetNameInGroup( nSplitSolidLayerId, EgtIf( bStartOrEnd, WIN_SRF_START, WIN_SRF_END)) end -- indviduo il lato su cui andranno i dowels local sSplitDowelSide = WIN_PRC_SIDETYPE.RIGHT if bStartOrEnd then sSplitDowelSide = WIN_PRC_SIDETYPE.LEFT end -- creo la superficie di test per verificare se dowel interno al pezzo local nSplitGeo = EgtGetFirstNameInGroup( nSplitPart, WIN_GEO) local nSplitSurf = CreateGeoArea( nSplitGeo, nSplitLayerId, false) local ptRef = EgtIf( bStartOrEnd, EgtSP( nSplitId), EgtEP( nSplitId)) -- se il bottom è soglia va ignorato local nStartIdx = EgtIf( EgtGetInfo( vOutlines[1], WIN_THRESHOLD, 'b'), 2, 1) for i = nStartIdx, #vOutlines do -- recupero il pezzo associato e il suo outline di riferimento local nPartId = FindAssociatedPart( vOutlines[i], true) local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i') local nProfileType = GetOutlineProfileType( nOutlineId, true) -- calcolo il frame di destinazione -- trovo intersezione dello split con lato In o Out del geo local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO) local nGeoCrvId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN) local ptInters = EgtIP( nGeoCrvId, nSplitId, ptRef) local sDowelSide = WIN_PRC_SIDETYPE.IN if not ptInters and nProfileType == WIN_PRF.SPLIT then nGeoCrvId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT) ptInters = EgtIP( nGeoCrvId, nSplitId, ptRef) sDowelSide = WIN_PRC_SIDETYPE.OUT end -- se non trovo intersezione passo al successivo if ptInters then -- TO DO : gestione split non lineare local frDest = Frame3d( ptInters, - EgtSV( nSplitId)) -- recupero il layer con le lavorazioni local nLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PRC) -- nel layer dei profili del pezzo aggiungo il profilo dello split posizionato correttamente local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) local nSplitProfileCopyId = EgtCopy( nSplitProfile, nProfileLayerId) local sSplitProfileType = EgtGetName( nSplitProfile) EgtSetInfo( nSplitProfileCopyId, WIN_PRF_TYPE, sSplitProfileType) EgtSetName( nSplitProfileCopyId, WIN_PRF_SPLIT) -- posiziono il profilo sulla curva di split EgtTransform( EgtGetAllInGroup( nSplitProfileCopyId), frOrig, GDB_RT.GLOB) EgtChangeGroupFrame( nSplitProfileCopyId, frDest, GDB_RT.GLOB) -- recupero eventuale solido local nSolidId if s_bCalcSolid then local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) nSolidId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_SRF_MAIN) end -- recupero le chiavi delle lunghezze ( dipendono dal profilo del pezzo su cui poggia lo split) local sSplitLenKey = WIN_DWL_TOP_PARA_LEN local sLenKey = WIN_DWL_TOP_PERP_LEN if nProfileType == WIN_PRF.BOTTOM then sSplitLenKey = WIN_DWL_BOTTOM_PARA_LEN sLenKey = WIN_DWL_BOTTOM_PERP_LEN elseif nProfileType == WIN_PRF.BOTTOMRAIL_FINAL then sSplitLenKey = WIN_DWL_RAILBOTTOM_PARA_LEN sLenKey = WIN_DWL_RAILBOTTOM_PERP_LEN elseif nProfileType == WIN_PRF.SPLIT then sSplitLenKey = WIN_DWL_SPLIT_PARA_LEN sLenKey = WIN_DWL_SPLIT_PERP_LEN end -- creo la superficie di test per il posizionamento dei dowels local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) local nTestSurf if not s_bCalcSolid or s_bSimplSolid then local bChangeProfile = EgtGetInfo( nSplitId, WIN_PRF_CHANGE, 'b') or false if bChangeProfile then local nMixedOutline = EgtGetInfo( nSplitId, EgtIf( bStartOrEnd, WIN_MIXED_REF_START, WIN_MIXED_REF_END), 'i') nTestSurf = CreateMixedSplitTrimSurf( nMixedOutline, nProfileId, 100, nLayerId) else local sCtr = WIN_OFST .. GetProfileCtrIn( nOutlineId, nSplitId, nProfileId) nTestSurf = CreateProfileSurf( nOutlineId, nProfileId, sCtr, 100, nLayerId) end else -- è la stessa superficie utilizzata per il trim del solido nTestSurf = EgtCopyGlob( vTestSurf[i], nSplitLayerId) end local nTestSurfInverted = EgtCopyGlob( nTestSurf, nSplitLayerId) EgtInvertSurf( nTestSurfInverted) -- calcolo le direzioni entranti nei pezzi local vtSplitDir = EgtIf( bStartOrEnd, - frDest:getVersZ(), frDest:getVersZ()) local vtDir = frDest:getVersZ() local _, _, nSide = EgtPointCurveDistSide( ptInters + vtDir, nGeoCrvId, Z_AX()) if nSide == 1 then -- se a destra della curva significa che la direzione è uscente dal pezzo e va invertita vtDir = - vtDir end -- creo la superficie di test per verificare se dowel interno al pezzo local nGeo = EgtGetFirstNameInGroup( nPartId, WIN_GEO) local nSurf = CreateGeoArea( nGeo, nLayerId, false) -- 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) EgtErase( nSurf) end end EgtErase( nSplitSurf) end --------------------------------------------------------------------- -- funzione che calcola le spine local function CalculateAreaDowels( nAreaId) local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then -- verifico se presente bottomrail local nBottomRails = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0 -- aggiungo le spine sui pezzi dell'area local nOutline = EgtGetFirstInGroup( nOutlineLayerId) local nPrevOutline = EgtGetLastInGroup( nOutlineLayerId) while nOutline do -- aggiungo spine su nOutline e nPrevOutline nel loro punto di giunzione CalcDowels( nOutline, nPrevOutline, nAreaType == WIN_AREATYPES.SASH) -- bottomrail if nBottomRails > 0 and ( EgtGetName( nOutline) == WIN_BOTTOM or EgtGetName( nPrevOutline) == WIN_BOTTOM) then for j = 1, nBottomRails do CalcDowels( nOutline, nPrevOutline, false, j) end end -- aggiorno per iterazione successiva nPrevOutline = nOutline nOutline = EgtGetNext( nOutline) end end -- verifico se c'e' uno split local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) if nSplitLayerId then local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL -- se split non è di tipo french ha un pezzo associato per il quale vanno calcolate le spine if nSplitType ~= WIN_SPLITTYPES.FRENCH then local nSplitId = EgtGetFirstInGroup( nSplitLayerId) -- start local vPrevOutlineId = EgtGetInfo( nSplitId, WIN_PREV_OUTLINES, 'vi') CalcSplitDowels( nSplitId, vPrevOutlineId, true) -- end local vNextOutlineId = EgtGetInfo( nSplitId, WIN_NEXT_OUTLINES, 'vi') CalcSplitDowels( nSplitId, vNextOutlineId, false) 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 -- ( analoga a GetProfileCtrIn) local function GetStripNearestToOutline( nPrevProfileId, nPrevOutlineId, nOutlineId) local sStripName = WIN_STRIP -- gestione particolare del caso di profilo di split if not EgtGetFirstNameInGroup( nPrevProfileId, sStripName) then -- recupero la curva di base outline da cui deriva il precedente local nPrevSouId = EgtGetInfo( nPrevOutlineId, WIN_COPY, 'i') local sPrevSouName repeat nPrevSouId = EgtGetInfo( nPrevSouId, WIN_SOU, 'i') sPrevSouName = EgtGetName( nPrevSouId or GDB_ID.NULL) until not nPrevSouId or sPrevSouName == WIN_SPLIT -- verifico da quale lato si trova la curva per decidere quale controprofilo considerare local _, _, nSide = EgtPointCurveDistSide( EgtMP( nOutlineId), nPrevSouId, Z_AX()) if nSide == 1 then sStripName = WIN_STRIP .. '1' -- dx else sStripName = WIN_STRIP .. '2' -- sx end end if s_bSimplSolid then sStripName = WIN_SIMPLIFIED .. sStripName end local nStripId = EgtGetFirstNameInGroup( nPrevProfileId, sStripName) return nStripId end --------------------------------------------------------------------- -- funzione che crea le linee di contorno massima e minima degli strip local function CreateStripGuideLines( nOutlineId, nStripId, nProfileId, nSolidLayerId) -- recupero il frame del profilo local nProfileFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) local frProfile = EgtFR( nProfileFrameId, GDB_ID.ROOT) -- se profilo e direzione prev uguali ( Prev e' Split), cambio segno all'offset di modo che rimanga sempre dalla stessa parte local vtE = EgtEV( nOutlineId) local bMainInvertOffset = AreSameVectorApprox( frProfile:getVersZ(), vtE) -- calcolo BBox local b3MainStrip = EgtGetBBoxRef( nStripId, GDB_BB.STANDARD, frProfile, GDB_RT.GLOB) -- calcolo offset per Strip local dDelta = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd') or 0 local dMainStripMinDelta = EgtIf( bMainInvertOffset, - b3MainStrip:getMax():getX() + dDelta, b3MainStrip:getMin():getX() - dDelta) local dMainStripMaxDelta = EgtIf( bMainInvertOffset, - b3MainStrip:getMin():getX() + dDelta, b3MainStrip:getMax():getX() - dDelta) local nStripMinOffsetId = EgtCopy( nOutlineId, nSolidLayerId) EgtOffsetCurve( nStripMinOffsetId, dMainStripMinDelta) local nStripMaxOffsetId = EgtCopy( nOutlineId, nSolidLayerId) EgtOffsetCurve( nStripMaxOffsetId, dMainStripMaxDelta) return nStripMinOffsetId, nStripMaxOffsetId end --------------------------------------------------------------------- -- funzione che crea gli Strip local function CreateStripFromOutline( nAreaId, nOutlineId) -- recupero il pezzo associato ( prendendo quello di bottomrail se esiste) local nPartId = FindAssociatedPart( nOutlineId, true) -- recupero layer per solido e per profili di estrusione local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) -- recupero gli outline precedente e successivo ( non serve utilizzare un WIN_PRF accurato perchè conta solo sia diverso da split) local nOutlineLayerId = EgtGetParent( nOutlineId) local vPrevOutlineId, vNextOutlineId = GetPrevNextOutline( WIN_PRF.NULL, nOutlineId, nOutlineLayerId) -- recupero i pezzi precedente e successivo, prendendo eventualmente quelli di bottomrail local nPrevPartId = FindAssociatedPart( vPrevOutlineId[1], true) local nNextPartId = FindAssociatedPart( vNextOutlineId[1], true) -- recupero profilo e controprofili local nMainProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) local nMainProfileId = EgtGetFirstNameInGroup( nMainProfileLayerId, WIN_PRF_MAIN) local nPrevProfileLayerId = EgtGetFirstNameInGroup( nPrevPartId, WIN_PROFILE) local nStartProfileId = EgtGetFirstNameInGroup( nPrevProfileLayerId, WIN_PRF_MAIN) local nNextProfileLayerId = EgtGetFirstNameInGroup( nNextPartId, WIN_PROFILE) local nEndProfileId = EgtGetFirstNameInGroup( nNextProfileLayerId, WIN_PRF_MAIN) -- a) estrudo il fermavetro -- recupero guida Main local nGuideId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_MAINGUIDE) -- recupero strip piu' vicino a prev outline e lo posiziono sulla guida local nMainStripId = GetStripNearestToOutline( nMainProfileId, nOutlineId, vPrevOutlineId[1]) local nSectionId = EgtCopyGlob( nMainStripId, nSolidLayerId) local nFrameProfileId = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTIONFRAME) local frOrig = EgtFR( nFrameProfileId, GDB_ID.ROOT) frOrig:invert() local frDest = Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId)) EgtTransform( nSectionId, frOrig) EgtTransform( nSectionId, frDest) -- creo estrusione local nMainStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nSectionId, nGuideId, false, WIN_SURF_APPROX) EgtSetName( nMainStripExtrusionId, WIN_SRF_STRIP) -- b) taglio con start -- recupero strip dello start piu' vicino ad outline local nStartStripId = GetStripNearestToOutline( nStartProfileId, vPrevOutlineId[1], nOutlineId) -- disegno guida start per lo strip trovando le intersezioni degli outline minimi e massimi tra MainStrip e StartStrip local nMainStripMinOffsetId, nMainStripMaxOffsetId = CreateStripGuideLines( nOutlineId, nMainStripId, nMainProfileId, nSolidLayerId) local nStartStripMinOffsetId, nStartStripMaxOffsetId = CreateStripGuideLines( vPrevOutlineId[1], nStartStripId, nStartProfileId, nSolidLayerId) local ptStripMinStart = FindIntersectionPoint( nMainStripMinOffsetId, nStartStripMinOffsetId, EgtSP( nMainStripMinOffsetId)) local ptStripMaxStart = FindIntersectionPoint( nMainStripMaxOffsetId, nStartStripMaxOffsetId, EgtSP( nMainStripMinOffsetId)) local nStartStripGuideId = EgtLine( nSolidLayerId, ptStripMinStart, ptStripMaxStart) EgtExtendCurveStartByLen( nStartStripGuideId, 10) EgtExtendCurveEndByLen( nStartStripGuideId, 10) EgtMove( nStartStripGuideId, Z_AX()) -- estrudo Strip start local b3RefStartProfile = GetProfileLocalBox( nStartProfileId) local nStartStripExtrusionId = EgtSurfTmByExtrusion( nSolidLayerId, nStartStripGuideId, - Z_AX() * ( b3RefStartProfile:getDimY() + 2), WIN_SURF_APPROX) EgtInvertSurf( nStartStripExtrusionId) -- intersezione con main EgtSurfTmIntersect( nMainStripExtrusionId, nStartStripExtrusionId) -- c) taglio con end -- recupero strip piu' vicino ad outline local nEndStripId = GetStripNearestToOutline( nEndProfileId, vNextOutlineId[1], nOutlineId) -- disegno guida end per lo strip trovando le intersezioni degli outline minimi e massimi tra MainStrip ed EndStrip local nEndStripMinOffsetId, nEndStripMaxOffsetId = CreateStripGuideLines( vNextOutlineId[1], nEndStripId, nEndProfileId, nSolidLayerId) local ptStripMinEnd = FindIntersectionPoint( nMainStripMinOffsetId, nEndStripMinOffsetId, EgtEP( nMainStripMinOffsetId)) local ptStripMaxEnd = FindIntersectionPoint( nMainStripMaxOffsetId, nEndStripMaxOffsetId, EgtEP( nMainStripMaxOffsetId)) local nEndStripGuideId = EgtLine( nSolidLayerId, ptStripMinEnd, ptStripMaxEnd) EgtExtendCurveStartByLen( nEndStripGuideId, 10) EgtExtendCurveEndByLen( nEndStripGuideId, 10) EgtMove( nEndStripGuideId, Z_AX()) -- estrudo Strip end local b3RefEndProfile = GetProfileLocalBox( nEndProfileId) local nEndStripExtrusionId = EgtSurfTmByExtrusion( nSolidLayerId, nEndStripGuideId, - Z_AX() * ( b3RefEndProfile:getDimY() + 2), WIN_SURF_APPROX) -- intersezione con main EgtSurfTmIntersect( nMainStripExtrusionId, nEndStripExtrusionId) -- cancello curve e superfici di costruzione EgtErase( nSectionId) EgtErase( { nMainStripMinOffsetId, nMainStripMaxOffsetId}) EgtErase( { nStartStripMinOffsetId, nStartStripMaxOffsetId, nStartStripGuideId, nStartStripExtrusionId}) EgtErase( { nEndStripMinOffsetId, nEndStripMaxOffsetId, nEndStripGuideId, nEndStripExtrusionId}) end ---------------------------------------------------------------------------------- ----------------------------- CALCOLO PEZZI ------------------------------------ ---------------------------------------------------------------------------------- -- funzione che stabilisce il nome del pezzo local function CalcPartName( nAreaId, nAreaType) local sName = '' if nAreaType == WIN_AREATYPES.FRAME then sName = WIN_FRAME EgtSetInfo( nAreaId, WIN_AREA_NAME, sName) elseif nAreaType == WIN_AREATYPES.SASH then s_nSashNbr = s_nSashNbr + 1 sName = WIN_SASH .. '_'.. tostring( s_nSashNbr) EgtSetInfo( nAreaId, WIN_AREA_NAME, sName) else -- per split o riempimento devo ricavare il nome del parent che lo contiene local nParentId = EgtGetParent( nAreaId) local nParentType = EgtGetInfo( nParentId, WIN_AREATYPE, 'i') while nParentType ~= WIN_AREATYPES.FRAME and nParentType ~= WIN_AREATYPES.SASH do nParentId = EgtGetParent( nParentId) nParentType = EgtGetInfo( nParentId, WIN_AREATYPE, 'i') end sName = EgtGetInfo( nParentId, WIN_AREA_NAME, sName) end return sName end --------------------------------------------------------------------- -- funzione che disegna l'apertura dell'anta local function DrawOpening( nAreaId) local nOpeningType = EgtGetInfo( nAreaId, WIN_OPENING_TYPE, 'i') if nOpeningType == WIN_OPENING_TYPES.NULL then return end -- creo gruppo per aperture local nOpeningLayId = EgtGroup( nAreaId) EgtSetName( nOpeningLayId, WIN_SASH_OPENING) -- verifico se anta ricevente per impostare tratteggio local nFactor = 7 local nPattern = 0xAAAA local nType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') local bStippled = ( nType == WIN_SASHTYPES.INACTIVE or nType == WIN_SASHTYPES.INACTIVE_IN or nType == WIN_SASHTYPES.INACTIVE_OUT) -- calcolo la curva di riferimento per il disegno dell'apertura local nOutlineLayId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) local vOutlines = EgtGetAllInGroup( nOutlineLayId) -- TODO gestire caso di triangolo if #vOutlines == 3 then return end local vCrvs = {} for i = 1, #vOutlines do local nCrv = EgtCopyGlob( vOutlines[i], nOpeningLayId) table.insert( vCrvs, nCrv) local nProfileId = GetOutlineProfileId( vCrvs[i], false) local b3FrameProfile = GetProfileLocalBox( nProfileId) local dOffs = b3FrameProfile:getMin():getX() EgtOffsetCurve( nCrv, dOffs) end TrimAndOrientOrderedCurves( vCrvs, false) local nGuideId = EgtCurveCompo( nOpeningLayId, vCrvs) local _, dParE = EgtCurveDomain( nGuideId) -- ribalta if nOpeningType == WIN_OPENING_TYPES.TILTONLY_TOP or nOpeningType == WIN_OPENING_TYPES.TILTTURN_LEFT or nOpeningType == WIN_OPENING_TYPES.TILTTURN_RIGHT then -- ricavo il punto sul top local ptMid = EgtUP( nGuideId, 2.5) if not EgtCurveIsARectangle( nGuideId) then -- per maggiore simmetria ricavo il punto sul top in corrispondenza del punto medio del bottom local ptTest = EgtUP( nGuideId, 0.5) local nLineTest = EgtLinePVL( nOpeningLayId, ptTest + Y_AX(), Y_AX(), 10000) ptMid = EgtIP( nGuideId, nLineTest, ORIG()) EgtErase( nLineTest) end EgtCurveCompoFromPoints( nOpeningLayId, { EgtSP( nGuideId), ptMid, EgtUP( nGuideId, 1)}) elseif nOpeningType == WIN_OPENING_TYPES.TILTONLY_BOTTOM then -- ricavo il punto sul bottom local ptMid = EgtUP( nGuideId, 0.5) EgtCurveCompoFromPoints( nOpeningLayId, { EgtUP( nGuideId, 2), ptMid, EgtUP( nGuideId, dParE - 1)}) end -- altre tipologie if nOpeningType == WIN_OPENING_TYPES.TILTTURN_LEFT or nOpeningType == WIN_OPENING_TYPES.TURNONLY_LEFT then -- battente sx local dLenRight = EgtCurveCompoLength( nGuideId, 1) local dLenLeft = EgtCurveCompoLength( nGuideId, dParE - 1) local dParMid = 1.5 -- se lato sinistro è il più corto, prendo sul destro il corrispondente del suo punto medio if dLenLeft < dLenRight - GEO.EPS_SMALL then dParMid = EgtCurveParamAtLength( nGuideId, EgtCurveCompoLength( nGuideId, 0) + dLenLeft * 0.5) end local nCrv = EgtCurveCompoFromPoints( nOpeningLayId, { EgtSP( nGuideId), EgtUP( nGuideId, dParMid), EgtUP( nGuideId, dParE - 1)}) -- tratteggio if bStippled then EgtSetStipple( nCrv, nFactor, nPattern) end elseif nOpeningType == WIN_OPENING_TYPES.TILTTURN_RIGHT or nOpeningType == WIN_OPENING_TYPES.TURNONLY_RIGHT then -- battente dx local dLenRight = EgtCurveCompoLength( nGuideId, 1) local dLenLeft = EgtCurveCompoLength( nGuideId, dParE - 1) local dParMid = dParE - 0.5 -- se lato destro è il più corto, prendo sul sinistro il corrispondente del suo punto medio if dLenRight < dLenLeft - GEO.EPS_SMALL then dParMid = EgtCurveParamAtLength( nGuideId, EgtCurveLength( nGuideId) - dLenRight * 0.5) end local nCrv = EgtCurveCompoFromPoints( nOpeningLayId, { EgtUP( nGuideId, 1), EgtUP( nGuideId, dParMid), EgtUP( nGuideId, 2)}) -- tratteggio if bStippled then EgtSetStipple( nCrv, nFactor, nPattern) end elseif nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_LEFT or nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT or nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_LEFT or nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_RIGHT then -- scorrevole e alzante scorrevole ( solo forma rettangolare) local bRight = ( nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT or nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_RIGHT) local dLen0 = EgtCurveCompoLength( nGuideId, 0) local dLen1 = EgtCurveCompoLength( nGuideId, 1) local dCoeff = 0.15 local ptS = EgtUP( nGuideId, 1.5) - dCoeff * dLen0 * X_AX() local ptE = EgtUP( nGuideId, dParE - 0.5) + dCoeff * dLen0 * X_AX() if bRight then ptS, ptE = ptE, ptS end local nCompo = EgtCurveCompoFromPoints( nOpeningLayId, { ptS, ptE}) if nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_LEFT or nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT then EgtAddCurveCompoLine( nCompo, ptS - dCoeff * dLen1 * Y_AX(), false) end local dAng = EgtIf( bRight, 135, 45) EgtLinePDL( nOpeningLayId, ptE, dAng, dCoeff * dLen0) EgtLinePDL( nOpeningLayId, ptE, - dAng, dCoeff * dLen0) elseif nOpeningType == WIN_OPENING_TYPES.FIXED then -- nessun disegno elseif nOpeningType == WIN_OPENING_TYPES.PIVOT then -- bilico rettangolare local nCompo = EgtCurveCompoFromPoints( nOpeningLayId, { EgtUP( nGuideId, 0.5), EgtUP( nGuideId, 1.5), EgtUP( nGuideId, 2.5), EgtUP( nGuideId, 3.5)}) EgtCloseCurveCompo( nCompo) -- TODO oblò end EgtErase( nGuideId) end --------------------------------------------------------------------- -- funzione che calcola l'ingombro dei pezzi del telaio e i loro solidi local function CreatePartFromOutline( nAreaLayerId, sName, nOutlineId, nOutlineCrvNbr, nBottomRail) -- se soglia ignoro local bThreshold = EgtGetInfo( nOutlineId or GDB_ID.NULL, WIN_THRESHOLD, 'b') or false if bThreshold then return end -- creo pezzo local nPartId = EgtGroup( GDB_ID.ROOT) -- inserisco riferimento alla sua area EgtSetInfo( nPartId, WIN_AREA, nAreaLayerId) local nAreaType = EgtGetInfo( nAreaLayerId, WIN_AREATYPE, 'i') local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaLayerId, WIN_OUTLINE) -- a) Telaio, anta o split if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH or nAreaType == WIN_AREATYPES.SPLIT then -- creo riferimenti tra pezzo e outline EgtSetInfo( nPartId, WIN_REF_OUTLINE, nOutlineId) if nBottomRail then -- aggiorno i riferimenti del bottomrail local vBottomRailParts = EgtGetInfo( nOutlineId, WIN_REF_BOTTOMRAIL_PART, 'vi') or {} table.insert( vBottomRailParts, nPartId) EgtSetInfo( nOutlineId, WIN_REF_BOTTOMRAIL_PART, vBottomRailParts) EgtSetInfo( nPartId, WIN_PART_TYPE, WIN_PART_TYPES.BOTTOMRAIL) else EgtSetInfo( nOutlineId, WIN_REF_PART, nPartId) end -- imposto nome del pezzo local sOutlineName = EgtIf( nBottomRail, WIN_BOTTOMRAIL .. '_' .. tostring( nBottomRail), EgtGetName( nOutlineId)) local sPartName = sName .. '_' .. sOutlineName EgtSetName( nPartId, sPartName) -- imposto il colore if sOutlineName == WIN_BOTTOM or sOutlineName == WIN_TOP or nBottomRail then EgtSetColor( nPartId, Color3d( 204, 102, 0)) elseif sOutlineName == WIN_RIGHT or sOutlineName == WIN_LEFT then EgtSetColor( nPartId, Color3d( 251, 128, 4)) else EgtSetColor( nPartId, Color3d( 255, 159, 57)) end -- ricavo il tipo di profilo local nProfileType = GetOutlineProfileType( nOutlineId, false, nBottomRail) -- disegno ingombro CalcFrameGeo( nPartId, nOutlineId, nOutlineCrvNbr, nOutlineLayerId, nProfileType, nBottomRail) -- calcolo eventuali curve ausiliarie per cambio profilo local bChangeProfile = EgtGetInfo( nOutlineId, WIN_PRF_CHANGE, 'b') or false if bChangeProfile and nProfileType ~= WIN_PRF.SPLIT then CalcMixedFrameCurves( nPartId, nOutlineId) end -- calcolo le lavorazioni associate ai profili CalcProfilingProcessings( nPartId, nOutlineId) -- calcolo il georaw per automatismo lavorazioni CalcGeoRaw( nPartId) -- disegno solido if s_bCalcSolid then CalcSolid( nPartId, nOutlineId) end -- b) Fill elseif nAreaType == WIN_AREATYPES.FILL then -- imposto nome del pezzo EgtSetName( nPartId, sName .. '_' .. WIN_FILL) EgtSetInfo( nPartId, WIN_PART_TYPE, WIN_PART_TYPES.FILL) -- ricavo tipo local nFillType = EgtGetInfo( nAreaLayerId, WIN_FILLTYPE, 'i') -- imposto colore e tipologia di riempimento if nFillType == WIN_FILLTYPES.GLASS then EgtSetColor( nPartId, Color3d( 71, 161, 255)) EgtSetAlpha( nPartId, 30) EgtSetInfo( nPartId, WIN_FILLTYPE, WIN_GLASS) elseif nFillType == WIN_FILLTYPES.WOOD then EgtSetColor( nPartId, Color3d( 194, 148, 103)) EgtSetInfo( nPartId, WIN_FILLTYPE, WIN_WOOD) end -- disegno ingombro local nGeoLayerId = CalcFillGeo( nPartId, nOutlineLayerId) -- disegno solido if s_bCalcSolid then CalcFillSolid( nPartId, nOutlineLayerId, nGeoLayerId) end end return nPartId end --------------------------------------------------------------------- -- funzione che cicla ricorsivamente su aree e sottoaree per calcolare i pezzi local function CalculateAreaParts( nAreaId) local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') -- recupero nome dei pezzi in quest'area local sName = CalcPartName( nAreaId, nAreaType) if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then -- creo pezzi per ogni outline local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) local vOutlines = EgtGetAllInGroup( nOutlineLayerId) for i = 1, #vOutlines do -- creo pezzo CreatePartFromOutline( nAreaId, sName, vOutlines[i], i) -- se di tipo bottom verifico se ha bottomrail if EgtGetName( vOutlines[i]) == WIN_BOTTOM then local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0 for j = 1, nBottomRail do CreatePartFromOutline( nAreaId, sName, vOutlines[i], i, j) end end end elseif nAreaType == WIN_AREATYPES.FILL then -- creo riempimento CreatePartFromOutline( nAreaId, sName) end -- verifico se c'e' uno split da realizzare local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) if nSplitLayerId then local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL -- se split non è di tipo french ha un pezzo associato if nSplitType ~= WIN_SPLITTYPES.FRENCH then local nSplitId = EgtGetFirstInGroup( nSplitLayerId) if nSplitId then -- creo pezzo split local nSplitPartId = CreatePartFromOutline( nAreaId, sName, nSplitId) -- disegno area di selezione per programma local nSelectionLayerId = EgtGroup( nAreaId) EgtSetName( nSelectionLayerId, WIN_SPLITSELECTION) EgtSetStatus( nSelectionLayerId, GDB_ST.OFF) local nSplitPartGeoId = EgtGetFirstNameInGroup( nSplitPartId, WIN_GEO) local nSelectionArea = CreateGeoArea( nSplitPartGeoId, nSelectionLayerId, false) EgtSetColor( nSelectionArea, 'YELLOW') EgtSetAlpha( nSelectionArea, 10) EgtMove( nSelectionArea, 10 * Z_AX()) end end elseif nAreaType ~= WIN_AREATYPES.FILL then if s_bCalcSolid then --- verifico se area successiva e' un fill local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') local nChildAreaType = EgtGetInfo( nChildAreaId or GDB_ID.NULL, WIN_AREATYPE, "i") if nChildAreaType == WIN_AREATYPES.FILL then -- se lo e', vuol dire che e' un vetro fisso, quindi calcolo strip dell'outline local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) while nOutlineId do CreateStripFromOutline( nAreaId, nOutlineId) nOutlineId = EgtGetNext( nOutlineId) end end end end -- se anta disegno apertura if nAreaType == WIN_AREATYPES.SASH then DrawOpening( nAreaId) end -- disegno area di selezione per programma local nSelectionLayerId = EgtGroup( nAreaId) EgtSetName( nSelectionLayerId, WIN_SELECTION) EgtSetStatus( nSelectionLayerId, GDB_ST.OFF) local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) local vOutlineList = EgtGetAllInGroup( nOutlineLayerId) local nCompoId = EgtCurveCompo( nSelectionLayerId, vOutlineList, false) local nSelectionArea = EgtSurfFlatRegion( nSelectionLayerId, nCompoId) EgtSetColor( nSelectionArea, 'YELLOW') EgtSetAlpha( nSelectionArea, 10) EgtMove( nSelectionArea, 10 * Z_AX()) EgtErase( nCompoId) -- calcolo i pezzi delle sottoaree local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') while nChildAreaId do CalculateAreaParts( nChildAreaId) nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*') end end ---------------------------------------------------------------------------------- ---------------------------------- TRONCHETTI ---------------------------------- ---------------------------------------------------------------------------------- -- funzione che spezza l'anta in corrispondenza dei tronchetti del telaio local function SplitArcByAlignment( nGeoIn, nGrp) -- recupero il pezzo del telaio corrispondente local nPartId = EgtGetParent( EgtGetParent( nGeoIn)) local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i') local nSouId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') local nAreaType = WIN_AREATYPES.NULL while nSouId and nAreaType ~= WIN_AREATYPES.FRAME do nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') or GDB_ID.NULL local nParentArea = EgtGetParent( EgtGetParent( nSouId)) or GDB_ID.NULL nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i') end if not nSouId then return end local nFrameOutlineId = EgtGetInfo( nSouId, WIN_COPY, 'i') local nFramePartId = EgtGetInfo( nFrameOutlineId, WIN_REF_PART, 'i') -- recupero le parti in cui era stato diviso l'arco del telaio local nFrameLogsLayer = EgtGetFirstNameInGroup( nFramePartId, WIN_LOGS) local vFrameLogs = EgtGetNameInGroup( nFrameLogsLayer, WIN_GEO_IN) local ptC = EgtCP( vFrameLogs[1]) local nCurrCrvId = EgtCopyGlob( nGeoIn, nGrp) local bInters = false for i = 1, #vFrameLogs - 1 do -- ricavo il punto di split sull'arco dell'anta local ptFrame = EgtEP( vFrameLogs[i]) local vtDir = ptFrame - ptC local nLineSplit = EgtLinePVL( nGrp, ptC, vtDir, vtDir:len() + 1000) local ptInt = EgtIP( nCurrCrvId, nLineSplit, ORIG()) EgtErase( nLineSplit) if ptInt then nCurrCrvId = EgtSplitCurveAtPoint( nCurrCrvId, ptInt) or GDB_ID.NULL bInters = true elseif bInters then -- se non ci sono più intersezioni esco return end end end --------------------------------------------------------------------- -- funzione che spezza l'arco in base al numero di pezzi local function SplitArcByNumber( nLogsNbr, nGeoIn, nGrp) local nCopy = EgtCopyGlob( nGeoIn, nGrp) EgtSplitCurve( nCopy, nLogsNbr) end --------------------------------------------------------------------- -- funzione che spezza gli archi per i tronchetti local function SplitArc( nLogsNbr, vSections, bAlign, dOverMatTot, nGeoIn, nGeoOut, nGrp) -- per allineamento con telaio if bAlign then return SplitArcByAlignment( nGeoIn, nGrp) -- per sezione elseif #vSections == 1 and nLogsNbr == 0 then -- dalla sezione ricavo il numero minimo di pezzi local dSection = vSections[1] - dOverMatTot local dROut = EgtArcRadius( nGeoOut) local dRIn = EgtArcRadius( nGeoIn) local dAng = abs( EgtArcAngCenter( nGeoIn)) local nParts if dSection < dROut - dRIn + GEO.EPS_SMALL then -- sezione troppo piccola -- TO DO : gestione errore EgtOutBox( 'Sezione tronchetto troppo piccola', '') elseif dSection > dROut + dRIn - GEO.EPS_SMALL then -- la sezione comprende già l'intero pezzo nParts = 1 else nParts = dAng / 2 / acos( ( dROut - dSection) / dRIn) nParts = ceil( nParts) end return SplitArcByNumber( nParts, nGeoIn, nGrp) -- per numero di pezzi else return SplitArcByNumber( nLogsNbr, nGeoIn, nGrp) end end --------------------------------------------------------------------- -- funzione che calcola la sezione dei tronchetti local function CalcLogsSection( nLogsNbr, vSections, bAlign, dOverMatTot, nGeoIn, nGeoOut, nGrp) -- se richiesta una sezione specifica senza vincoli sul numero di pezzi if not bAlign and #vSections == 1 and nLogsNbr == 0 then return vSections[1] end -- calcolo la sezione necessaria per la suddivisione scelta local dMySection = 0 local dROut = EgtArcRadius( nGeoOut) local dRIn = EgtArcRadius( nGeoIn) if bAlign then -- calcolo la massima sezione dai tronchetti ottenuti local vSplits = EgtGetAllInGroup( nGrp) for i = 1, #vSplits do local dAng = abs( EgtArcAngCenter( vSplits[i])) local dCurrSection = dROut - dRIn * cos( dAng / 2) if dCurrSection > dMySection then dMySection = dCurrSection end end dMySection = dMySection + dOverMatTot else -- ricavo la sezione dal numero di pezzi local dAng = abs( EgtArcAngCenter( nGeoIn)) dMySection = dROut - dRIn * cos( dAng / nLogsNbr / 2) + dOverMatTot end if #vSections == 0 then -- se no vincoli sulla sezione return dMySection else -- cerco la sezione più adatta dalla lista di sezioni disponibili table.sort( vSections) for i = 1, #vSections do if vSections[i] > dMySection - GEO.EPS_SMALL then return vSections[i] end end -- se non ho trovato la sezione errore EgtOutBox( 'Sezioni tronchetti troppo piccole per suddivisione richiesta', '') return nil end end --------------------------------------------------------------------- local function CalcLogs( nGrp, nGeoOut, dOverMatIn, dOverMatOut, dOverMatExt, dOverMatInt, dRefSection, bCutExtremities) -- recupero tutti i tratti dell'arco local vCrvsIn = EgtGetAllInGroup( nGrp) local ptC = EgtCP( vCrvsIn[1]) -- calcolo i tronchetti local dLenTot = 0 for i = 1, #vCrvsIn do local ptSIn = EgtSP( vCrvsIn[i]) local ptEIn = EgtEP( vCrvsIn[i]) -- recupero il tratto corrispondente sulla curva out local ptSOut, dParSOut, ptEOut, dParEOut if i == 1 then -- forzo a coincidere con l'estremo della curva out ptEOut = EgtEP( nGeoOut) dParEOut = 1 else _, ptEOut, dParEOut = EgtPointCurveDist( ptSIn, nGeoOut) end if i == #vCrvsIn then -- forzo a coincidere con l'estremo della curva out ptSOut = EgtSP( nGeoOut) dParSOut = 0 else _, ptSOut, dParSOut = EgtPointCurveDist( ptEIn, nGeoOut) end local nOut = EgtCopyGlob( nGeoOut, nGrp) EgtTrimCurveStartEndAtParam( nOut, dParSOut, dParEOut) -- creo composita corrispondente al pezzo local nCompo = EgtCurveCompo( nGrp, {vCrvsIn[i]}, false) EgtAddCurveCompoLine( nCompo, ptSOut) EgtAddCurveCompoCurve( nCompo, nOut, false) EgtCloseCurveCompo( nCompo) -- calcolo il frame per il tronchetto local ptM = EgtMP( vCrvsIn[i]) local vtRad = ptM - ptC local frRef = Frame3d( ptM, vtRad ^ Z_AX(), vtRad, Z_AX()) -- calcolo il box locale al frame local b3Ref = EgtGetBBoxRef( nCompo, GDB_BB.STANDARD, frRef) local ptMax = b3Ref:getMax() local ptMin = b3Ref:getMin() ptMin:setZ( ptMax:getZ()) -- per avere curve sullo stesso piano ( e gestire correttamente le intersezioni) -- verifico se necessario sovramateriale extra per raggiungere la sezione desiderata local dExtraSection = max( 0, dRefSection - b3Ref:getDimY() - dOverMatIn - dOverMatOut) -- lato bottom local nLineBottom = EgtLinePVL( nGrp, ptMin - ( dOverMatIn + 0.5 * dExtraSection) * Y_AX(), X_AX(), 10000) EgtExtendCurveStartByLen( nLineBottom, 10000) EgtTransform( nLineBottom, frRef) -- lato top local nLineTop = EgtLinePVL( nGrp, ptMax + ( dOverMatOut + 0.5 * dExtraSection) * Y_AX(), - X_AX(), 10000) EgtExtendCurveStartByLen( nLineTop, 10000) EgtTransform( nLineTop, frRef) -- lato right local nLineRight if i == 1 and not bCutExtremities then nLineRight = EgtLinePVL( nGrp, ptMin, - Y_AX(), 10000) EgtTransform( nLineRight, frRef) else nLineRight = EgtLine( nGrp, ptEOut, ptSIn) EgtExtendCurveEndByLen( nLineRight, 10000) end EgtOffsetCurve( nLineRight, EgtIf( i == 1, dOverMatExt, dOverMatInt)) EgtExtendCurveStartByLen( nLineRight, 10000) -- lato left local nLineLeft if i == #vCrvsIn and not bCutExtremities then nLineLeft = EgtLinePVL( nGrp, ptMax, Y_AX(), 10000) EgtTransform( nLineLeft, frRef) else nLineLeft = EgtLine( nGrp, ptEIn, ptSOut) EgtExtendCurveEndByLen( nLineLeft, 10000) end EgtOffsetCurve( nLineLeft, EgtIf( i == #vCrvsIn, dOverMatExt, dOverMatInt)) EgtExtendCurveStartByLen( nLineLeft, 10000) -- taglio le curve nei loro punti di intersezione local vCrvs = { nLineTop, nLineRight, nLineBottom, nLineLeft} TrimAndOrientOrderedCurves( vCrvs, false) -- TO DO : controllo lunghezza minima -- local dLenTop = EgtCurveLength( nLineTop) dLenTot = dLenTot + EgtCurveLength( nLineTop) -- creo il tronchetto local nLogCrv = EgtCurveCompo( nGrp, vCrvs) EgtSetName( nLogCrv, WIN_LOGS) EgtSetColor( nLogCrv, EgtStdColor( 'BLUE')) -- salvo i sovramateriali utilizzati nella curva EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_IN, dOverMatIn) EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_OUT, dOverMatOut) EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_LEFT, EgtIf( i == #vCrvsIn, dOverMatExt, dOverMatInt)) EgtSetInfo( nLogCrv, WIN_PRC_OVERMAT_RIGHT, EgtIf( i == 1, dOverMatExt, dOverMatInt)) EgtSetStatus( vCrvsIn[i], GDB_ST.OFF) EgtSetStatus( nOut, GDB_ST.OFF) EgtErase( nCompo) end -- salvo i dati della sezione ( analogamente a quanto fatto nel geo per pezzi lineari) EgtSetInfo( nGrp, WIN_GEOWIDTH, dRefSection) CopyInfo( nGrp, EgtGetParent( nGeoOut), WIN_GEOHEIGHT) EgtSetInfo( nGrp, WIN_GEOLEN, dLenTot) end --------------------------------------------------------------------- -- funzione che crea la spina per tronchetti local function CalcLogDowel( nOrigPartId, nCrvOut, bLeftOrRight, nProcLayerId, nProfileId, nInfoGrp, nSolidId) -- creo il frame per il posizionamento del dowel local nOutlineRef = EgtGetInfo( nOrigPartId, WIN_REF_OUTLINE, 'i') local ptRef = EgtIf( bLeftOrRight, EgtSP( nCrvOut), EgtEP( nCrvOut)) local _, ptOrig, dParOrig = EgtPointCurveDist( ptRef, nOutlineRef) local vtFrame = EgtUV( nOutlineRef, dParOrig, -1) local frDest = Frame3d( ptOrig, - vtFrame) -- calcolo direzione verso interno del pezzo local vtDir = frDest:getVersZ() if bLeftOrRight then vtDir = - vtDir end -- recupero i dati del dowel local dDowelDiam = EgtGetInfo( nInfoGrp, WIN_DWL_DIAM, 'd') local dDowelLen = EgtGetInfo( nInfoGrp, WIN_DWL_LOG_LEN, 'd') -- creo il dowel nel riferimento della sezione -- TO DO : recupero della sezione corretta nel caso di cambio profilo local nSectionId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTION) or EgtGetFirstNameInGroup( nProfileId, WIN_SASH .. WIN_SECTION) local nDowelId = EgtCircle( nProcLayerId, EgtGP( nSectionId), 0.5 * dDowelDiam) -- posiziono il dowel usando i riferimenti local nFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) local frOrig = EgtFR( nFrameId) frOrig:invert() EgtTransform( nDowelId, frOrig) EgtTransform( nDowelId, frDest) local nPartId = EgtGetParent( nProcLayerId) local dOverMat = EgtGetInfo( nPartId, EgtIf( bLeftOrRight, WIN_PRC_OVERMAT_LEFT, WIN_PRC_OVERMAT_RIGHT)) EgtMove( nDowelId, - vtDir * ( s_dDowelTol + dOverMat)) EgtModifyCurveExtrusion( nDowelId, - vtDir) local dLen = dDowelLen + dOverMat + s_dDowelTol EgtModifyCurveThickness( nDowelId, - dLen) -- setto info di lavorazione EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) EgtSetInfo( nDowelId, WIN_PRC_SIDE, EgtIf( bLeftOrRight, WIN_PRC_SIDETYPE.LEFT, WIN_PRC_SIDETYPE.RIGHT)) -- eventuale aggiornamento del solido if nSolidId then UpdateSolidWithProcessingSurf( nDowelId, nSolidId, nProcLayerId) end end --------------------------------------------------------------------- -- funzione che crea i pezzi dei tronchetti local function CalcLogParts( nOrigPartId, bFinishedLogs) local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) local nInfoGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_INFO_GRP) -- recupero i gruppi dal pezzo ad arco local nProfileLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_PROFILE) local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) local nOrigSolidLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_SOLID) local nOrigProcLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_PRC) -- recupero dimensione del profilo local nGeoLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_GEO) local dThick = EgtGetInfo( nGeoLayerId, WIN_GEOHEIGHT, 'd') -- recupero i tronchetti local nLogLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_LOGS) local vCrvIn = EgtGetNameInGroup( nLogLayerId, WIN_GEO_IN) local vCrvOut = EgtGetNameInGroup( nLogLayerId, WIN_GEO_OUT) local vLogs = {} for i = 1, #vCrvIn do -- creo il pezzo per il trochetto local nPartId = EgtGroup( GDB_ID.ROOT) EgtSetName( nPartId, WIN_LOGS) EgtSetColor( nPartId, Color3d( 204, 102, 0)) EgtSetStatus( nPartId, GDB_ST.OFF) table.insert( vLogs, nPartId) local nCrvIn = vCrvIn[i] local nCrvOut = vCrvOut[i] local nLogCrv = EgtGetNext( nCrvOut) -- setto le info con i sovramateriali corrispondenti CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_IN, 0) CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_OUT, 0) CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_LEFT, 0) CopyInfo( nPartId, nLogCrv, WIN_PRC_OVERMAT_RIGHT, 0) -- a) GEORAW local nGeoRawLayerId = EgtGroup( nPartId) EgtSetName( nGeoRawLayerId, WIN_GEO_RAW) local nGeoRawCrvId = EgtCopyGlob( nLogCrv, nGeoRawLayerId) EgtModifyCurveThickness( nGeoRawCrvId, - dThick) -- creo il frame ausiliario local vtX = EgtSV( nLogCrv) local frGeo = Frame3d( EgtSP( nLogCrv), vtX, Z_AX() ^ vtX, Z_AX()) local nFrameId = EgtFrame( nGeoRawLayerId, frGeo) EgtSetName( nFrameId, WIN_PRC_FRAME) -- b) SOLIDO local nSolidId if s_bCalcSolid then local nSolidLayerId = EgtGroup( nPartId) EgtSetName( nSolidLayerId, WIN_SOLID) if #vCrvIn == 1 then -- essendo singolo pezzo il solido è quello originale local nOrigSolidId = EgtGetFirstNameInGroup( nOrigSolidLayerId, WIN_SRF_MAIN) EgtRelocateGlob( nOrigSolidId, nSolidLayerId) elseif bFinishedLogs then -- recupero il solido originale e lo taglio opportunamente agli estremi local nOrigSolidId = EgtGetFirstNameInGroup( nOrigSolidLayerId, WIN_SRF_MAIN) nSolidId = EgtCopyGlob( nOrigSolidId, nSolidLayerId) local bBox = GetProfileLocalBox( nProfileId) local dDimY = bBox:getDimY() if i ~= 1 then local nTrimCrv = EgtLine( nSolidLayerId, EgtUP( nLogCrv, 2), EgtUP( nLogCrv, 1)) EgtMove( nTrimCrv, Z_AX()) local nTrimSrf = EgtSurfTmByExtrusion( nSolidLayerId, nTrimCrv, - Z_AX() * ( dDimY + 2), WIN_SURF_APPROX) EgtSurfTmIntersect( nSolidId, nTrimSrf) EgtErase( { nTrimCrv, nTrimSrf}) end if i ~= #vCrvIn then local nTrimCrv = EgtLine( nSolidLayerId, EgtSP( nLogCrv), EgtUP( nLogCrv, 3)) EgtMove( nTrimCrv, Z_AX()) local nTrimSrf = EgtSurfTmByExtrusion( nSolidLayerId, nTrimCrv, - Z_AX() * ( dDimY + 2), WIN_SURF_APPROX) EgtSurfTmIntersect( nSolidId, nTrimSrf) EgtErase( { nTrimCrv, nTrimSrf}) end else -- il solido è esattamente il tronchetto local bBox = GetProfileLocalBox( nProfileId) nSolidId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nLogCrv, - bBox:getDimY() * Z_AX()) EgtSetName( nSolidId, WIN_SOLID) end end -- c) LAVORAZIONI -- se unico tronchetto le lavorazioni sono quelle del pezzo originale if #vCrvIn == 1 then EgtRelocateGlob( nOrigProcLayerId, nPartId) EgtSetStatus( nOrigProcLayerId, GDB_ST.ON) return end local nProcLayerId = EgtGroup( nPartId) EgtSetName( nProcLayerId, WIN_PRC) -- profili in e out if bFinishedLogs then local nCrvInCopy = EgtCopyGlob( nCrvIn, nProcLayerId) local nSemiProfileInId = EgtGetInfo( nCrvInCopy, WIN_SEMI_PROFILE, 'i') GetProcessingInfoFromSemiProfile( nCrvInCopy, nSemiProfileInId) EgtSetStatus( nCrvInCopy, GDB_ST.ON) local nCrvOutCopy = EgtCopyGlob( nCrvOut, nProcLayerId) local nSemiProfileOutId = EgtGetInfo( nCrvOutCopy, WIN_SEMI_PROFILE, 'i') GetProcessingInfoFromSemiProfile( nCrvOutCopy, nSemiProfileOutId) EgtSetStatus( nCrvOutCopy, GDB_ST.ON) end -- profilo left if i == #vCrvIn and bFinishedLogs then -- recupero la curva di lavorazione dal pezzo originale local nLeftPrc = EgtGetFirstNameInGroup( nOrigProcLayerId, WIN_GEO_LEFT) EgtRelocateGlob( nLeftPrc, nProcLayerId) elseif i ~= #vCrvIn then -- minizinken local nLeftId = EgtLine( nProcLayerId, EgtUP( nLogCrv, 3), EgtSP( nLogCrv)) EgtSetName( nLeftId, WIN_LEFT) -- assegno le info di lavorazione EgtSetInfo( nLeftId, WIN_PRC_NTOOLS, 1) local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME) EgtSetInfo( nLeftId, WIN_PRC_TOOL_NAME .. '_1', sToolName) local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd') -- TO DO : verificare valore OffsR EgtSetInfo( nLeftId, WIN_PRC_OFFR .. '_1', dOffR) local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_1', 'd') EgtSetInfo( nLeftId, WIN_PRC_OFFL .. '_1', dOffL) end -- profilo right if i == 1 and bFinishedLogs then -- recupero la curva di lavorazione dal pezzo originale local nRightPrc = EgtGetFirstNameInGroup( nOrigProcLayerId, WIN_GEO_RIGHT) EgtRelocateGlob( nRightPrc, nProcLayerId) elseif i ~= 1 then -- minizinken local nRightId = EgtLine( nProcLayerId, EgtUP( nLogCrv, 1), EgtUP( nLogCrv, 2)) EgtSetName( nRightId, WIN_RIGHT) -- assegno info di lavorazione EgtSetInfo( nRightId, WIN_PRC_NTOOLS, 1) local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME) EgtSetInfo( nRightId, WIN_PRC_TOOL_NAME .. '_1', sToolName) local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd') -- TO DO : verificare valore OffsR EgtSetInfo( nRightId, WIN_PRC_OFFR .. '_1', dOffR) local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_2', 'd') EgtSetInfo( nRightId, WIN_PRC_OFFL .. '_1', dOffL) end -- dowels per incastro dei tronchetti if i ~= 1 then CalcLogDowel( nOrigPartId, nCrvOut, false, nProcLayerId, nProfileId, nInfoGrp, nSolidId) end if i ~= #vCrvIn then CalcLogDowel( nOrigPartId, nCrvOut, true, nProcLayerId, nProfileId, nInfoGrp, nSolidId) end -- se i tronchetti sono gestiti come pezzi finiti cerco le lavorazioni del pezzo orginale che appartengono al tronchetto if bFinishedLogs then local vProcessings = EgtGetAllInGroup( nOrigProcLayerId) local nSurfTest = EgtSurfFlatRegion( nProcLayerId, nLogCrv) for i = 1, #vProcessings do local sPrcType = EgtGetInfo( vProcessings[i], WIN_PRC_FEATURE_TYPE) -- forature if sPrcType == WIN_PRC_TYPE.HOLE then local sSide = EgtGetInfo( vProcessings[i], WIN_PRC_SIDE) -- se dowel sull'estremo lo assegno direttamente al tronchetto corrispondente if ( sSide == WIN_PRC_SIDETYPE.LEFT and i == #vCrvIn) or ( sSide == WIN_PRC_SIDETYPE.RIGHT and i == 1) then EgtRelocateGlob( vProcessings[i], nProcLayerId) end -- altrimenti verifico se interno al tronchetto corrente if sSide == WIN_PRC_SIDETYPE.IN then local _, _, nSide = EgtPointCurveDistSide( EgtCP( vProcessings[i]), nLogCrv, Z_AX()) if nSide == -1 then -- copio perchè la stessa lavorazione potrebbe coinvolgere più tronchetti EgtCopyGlob( vProcessings[i], nProcLayerId) else -- verifico anche la faccia di fondo local vtExtr = EgtCurveExtrusion( vProcessings[i]) local dThickness = EgtCurveThickness( vProcessings[i]) _, _, nSide = EgtPointCurveDistSide( EgtCP( vProcessings[i]) + dThickness * vtExtr, nLogCrv, Z_AX()) if nSide == -1 then EgtCopyGlob( vProcessings[i], nProcLayerId) end end end -- fermavetro elseif sPrcType == WIN_PRC_TYPE.STRIP_CUT then -- TO DO da sistemare local nStrip = EgtCopyGlob( vProcessings[i], nProcLayerId) EgtTrimCurveWithRegion( nStrip, nSurfTest, true, false) else -- TO DO lavorazioni legate alla ferramenta, cambio profilo end end EgtErase( nSurfTest) end end -- salvo nel pezzo ad arco i pezzi dei tronchetti associati EgtSetInfo( nOrigPartId, WIN_LOGS, vLogs) end --------------------------------------------------------------------- -- funzione che crea gli elementi ausiliari per la creazione del grezzo nell'automatismo delle lavorazioni local function CalcGeoRawFromLogs( nPartId) -- svuoto il GeoRaw per ricalcolarlo local nGeoRawLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO_RAW) EgtEmptyGroup( nGeoRawLayerId) -- recupero i vari tronchetti local nLogGrp = EgtGetFirstNameInGroup( nPartId, WIN_LOGS) local vLogCrvs = EgtGetNameInGroup( nLogGrp, WIN_LOGS) -- salvo le info di sovramateriale nel pezzo CopyInfo( nPartId, vLogCrvs[1], WIN_PRC_OVERMAT_IN, 0) CopyInfo( nPartId, vLogCrvs[1], WIN_PRC_OVERMAT_OUT, 0) local nOvermatLateral = EgtGetInfo( vLogCrvs[1], WIN_PRC_OVERMAT_RIGHT, 'd') EgtSetInfo( nPartId, WIN_PRC_OVERMAT_RIGHT, nOvermatLateral) EgtSetInfo( nPartId, WIN_PRC_OVERMAT_LEFT, nOvermatLateral) -- costruisco il grezzo a partire dai tronchetti local vCrvs = {} local vIdIn = {} -- recupero le curve in e out dei tronchetti for i = #vLogCrvs, 1, -1 do local nLineOut = EgtLine( nGeoRawLayerId, EgtUP( vLogCrvs[i], 0), EgtUP( vLogCrvs[i], 1)) local nLineIn = EgtLine( nGeoRawLayerId, EgtUP( vLogCrvs[i], 2), EgtUP( vLogCrvs[i], 3)) table.insert( vCrvs, nLineOut) table.insert( vIdIn, nLineIn) end local nLineR = EgtLine( nGeoRawLayerId, EgtEP( vCrvs[#vCrvs]), EgtSP( vIdIn[#vIdIn])) table.insert( vCrvs, nLineR) for i = #vIdIn, 1, -1 do table.insert( vCrvs, vIdIn[i]) end local nLineL = EgtLine( nGeoRawLayerId, EgtEP( vIdIn[1]), EgtSP( vCrvs[1])) table.insert( vCrvs, nLineL) -- taglio le curve nelle intersezioni ( va eliminato il sovramateriale per minizinken) TrimAndOrientOrderedCurves( vCrvs, false) -- 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 DrawHinges( nOutlineId, nSolidLayerId) -- dimensioni cerniere local dDimH = 16 local dDimV = 70 local dFilletRad = 5 local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') local dDelta = ( EgtSP( nOutlineId) - EgtSP( nBaseOutlineId)) * Z_AX() if dDelta < GEO.EPS_SMALL then return end local vtDir = EgtSV( nOutlineId) local vtDirIn = Vector3d( vtDir) vtDirIn:rotate( Z_AX(), -90) -- prima cerniera local pt1 = EgtSP( nOutlineId) - dDelta * Z_AX() local nCompo = EgtCurveCompoFromPoints( nSolidLayerId, { pt1 + dFilletRad * vtDir, pt1 + ( dDimV - dFilletRad) * vtDir}) EgtAddCurveCompoArcTg( nCompo, pt1 + dDimV * vtDir + dFilletRad * vtDirIn) EgtAddCurveCompoLine( nCompo, pt1 + dDimV * vtDir + ( dDimH - dFilletRad) * vtDirIn) EgtAddCurveCompoArcTg( nCompo, pt1 + ( dDimV - dFilletRad) * vtDir + dDimH * vtDirIn) EgtAddCurveCompoLine( nCompo, pt1 + dFilletRad * vtDir + dDimH * vtDirIn) EgtAddCurveCompoArcTg( nCompo, pt1 + ( dDimH - dFilletRad) * vtDirIn) EgtAddCurveCompoLine( nCompo, pt1 + dFilletRad * vtDirIn) EgtAddCurveCompoArcTg( nCompo, EgtSP( nCompo)) local nStm1 = EgtSurfTmByRegionExtrusion( nSolidLayerId, nCompo, dDelta * Z_AX()) EgtSetColor( nStm1, Color3d( 128, 128, 128)) EgtSetName( nStm1, WIN_HDW_HINGES) EgtErase( nCompo) -- seconda cerniera local pt2 = EgtEP( nOutlineId) - dDelta * Z_AX() - dDimV * vtDir local nStm2 = EgtCopyGlob( nStm1, nSolidLayerId) EgtMove( nStm2, pt2 - pt1) -- correzioni per telai non rettangolari local nFrameAreaId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*') local nFrameType = EgtGetInfo( nFrameAreaId, WIN_FRAME_TYPE, 'i') -- a) arco if nFrameType == WIN_FRAME_TYPES.ROUND_ARC or nFrameType == WIN_FRAME_TYPES.SEGMENTAL_ARC then local sName = EgtGetName( nOutlineId) -- calcolo il delta da applicare ( euristico, calcolato in base ai risultati ferramenta) local dDelta = 24 -- caso di arco a tutto sesto local dDeltaSegArc = 54.7 -- caso di arco ribassato if nFrameType == WIN_FRAME_TYPES.SEGMENTAL_ARC then -- nel caso di arco ribassato il delta va calcolato rispetto al frame della ferramenta local nAreaId = EgtGetParent( EgtGetParent( nOutlineId)) local nHdwFramesId = EgtGetFirstNameInGroup( nAreaId, WIN_HDW_FRAME) local sFrameName = EgtIf( sName == WIN_LEFT, 'B*', 'C*') local nFrameId = EgtGetFirstNameInGroup( nHdwFramesId, sFrameName) if sName == WIN_LEFT then dDelta = ( EgtSP( nFrameId) - EgtSP( nOutlineId)) * vtDir else dDelta = ( EgtEP( nOutlineId) - EgtSP( nFrameId)) * vtDir end dDelta = dDelta + dDeltaSegArc end -- traslazione if sName == WIN_LEFT then EgtMove( nStm1, dDelta * vtDir) else EgtMove( nStm2, - dDelta * vtDir) end -- b) trapezio elseif nFrameType == WIN_FRAME_TYPES.CHAMFER_SIDE then -- calcolo il delta da applicare. Euristico. Dal calcolo della ferramenta si vede che la cerniera si trova circa nel punto di intersezione tra nOutlineId e una retta inclinata -- come il top e passante per il frame della ferramenta local sName = EgtGetName( nOutlineId) local nOutlineLayId = EgtGetParent( nOutlineId) local nAreaId = EgtGetParent( nOutlineLayId) local nHdwFramesId = EgtGetFirstNameInGroup( nAreaId, WIN_HDW_FRAME) local sFrameName = EgtIf( sName == WIN_LEFT, 'B*', 'C*') local nFrameId = EgtGetFirstNameInGroup( nHdwFramesId , sFrameName) local nTopId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_TOP) local vtTop = EgtSV( nTopId) local ptRef = EgtIf( sName == WIN_LEFT, EgtSP( nOutlineId), EgtEP( nOutlineId)) local vtDist = EgtSP( nFrameId) - ptRef local dDelta = ( vtDist ^ vtTop):len() / ( vtTop ^ vtDir):len() if sName == WIN_LEFT then EgtMove( nStm1, dDelta * vtDir) else EgtMove( nStm2, - dDelta * vtDir) end end end --------------------------------------------------------------------- -- funzione che disegna la maniglia local function DrawHandle( 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 --------------------------------------------------------------------- -- funzione che disegna la ferramenta local function DrawSashHardware( nAreaId, nRefAreaId, nSolidLayerId) 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, nSolidLayerId) -- recupero lato maniglia local vOptions = EgtGetInfo( nRefAreaId, WIN_HDW_OPTIONS, 'vs') or {} local sHandleSide = 'Sx' local nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_RIGHT) for i = 1, #vOptions do local vString = EgtSplitString( vOptions[i], '=') if vString[1] == 'PosizioneManiglia' then if vString[2] == 'destra' then sHandleSide = 'Dx' nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_LEFT) elseif vString[2] == 'sopra' then nOutlineId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_TOP) end break end end -- altezza maniglia è fissata a metà del lato ( con compensazione per frame di riferimento della ferramenta) local nPartId = EgtGetInfo( nOutlineId, WIN_REF_PART, 'i') local nProfileLayId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) local nProfileId = EgtGetFirstNameInGroup( nProfileLayId, EgtIf( sHandleSide == 'Sx', WIN_PRF_START, WIN_PRF_END)) local dGapHardware = EgtGetInfo( nProfileId, WIN_GAPDELTA, 'd') local dHandleH = 0.5 * EgtCurveLength( nOutlineId) - dGapHardware -- disegno maniglia DrawHandle( nOutlineId, sHandleSide, dHandleH, nSolidLayerId) -- 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 = 400 local vOptions = EgtGetInfo( nRefAreaId, 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 dHandleH = tonumber( vString[2]) break end end DrawHandle( nOutlineId, sHandleSide, dHandleH, nSolidLayerId, true) -- 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 dati della maniglia local sHandleSide = EgtGetInfo( nRefAreaId, WIN_HDW_HANDLE) local dHandleH = 500 local vOptions = EgtGetInfo( nRefAreaId, 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 dHandleH = tonumber( vString[2]) break end end -- cerniere if nSashType == WIN_SASHTYPES.INACTIVE or nSashType == WIN_SASHTYPES.INACTIVE_OUT or nSashType == WIN_SASHTYPES.ACTIVE or nSashType == WIN_SASHTYPES.ACTIVE_OUT then -- le cerniere vanno messe sul lato che poggia sul telaio local nBaseOutlineId = EgtGetInfo( nLeftId, WIN_COPY, 'i') local bLeftInactive = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b') or false DrawHinges( EgtIf( bLeftInactive, nRightId, nLeftId), nSolidLayerId) elseif nSashType == WIN_SASHTYPES.NULL then -- è il lato senza maniglia if sHandleSide == 'Sx' then DrawHinges( nLeftId, nSolidLayerId) else DrawHinges( nRightId, nSolidLayerId) end end -- maniglia if nSashType == WIN_SASHTYPES.ACTIVE or nSashType == WIN_SASHTYPES.ACTIVE_IN or nSashType == WIN_SASHTYPES.NULL then if sHandleSide == 'Sx' then DrawHandle( nRightId, sHandleSide, dHandleH, nSolidLayerId) else DrawHandle( nLeftId, sHandleSide, dHandleH, nSolidLayerId) end end end end --------------------------------------------------------------------- -- funzione che calcola i dati necessari per la ferramenta local function SearchSash( nAreaId, SashList) -- verifico il tipo local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') if nAreaType == WIN_AREATYPES.SASH then -- creo gruppo temporaneo per i conti local nOutlineOffsetLayerId = EgtGroup( nAreaId) -- recupero gruppi dei profili local nProfileId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileId, WIN_SASH) local nFrameProfileLayerId = EgtGetFirstNameInGroup( nProfileId, WIN_FRAME) -- creo gruppo per i riferimenti della ferramenta per l'anta local nHdwSashLayerId = EgtGroup( nAreaId) EgtSetName( nHdwSashLayerId, WIN_HDW_FRAME) EgtSetStatus( nHdwSashLayerId, GDB_ST.OFF) -- recupero o creo gruppo per i riferimenti della ferramenta per il telaio local nFrameAreaId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*') local nHdwFrameLayerId = EgtGetFirstNameInGroup( nFrameAreaId, WIN_HDW_FRAME) if not nHdwFrameLayerId then nHdwFrameLayerId = EgtGroup( nFrameAreaId) EgtSetName( nHdwFrameLayerId, WIN_HDW_FRAME) EgtSetStatus( nHdwFrameLayerId, GDB_ST.OFF) end -- verifico se alzante scorrevole local bSlide = EgtGetInfo( nFrameAreaId, WIN_SLIDE_WINDOW, 'b') or false -- ricostruisco gli outlines dell'anta in corrispondenza del canalino della ferramenta ( orgine dei riferimenti) local vOutlineCopy = {} local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) while nOutlineId do local sProfileType = EgtGetInfo( nOutlineId, WIN_PROFILETYPE) local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sProfileType) local dGapDelta = EgtGetInfo( nSashProfileId, WIN_GAPDELTA, 'd') local nOutlineCopyId = EgtCopy( nOutlineId, nOutlineOffsetLayerId) EgtOffsetCurve( nOutlineCopyId, - dGapDelta) table.insert( vOutlineCopy, nOutlineCopyId) -- setto info ausiliarie sulla curva EgtSetInfo( nOutlineCopyId, 'ORIG', nOutlineId) CopyInfo( nOutlineCopyId, nSashProfileId, WIN_GAPDELTAZ) local b3Profile = GetProfileLocalBox( nSashProfileId) EgtSetInfo( nOutlineCopyId, WIN_GAPDELTAZ .. 2, b3Profile:getDimY()) nOutlineId = EgtGetNext( nOutlineId) end TrimAndOrientOrderedCurves( vOutlineCopy, false) -- costruisco i riferimenti local tFrame = {} for nIndex = 1, #vOutlineCopy do -- 1) Riferimenti ANTA local ptOrig = EgtEP( vOutlineCopy[nIndex]) local sOrigName = string.char( string.byte( 'A') + #vOutlineCopy - nIndex) local vtDir = EgtEV( vOutlineCopy[nIndex]) local nFA1Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig, - vtDir, vtDir ^ Z_AX(), Z_AX())) EgtSetName( nFA1Id, sOrigName .. '.FA1') local vtIn = Vector3d( vtDir) vtIn:rotate( Z_AX(), -90) local dGapDeltaZ = EgtGetInfo( vOutlineCopy[nIndex], WIN_GAPDELTAZ, 'd') local nFA2Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig - dGapDeltaZ * Z_AX(), - vtDir, vtDir ^ vtIn, vtIn)) EgtSetName( nFA2Id, sOrigName .. '.FA2') local dGapDeltaZ2 = EgtGetInfo( vOutlineCopy[nIndex], WIN_GAPDELTAZ .. 2, 'd') local nFA3Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig - dGapDeltaZ2 * Z_AX(), - vtDir, vtDir ^ -Z_AX(), -Z_AX())) EgtSetName( nFA3Id, sOrigName .. '.FA3') -- 2) Riferimenti TELAIO -- ricavo elemento su cui poggia ( è il primo parent con un profilo associato. Potrebbe essere uno split in sottoarea del telaio o potrebbe non -- esistere nel caso di french split) local nOrigOutlineId = EgtGetInfo( vOutlineCopy[nIndex], 'ORIG', 'i') local nBaseOutlineId = EgtGetInfo( nOrigOutlineId, WIN_COPY, 'i') local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') local sProfileFrame = EgtGetInfo( nSouId, WIN_PROFILETYPE) while nSouId and not sProfileFrame do nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') sProfileFrame = EgtGetInfo( nSouId or GDB_ID.NULL, WIN_PROFILETYPE) end if nSouId then -- ricavo aria lato telaio local nFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileLayerId, sProfileFrame, 'i') local dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA, 'd') -- se deriva da split verifico il lato if EgtGetName( nSouId) == WIN_SPLIT then local bSameDir = AreSameVectorApprox( EgtSV( nSouId), EgtSV( nBaseOutlineId)) -- recupero informazione dal lato corretto ( split orizzontale) if not dGapDeltaOut then if bSameDir then dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '2', 'd') else dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '1', 'd') end end -- verifico il segno dell'offset if not bSameDir then dGapDeltaOut = - dGapDeltaOut end end local nOutlineOutId = EgtCopy( nSouId, nOutlineOffsetLayerId) EgtOffsetCurve( nOutlineOutId, - dGapDeltaOut) -- recupero origine come proiezione sul telaio dell'origine dell'anta local _, ptOrigFr = EgtPointCurveDist( ptOrig, nOutlineOutId) if bSlide then -- nel caso di alzante scorrevole l'origine non è proiettata ptOrigFr = EgtEP( nOutlineOutId) end local nFT1Id = EgtFrame( nHdwFrameLayerId, Frame3d( ptOrigFr, - vtDir, vtDir ^ Z_AX(), Z_AX())) EgtSetName( nFT1Id, sOrigName .. '.FT1') table.insert( tFrame, nFT1Id) local vtFrameIn = Vector3d( vtDir) vtFrameIn:rotate( Z_AX(), 90) local dFrameGapDeltaZ = EgtGetInfo( nFrameProfileId, WIN_GAPDELTAZ, 'd') local nFT2Id = EgtFrame( nHdwFrameLayerId, Frame3d( ptOrigFr - dFrameGapDeltaZ * Z_AX(), - vtDir, vtDir ^ vtFrameIn, vtFrameIn)) EgtSetName( nFT2Id, sOrigName .. '.FT2') table.insert( tFrame, nFT2Id) local b3FrameProfile = GetProfileLocalBox( nFrameProfileId) local dGapDeltaZ2 = b3FrameProfile:getDimY() local nFT3Id = EgtFrame( nHdwFrameLayerId, Frame3d( ptOrigFr - dGapDeltaZ2 * Z_AX(), - vtDir, vtDir ^ -Z_AX(), -Z_AX())) EgtSetName( nFT3Id, sOrigName .. '.FT3') table.insert( tFrame, nFT3Id) end end -- preparo tabella per l'anta con i dati necessari per la ferramenta local tSash = { nAreaId = nAreaId} -- calcolo in centro per ordinamento local b3Outline = EgtGetBBox( nOutlineLayerId, GDB_BB.STANDARD) tSash.ptCenter = b3Outline:getCenter() -- calcolo le dimensioni tSash.LHeight = EgtCurveLength( vOutlineCopy[4]) tSash.RHeight = EgtCurveLength( vOutlineCopy[2]) tSash.BWidth = EgtCurveLength( vOutlineCopy[1]) if EgtGetType( vOutlineCopy[3]) == GDB_TY.CRV_ARC then -- tSash.BCLength = EgtCurveLength( vOutlineCopy[3]) -- in alternativa a BCArrow, è il parametro LBBA nel file di richiesta tSash.BCArrow = dist( EgtMP( vOutlineCopy[3]), 0.5 * ( EgtEP( vOutlineCopy[3]) + EgtSP( vOutlineCopy[3]))) end -- salvo i frame del telaio associati tSash.Frame = tFrame table.insert( SashList, tSash) EgtErase( nOutlineOffsetLayerId) end -- verifico se ci sono sotto-aree local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') while nChildAreaId do -- lancio costruzione pezzi di quell'area SearchSash( nChildAreaId, SashList) nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*') end end --------------------------------------------------------------------- -- funzione che aggiunge l'hardware function WinCalculate.AddHardwareForSash( nFrameId, bOnlyRequest) -- 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 bOnlyRequest then nFavourite = WDG.HDWFAVOURITE end 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 bOnlyRequest then sHandle = WDG.HDWHANDLE end if not sHandle then EgtOutLog('Warning! No hardware handle set!') return end -- creo file di richiesta ferramenta local sNow = os.date( '_%Y_%m_%d_%H_%M_%S', os.time()) local sInputFile = 'a:\\InputBatch\\Input' .. sNow .. '.txt' local sAGBOutputKitFile = 'C:\\AGB3000NG\\OutputBatch\\Output' .. sNow .. '.txt' local sAGBOutputPositionFile = 'C:\\AGB3000NG\\OutputBatch\\OutputPosition' .. sNow .. '.txt' local sAGBOutputLavFile = 'C:\\AGB3000NG\\OutputBatch\\OutputLav' .. sNow .. '.txt' local sOutputKitFile = 'a:\\OutputBatch\\Output' .. sNow .. '.txt' local sOutputPositionFile = 'a:\\OutputBatch\\OutputPosition' .. sNow .. '.txt' local sOutputLavFile = 'a:\\OutputBatch\\OutputLav' .. sNow .. '.txt' -- Apro file Input in scrittura local fhInput = io.open( sInputFile, 'w') if not fhInput then EgtOutLog( 'Error opening file ' .. sInputFile) return false end local sText = 'S_NAME=' .. nFavourite .. '\n' .. 'RECORDID=15A' .. '\n' if s_bCalcHardwareKit then sText = sText .. 'EXTINFO=ON\n' .. 'OUTPUTKIT=' .. sAGBOutputKitFile .. '\n' end if s_bCalcHardwarePosition then sText = sText .. 'OUTPUTARTICLEPOSITION=' .. sAGBOutputPositionFile .. '\n' end -- recupero il tipo di apertura local nOpeningType = WIN_OPENING_TYPES.NULL if #SashList > 0 then nOpeningType = EgtGetInfo( SashList[1].nAreaId, WIN_OPENING_TYPE, 'i') end -- recupero se scorrevole local bSlide = EgtGetInfo( nFrameId, WIN_SLIDE_WINDOW, 'b') or false if bSlide then -- le dimensioni per alzante scorrevole sono quelle del telaio local nOutlineLayId = EgtGetFirstInGroup( nFrameId, WIN_AREAOUTLINE) local nBottomId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_BOTTOM) local dMet = EgtCurveLength( nBottomId) local nLeftId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_LEFT) local dHet = EgtCurveLength( nLeftId) sText = sText .. 'MET=' .. tostring( dMet) .. '\n' sText = sText .. 'HET=' .. tostring( dHet) .. '\n' else if #SashList >= 1 and abs( SashList[1].LHeight - SashList[1].RHeight) < GEO.EPS_SMALL then sText = sText .. 'HBB=' .. tostring( SashList[1].LHeight) .. '\n' else for nSashIndex = 1, #SashList do if nSashIndex == 1 then sText = sText .. 'HBB_sx=' .. tostring( SashList[nSashIndex].LHeight) .. '\n' else sText = sText .. 'HBB_' .. tostring( nSashIndex - 1) .. 'B=' .. tostring( SashList[nSashIndex].LHeight) .. '\n' end if nSashIndex == #SashList then sText = sText .. 'HBB_dx=' .. tostring( SashList[nSashIndex].RHeight) .. '\n' else sText = sText .. 'HBB_' .. tostring( nSashIndex) .. '=' .. tostring( SashList[nSashIndex].RHeight) .. '\n' end end end if #SashList == 1 then sText = sText .. 'LBB=' .. tostring( SashList[1].BWidth) .. '\n' if SashList[1].BCArrow then sText = sText .. 'FRECCIA_1=' .. tostring( SashList[1].BCArrow) .. '\n' end else for nSashIndex = 1, #SashList do sText = sText .. 'LBB' .. nSashIndex .. '=' .. tostring( SashList[nSashIndex].BWidth) .. '\n' if SashList[nSashIndex].BCArrow then sText = sText .. 'FRECCIA_' .. nSashIndex .. '=' .. tostring( SashList[nSashIndex].BCArrow) .. '\n' end end end end sText = sText .. 'FINESTRAPORTAFINESTRA=Finestra' .. '\n' .. 'Q=1' .. '\n' -- opzione manoserramento ( non per vasistas altrimenti sovrascrive l'opzione) if nOpeningType ~= WIN_OPENING_TYPES.TILTONLY_TOP then sText = sText .. 'MANOSERRAMENTO=' .. sHandle .. '\n' end local vOptions = EgtGetInfo( nFrameId, WIN_HDW_OPTIONS, 'vs') or {} for i = 1, #vOptions do sText = sText .. vOptions[i] .. '\n' end sText = sText .. 'CNCOUTPUT=' .. sAGBOutputLavFile .. '\n' .. 'RUN' -- Scrittura nuova linea fhInput:write( sText .. '\n') -- Chiudo file fhInput:close() if bOnlyRequest then return sInputFile end -- attendo scrittura output lavorazioni local nWait = 0 while not EgtExistsFile( sOutputLavFile) and nWait < 1000 do nWait = nWait + 1 EgtPause( 10, true) end EgtPause( 10, true) -- Apro file OutputLav in lettura local fhOutputLav = io.open( sOutputLavFile, 'r') if not fhOutputLav then EgtOutLog( 'Error opening file ' .. sOutputLavFile) return false end local nFrameAreaId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*') local nHdwFrameLayerId = EgtGetFirstNameInGroup( nFrameAreaId, WIN_HDW_FRAME) for sMach in fhOutputLav:lines('l') do local MachParams = EgtSplitString( sMach, ';') local sPart = MachParams[3] local nSashIndex = tonumber( MachParams[4]) local sSashPart = MachParams[5] local dPosX = tonumber( MachParams[6]) local dPosY = tonumber( MachParams[7]) local dPosZ = tonumber( MachParams[8]) local sMacro = MachParams[9] local sSide = MachParams[21] -- FT1, FT2, FT3, FA1, FA2, FA3 local sOrigin = MachParams[24] -- AB, BC, CD, DA local nSashId = SashList[nSashIndex].nAreaId local nOutlineLayerId = EgtGetFirstNameInGroup( nSashId, WIN_OUTLINE) local vOutlineIds = EgtGetAllInGroup( nOutlineLayerId) local nA = string.byte( 'A') local nSashPart = string.byte( sSashPart) local nOutlineIndex = #vOutlineIds - ( nSashPart - nA) local nOutlineId = vOutlineIds[nOutlineIndex] local nPartId = GDB_ID.NULL local frHdw if sPart == 'TELAIO' then local nSashBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') local nSouId = EgtGetInfo( nSashBaseOutlineId, WIN_SOU, 'i') local sSouProfile = EgtGetInfo( nSouId, WIN_PROFILETYPE) while nSouId and not sSouProfile do nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') sSouProfile = EgtGetInfo( nSouId or GDB_ID.NULL, WIN_PROFILETYPE) end local nFrameOutlineId = EgtGetInfo( nSouId, WIN_COPY, 'i') nPartId = EgtGetInfo( nFrameOutlineId, WIN_REF_PART, 'i') local nHdwFrameId = EgtGetLastNameInGroup( nHdwFrameLayerId, nSashIndex .. '.' .. sSashPart .. '.' .. sSide) frHdw = EgtFR( nHdwFrameId) elseif sPart == 'ANTA' then nPartId = EgtGetInfo( nOutlineId, WIN_REF_PART, 'i') local nHdwFrameLayerId = EgtGetFirstNameInGroup( nSashId, WIN_HDW_FRAME) local nHdwFrameId = EgtGetLastNameInGroup( nHdwFrameLayerId, sSashPart .. '.' .. sSide) frHdw = EgtFR( nHdwFrameId) end local nProcLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PRC) -- recupero solido ( se non calcolato non vengono utilizzate) local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) or GDB_ID.NULL local nMainExtrusionId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_SRF_MAIN) local nOrigMainId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_SRF_ORIGMAIN) -- calcolo il punto centrale della lavorazione local ptCenter = Point3d( dPosX, dPosY, dPosZ) -- gestione particolare per traverso superiore ad arco if EgtGetType( nOutlineId) == GDB_TY.CRV_ARC then local nProfileLayId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) local nProfileId = EgtGetFirstNameInGroup( nProfileLayId, WIN_PRF_MAIN) -- calcolo outline del telaio sul canalino della ferramenta local nRefOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i') local nOffsetId = EgtCopyGlob( nRefOutlineId, nPartId) local dGapDelta = EgtGetInfo( nProfileId, WIN_GAPDELTA, 'd') EgtOffsetCurve( nOffsetId, - dGapDelta) -- recupero origine sulla curva di offset a partire dai frame dell'anta local nHdwSashLayerId = EgtGetFirstNameInGroup( nSashId, WIN_HDW_FRAME) local sHdwName = EgtIf( sOrigin == 'AB', 'B', 'C') .. '.FA1' local nHdwSashId = EgtGetLastNameInGroup( nHdwSashLayerId, sHdwName) local _, _, dParRef = EgtPointCurveDist( EgtSP( nHdwSashId), nOffsetId) local dLen = EgtCurveLengthAtParam( nOffsetId, dParRef) dLen = dLen + dPosX local dPar = EgtCurveParamAtLength( nOffsetId, dLen) local ptOrig = EgtUP( nOffsetId, dPar) -- ricostruisco il frame in base alla nuova origine local vtDir = EgtUV( nOffsetId, dPar, -1) if sSide == 'FT1' or sSide == 'FA1' then frHdw = Frame3d( ptOrig, - vtDir, vtDir ^ Z_AX(), Z_AX()) elseif sSide == 'FT2' or sSide == 'FA2' then local vtDirIn = Vector3d( vtDir) vtDirIn:rotate( Z_AX(), 90) local dFrameGapDeltaZ = EgtGetInfo( nProfileId, WIN_GAPDELTAZ, 'd') frHdw = Frame3d( ptOrig - dFrameGapDeltaZ * Z_AX(), - vtDir, vtDir ^ vtDirIn, vtDirIn) elseif sSide == 'FT3' or sSide == 'FA3' then local b3FrameProfile = GetProfileLocalBox( nProfileId) local dGapDeltaZ2 = b3FrameProfile:getDimY() frHdw = Frame3d( ptOrig - dGapDeltaZ2 * Z_AX(), - vtDir, vtDir ^ -Z_AX(), -Z_AX()) end -- calcolo il centro della lavorazione riferito al nuovo frame ptCenter = Point3d( 0, dPosY, dPosZ) EgtErase( nOffsetId) end local vMacro = EgtSplitString( sMacro, '_') if vMacro[1] == 'FRESATA' then elseif vMacro[1] == 'ASOLA' or vMacro[1] == 'MANIGLIA' then local dLength, dWidth, dHeight if vMacro[1] == 'ASOLA' then dLength = tonumber( vMacro[2]) dWidth = tonumber( vMacro[3]) dHeight = tonumber( vMacro[4]) -- NB in alcune macro ASOLA il secondo parametro non è la width ma la width/2 ! -- TODO Al momento sembra che questo avvenga solo quando il suo valore è 8. Da verificare if abs( dWidth - 8) < GEO.EPS_SMALL then dWidth = dWidth * 2 end elseif vMacro[1] == 'MANIGLIA' and vMacro[2] == '160' then -- macro speciale che corrisponde ad ASOLA_216_12_56 quindi forzo direttamente i valori -- TODO gestione di queste macro non parlanti dLength = 216 dWidth = 12 dHeight = 56 elseif vMacro[1] == 'MANIGLIA' then -- and vMacro[2] == '15' -- corrisponde ad ASOLA_69_12_30 dLength = 69 dWidth = 12 dHeight = 30 end local ptP1 = ptCenter + ( dLength / 2 - dWidth / 2) * X_AX() + dWidth / 2 * Y_AX() local ptP2 = ptCenter - ( dLength / 2 - dWidth / 2) * X_AX() + dWidth / 2 * Y_AX() local nPocketOutlineId = EgtCurveCompoFromPoints( nProcLayerId, { ptP1, ptP2}) EgtAddCurveCompoArcTg( nPocketOutlineId, ptCenter - ( dLength / 2 - dWidth / 2) * X_AX() - dWidth / 2 * Y_AX()) EgtAddCurveCompoArcTg( nPocketOutlineId, ptCenter + ( dLength / 2 - dWidth / 2) * X_AX() - dWidth / 2 * Y_AX(), false) EgtCloseCurveCompo( nPocketOutlineId) EgtSetColor( nPocketOutlineId, EgtStdColor( 'GRAY')) -- setto info di lavorazione EgtSetInfo( nPocketOutlineId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) EgtSetInfo( nPocketOutlineId, WIN_PRC_PROFILE_INFO, WIN_PRC_PROFILE_TYPE.GENERIC) EgtSetInfo( nPocketOutlineId, WIN_PRC_SIDE, WIN_PRC_SIDETYPE.IN) EgtModifyCurveExtrusion( nPocketOutlineId, Z_AX()) EgtModifyCurveThickness( nPocketOutlineId, - dHeight) -- porto la lavorazione in globale EgtTransform( nPocketOutlineId, frHdw) -- aggiornamento del solido if s_bCalcSolid then UpdateSolidWithProcessingSurf( nPocketOutlineId, nMainExtrusionId, nSolidLayerId) end elseif vMacro[1] == 'TASCA' then elseif vMacro[1] == 'VITE' then local dRadius = 1.5 local dDepth = 2 if vMacro[2] == 'CANALINO' then dRadius = 2 dDepth = 3 elseif vMacro[2] == 'ANTA' then dRadius = 2.5 dDepth = 4 end local nHoleId = EgtCircle( nProcLayerId, ptCenter, dRadius) EgtMove( nHoleId, Z_AX()) EgtModifyCurveExtrusion( nHoleId, Z_AX()) EgtModifyCurveThickness( nHoleId, - ( dDepth + 1)) EgtTransform( nHoleId, frHdw) EgtSetInfo( nHoleId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) elseif vMacro[1] == 'FORO' then local sDiameter = EgtReplaceString( vMacro[2], 'D', '') local dRadius = tonumber( sDiameter) / 2 local nHoleId = EgtCircle( nProcLayerId, ptCenter, dRadius) -- setto info di lavorazione EgtModifyCurveExtrusion( nHoleId, Z_AX()) -- TODO : come gestire profondità non definita? local dDepth = tonumber(25) if #vMacro == 3 then dDepth = tonumber( vMacro[3]) end EgtModifyCurveThickness( nHoleId, - dDepth) EgtSetColor( nHoleId, EgtStdColor( 'GRAY')) EgtSetInfo( nHoleId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) -- porto la lavorazione in globale EgtTransform( nHoleId, frHdw) -- aggiornamento del solido if s_bCalcSolid then UpdateSolidWithProcessingSurf( nHoleId, nMainExtrusionId, nSolidLayerId) end end end -- Chiudo file OutputLav in lettura fhOutputLav:close() if s_bCalcHardwareKit then local OutputKit = {} -- Apro file OutputKit in lettura local fhOutputKit = io.open( sOutputKitFile, 'r') if not fhOutputKit then EgtOutLog( 'Error opening file ' .. sOutputKitFile) return false end local nKitLineIndex = 1 for sLine in fhOutputKit:lines('l') do local KitParams = EgtSplitString( sLine, ';') OutputKit[nKitLineIndex] = KitParams nKitLineIndex = nKitLineIndex + 1 end table.insert( OutputKitList, OutputKit) -- Chiudo file OutputKit in lettura fhOutputKit:close() end if s_bCalcHardwarePosition then local OutputPosition = {} -- Apro file OutputPosition in lettura local fhOutputPosition = io.open( sOutputPositionFile, 'r') if not fhOutputPosition then EgtOutLog( 'Error opening file ' .. sOutputPositionFile) return false end local nPositionLineIndex = 1 for sLine in fhOutputPosition:lines('l') do local PositionParams = EgtSplitString( sLine, ';') OutputPosition[nPositionLineIndex] = PositionParams nPositionLineIndex = nPositionLineIndex + 1 end table.insert( OutputPositionList, OutputPosition) -- Chiudo file OutputPosition in lettura fhOutputPosition:close() end -- 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 --------------------------------------------------------------------- -- funzione che crea stringa per richiesta hardware AGB function WinCalculate.GetAGBSashDescription( nFrameId) -- 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 bOnlyRequest then nFavourite = WDG.HDWFAVOURITE --end 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 bOnlyRequest then sHandle = WDG.HDWHANDLE end if not sHandle then EgtOutLog('Warning! No hardware handle set!') return end local sText = 'S_NAME=' .. nFavourite .. '\n' .. 'RECORDID=15A' .. '\n' -- recupero il tipo di apertura local nOpeningType = WIN_OPENING_TYPES.NULL if #SashList > 0 then nOpeningType = EgtGetInfo( SashList[1].nAreaId, WIN_OPENING_TYPE, 'i') end -- recupero se scorrevole local bSlide = EgtGetInfo( nFrameId, WIN_SLIDE_WINDOW, 'b') or false if bSlide then -- le dimensioni per alzante scorrevole sono quelle del telaio local nOutlineLayId = EgtGetFirstInGroup( nFrameId, WIN_AREAOUTLINE) local nBottomId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_BOTTOM) local dMet = EgtCurveLength( nBottomId) local nLeftId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_LEFT) local dHet = EgtCurveLength( nLeftId) sText = sText .. 'MET=' .. tostring( dMet) .. '\n' sText = sText .. 'HET=' .. tostring( dHet) .. '\n' else if #SashList >= 1 and abs( SashList[1].LHeight - SashList[1].RHeight) < GEO.EPS_SMALL then sText = sText .. 'HBB=' .. tostring( SashList[1].LHeight) .. '\n' else for nSashIndex = 1, #SashList do if nSashIndex == 1 then sText = sText .. 'HBB_sx=' .. tostring( SashList[nSashIndex].LHeight) .. '\n' else sText = sText .. 'HBB_' .. tostring( nSashIndex - 1) .. 'B=' .. tostring( SashList[nSashIndex].LHeight) .. '\n' end if nSashIndex == #SashList then sText = sText .. 'HBB_dx=' .. tostring( SashList[nSashIndex].RHeight) .. '\n' else sText = sText .. 'HBB_' .. tostring( nSashIndex) .. '=' .. tostring( SashList[nSashIndex].RHeight) .. '\n' end end end if #SashList == 1 then sText = sText .. 'LBB=' .. tostring( SashList[1].BWidth) .. '\n' if SashList[1].BCArrow then sText = sText .. 'FRECCIA_1=' .. tostring( SashList[1].BCArrow) .. '\n' end else for nSashIndex = 1, #SashList do sText = sText .. 'LBB' .. nSashIndex .. '=' .. tostring( SashList[nSashIndex].BWidth) .. '\n' if SashList[nSashIndex].BCArrow then sText = sText .. 'FRECCIA_' .. nSashIndex .. '=' .. tostring( SashList[nSashIndex].BCArrow) .. '\n' end end end end sText = sText .. 'FINESTRAPORTAFINESTRA=Finestra' .. '\n' .. 'Q=1' .. '\n' -- opzione manoserramento ( non per vasistas altrimenti sovrascrive l'opzione) if nOpeningType ~= WIN_OPENING_TYPES.TILTONLY_TOP then sText = sText .. 'MANOSERRAMENTO=' .. sHandle .. '\n' end local vOptions = EgtGetInfo( nFrameId, WIN_HDW_OPTIONS, 'vs') or {} for i = 1, #vOptions do sText = sText .. vOptions[i] .. '\n' end return sText end --------------------------------------------------------------------- -- funzione che recupera le opzioni dell'hardware function WinCalculate.GetHardwareOptions( nAreaId) local sAGBSashDescription = WinCalculate.GetAGBSashDescription( nAreaId) -- creo file di richiesta ferramenta local sNow = os.date( '_%Y_%m_%d_%H_%M_%S', os.time()) local sInputFile = 'a:\\InputBatch\\Input' .. sNow .. '.txt' local sInputOptFile = 'a:\\InputBatch\\Input' .. sNow .. '.opt' -- Apro file Input in scrittura local fhInput = io.open( sInputFile, 'w') if not fhInput then EgtOutLog( 'Error opening file ' .. sInputFile) return false end local sText = 'S_NAME=' .. nFavourite .. '\n' .. 'RECORDID=15A' .. '\n' .. 'only_options=on' .. '\n' .. sAGBSashDescription .. '\n' .. 'RUN' -- Scrittura nuova linea fhInput:write( sText .. '\n') -- Chiudo file fhInput:close() if bOnlyRequest then return sInputFile end -- attendo scrittura output lavorazioni local nWait = 0 while not EgtExistsFile( sInputOptFile) and nWait < 1000 do nWait = nWait + 1 EgtPause( 10, true) end EgtPause( 10, true) -- Apro file OutputKit in lettura local fhOutputKit = io.open( sOutputKitFile, "rb") if not fhOutputKit then EgtOutLog( 'Error opening file ' .. sOutputKitFile) return false end local content = SouFh:read( "*all") -- Chiudo file OutputKit in lettura fhOutputKit:close() return content end --------------------------------------------------------------------- -- funzione che aggiunge l'hardware function WinCalculate.AddHardware( nAreaId) OutputKitList = {} OutputPositionList = {} WinCalculate.AddHardwareRec( nAreaId) return OutputKitList, OutputPositionList end function WinCalculate.AddHardwareRec( nAreaId) -- verifico il tipo local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) local nSplitType = WIN_SPLITTYPES.NULL if nSplitLayerId then nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') end if nAreaType == WIN_AREATYPES.SASH or ( nSplitLayerId and nSplitType == WIN_SPLITTYPES.FRENCH) then -- lancio calcolo sash return WinCalculate.AddHardwareForSash( nAreaId) else -- verifico se ci sono sotto-aree local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') while nChildAreaId do -- lancio verifica di quell'area WinCalculate.AddHardwareRec( nChildAreaId) nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*') end end end --------------------------------------------------------------------- -- funzione che disegna l'hardware local function DrawHardware( nAreaId, nAuxLayerId) -- verifico il tipo local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') -- se anta disegno la ferramenta if nAreaType == WIN_AREATYPES.SASH then -- se è stato definito un preferito disegno la ferramenta local sFavourite = EgtGetInfo( nAreaId, WIN_HDW_FAVOURITE) or WIN_HDW_NULL if sFavourite ~= WIN_HDW_NULL then DrawSashHardware( nAreaId, nAreaId, nAuxLayerId) end return else -- verifico se contiene un french split local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) local nSplitType = WIN_SPLITTYPES.NULL if nSplitLayerId then nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') end if nSplitType == WIN_SPLITTYPES.FRENCH then -- se ha definito un preferito devo disegnare la ferramenta local sFavourite = EgtGetInfo( nAreaId, WIN_HDW_FAVOURITE) or WIN_HDW_NULL if sFavourite ~= WIN_HDW_NULL then -- recupero tutte le sottoaree di tipo anta local vSashes = {} local vStack = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*') local i = 1 while vStack[i] do local nType = EgtGetInfo( vStack[i], WIN_AREATYPE, 'i') if nType == WIN_AREATYPES.SASH then table.insert( vSashes, vStack[i]) else local vChildren = EgtGetNameInGroup( vStack[i], WIN_AREA .. '*') vStack = EgtJoinTables( vStack, vChildren) end end -- disegno la ferramenta su tutte le ante for i = 1, #vSashes do DrawSashHardware( vSashes[i], nAreaId, nAuxLayerId) end end return 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 end ---------------------------------------------------------------------------------- ----------------------------------- ACCESSORI ---------------------------------- ---------------------------------------------------------------------------------- -- funzione che indidivua i parametri di trim della curva nCrvId in base al geo delle curve prev e next ( ricavate dalle info di nAuxCrv) local function GetTrimParamsByPrevAndNext( nCrvId, nAuxCrvId, sGeoRef) local nAuxGrp = EgtGetParent( nCrvId) -- recupero curve prev e next di riferimento local nPrevCrv = EgtGetInfo( nAuxCrvId, WIN_PREV_OUTLINES, 'i') local nNextCrv = EgtGetInfo( nAuxCrvId, WIN_NEXT_OUTLINES, 'i') if not nPrevCrv or not nNextCrv then -- gestione speciale per soglia dove prev e next non sono settati local nRefGrp = EgtGetParent( nAuxCrvId) nPrevCrv = EgtGetLastInGroup( nRefGrp) nNextCrv = EgtGetNext( nAuxCrvId) end -- recupero le curve del geo di interesse local nPrevPart = EgtGetInfo( nPrevCrv, WIN_REF_PART, 'i') local nPrevGeo = EgtGetFirstNameInGroup( nPrevPart, WIN_GEO) local nPrevRef = EgtGetFirstNameInGroup( nPrevGeo, sGeoRef) local nPrevCopy = EgtCopyGlob( nPrevRef, nAuxGrp) EgtExtendCurveStartByLen( nPrevCopy, 1000) EgtExtendCurveEndByLen( nPrevCopy, 1000) local nNextPart = EgtGetInfo( nNextCrv, WIN_REF_PART, 'i') local nNextGeo = EgtGetFirstNameInGroup( nNextPart, WIN_GEO) local nNextRef = EgtGetFirstNameInGroup( nNextGeo, sGeoRef) local nNextCopy = EgtCopyGlob( nNextRef, nAuxGrp) EgtExtendCurveStartByLen( nNextCopy, 1000) EgtExtendCurveEndByLen( nNextCopy, 1000) -- recupero punti di intersezione local ptS = EgtIP( nCrvId, nPrevCopy, ORIG()) local dParS = EgtCurveParamAtPoint( nCrvId, ptS) local ptE = EgtIP( nCrvId, nNextCopy, ORIG()) local dParE = EgtCurveParamAtPoint( nCrvId, ptE) EgtErase( { nPrevCopy, nNextCopy}) return dParS, dParE end ---------------------------------------------------------------------------------- -- funzione che calcola e disegna la soglia local function CalcThreshold( nOutlineId, nAreaId) -- recupero il profilo della soglia local nProfileId = GetOutlineProfileId( nOutlineId) local dLenTot = 0 -- disegno local nAuxGrp = GetAuxLayer() local nStm = CreateProfileSurf( nOutlineId, nProfileId, WIN_SECTION, 0, nAuxGrp) if nStm then EgtSetColor( nStm, Color3d( 128, 128, 128)) EgtSetName( nStm, WIN_THRESHOLD) dLenTot = EgtCurveLength( nOutlineId) end -- se slide window ci sono parti extra da estrudere in corrispondenza delle ante fisse local bSlideWindow = EgtGetInfo( nAreaId, WIN_SLIDE_WINDOW, 'b') or false if bSlideWindow then -- 1) soglia extra per parte mobile local nGuideId = EgtCopyGlob( nOutlineId, nAuxGrp) local dParS, dParE = GetTrimParamsByPrevAndNext( nGuideId, nOutlineId, WIN_IN) EgtTrimCurveStartEndAtParam( nGuideId, dParS, dParE) local vMovableSections = EgtGetNameInGroup( nProfileId, WIN_MOVABLE .. WIN_SECTION) for i = 1, #vMovableSections do local nStmExtra = CreateProfileSurfById( nGuideId, nProfileId, vMovableSections[i], 0, nAuxGrp) EgtSetColor( nStmExtra, Color3d( 128, 128, 128)) EgtSetName( nStmExtra, WIN_MOVABLE .. WIN_SECTION) end dLenTot = dLenTot + #vMovableSections * EgtCurveLength( nGuideId) EgtErase( nGuideId) -- 2) soglia extra per le sottoante fisse -- recupero i profili extra da estrudere local vExtraSections = EgtGetNameInGroup( nProfileId, WIN_FIXED .. WIN_SECTION) if #vExtraSections > 0 then -- cerco tutte le sottoante fisse local vChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi') for i = 1, #vChildren do local nSashAreaId = EgtGetParent( EgtGetParent( vChildren[i])) local nSashType = EgtGetInfo( nSashAreaId, WIN_SASHTYPE, 'i') if nSashType == WIN_SASHTYPES.SLIDE_FIXED then local nGuideId = EgtCopyGlob( vChildren[i], nAuxGrp) EgtExtendCurveStartByLen( nGuideId, 1000) EgtExtendCurveEndByLen( nGuideId, 1000) -- trim della guida con il geo dei pezzi vicini local nOutlineId = EgtGetInfo( vChildren[i], WIN_COPY, 'i') local dParS, dParE = GetTrimParamsByPrevAndNext( nGuideId, nOutlineId, WIN_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 -- gruppi per i conti local nGrp = EgtGroup( nPartId) -- recupero parametri di intersezione con i pezzi vicini local dParPrev, dParNext = GetTrimParamsByPrevAndNext( nOutlineId, nOutlineId, WIN_IN) local vParams = { dParPrev, dParNext} -- verifico se outline va spezzato ulteriormente a causa di montanti 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.FRAME or nAreaType == WIN_AREATYPES.SPLIT then local nSplitId = EgtGetFirstNameInGroup( vStack[i], WIN_SPLIT) if nSplitId then local nSplitType = EgtGetInfo( nSplitId, WIN_SPLITTYPE, 'i') if nSplitType ~= WIN_SPLITTYPES.FRENCH then -- recupero il pezzo associato allo split local nSplitOutline = EgtGetFirstInGroup( nSplitId) local nSplitPart = EgtGetInfo( nSplitOutline, WIN_REF_PART, 'i') -- recupero le intersezioni con la curva di outline local nSplitGeo = EgtGetFirstNameInGroup( nSplitPart, WIN_GEO) local nCrv1 = EgtGetFirstNameInGroup( nSplitGeo, WIN_IN) local nCopy1 = EgtCopyGlob( nCrv1, nGrp) EgtExtendCurveStartByLen( nCopy1, 200) EgtExtendCurveEndByLen( nCopy1, 200) local nCrv2 = EgtGetFirstNameInGroup( nSplitGeo, WIN_OUT) local nCopy2 = EgtCopyGlob( nCrv2, nGrp) EgtExtendCurveStartByLen( nCopy2, 200) EgtExtendCurveEndByLen( nCopy2, 200) local pt1 = EgtIP( nOutlineId, nCopy1, ORIG()) local pt2 = EgtIP( nOutlineId, nCopy2, ORIG()) if pt1 and pt2 then -- salvo i parametri di intersezione local dPar1 = EgtCurveParamAtPoint( nOutlineId, pt1, 100 * GEO.EPS_SMALL) local dPar2 = EgtCurveParamAtPoint( nOutlineId, pt2, 100 * GEO.EPS_SMALL) table.insert( vParams, dPar1) table.insert( vParams, dPar2) end -- salvo le sue sottoaree per analizzarle local vChildren = EgtGetNameInGroup( vStack[i], WIN_AREA .. '*') or {} vStack = EgtJoinTables( vStack, vChildren) end end end i = i + 1 end end -- riordino i parametri ( non dovrebbero mai capitare parametri coincidenti) table.sort( vParams) -- recupero il gruppo per il disegno dei solidi local nSolidLayId if bDraw and s_bCalcSolid then nSolidLayId = GetAuxLayer() end local dLenTot = 0 for i = 1, #vParams, 2 do -- creo la guida di estrusione per il gocciolatoio local nGuideId = EgtCopyGlob( nOutlineId, nGrp) -- trim della curva EgtTrimCurveStartEndAtParam( nGuideId, vParams[i], vParams[i+1]) -- aggiorno la lunghezza dLenTot = dLenTot + EgtCurveLength( nGuideId) -- disegno if bDraw and s_bCalcSolid then -- estrudo la superficie local nStm = CreateProfileSurf( nGuideId, nProfileId, WIN_WATERDRIP, 0, nSolidLayId) EgtSetColor( nStm, Color3d( 128, 128, 128)) EgtSetName( nStm, WIN_WATERDRIP) end end -- salvo la lunghezza del gocciolatoio EgtSetInfo( nAreaId, WIN_WATERDRIP_LEN, dLenTot) EgtErase( nGrp) 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 TrimAndOrientOrderedCurves( 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 gocciolatioio local nBottomId = EgtGetFirstNameInGroup( nOutlineLayId, WIN_BOTTOM) local bThreshold = EgtGetInfo( nAreaId, WIN_THRESHOLD, 'b') or false if bThreshold then -- soglia CalcThreshold( nBottomId, nAreaId) else -- gocciolatoio local nPartId = EgtGetInfo( nBottomId, WIN_REF_PART, 'i') CalcWaterdrip( nPartId, nBottomId, nAreaId, bDraw) end -- guarnizioni se definisce un french split o se definisce direttamente anta local nSplitId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) or GDB_ID.NULL local nSplitType = EgtGetInfo( nSplitId, WIN_SPLITTYPE, 'i') if nSplitId == GDB_ID.NULL or nSplitType == WIN_SPLITTYPES.FRENCH then CalcGaskets( nAreaId, bDraw) end -- TODO guarnizioni per gocciolatoio elseif nAreaType == WIN_AREATYPES.SASH then -- guarnizioni anta CalcGaskets( nAreaId, bDraw) elseif nAreaType == WIN_AREATYPES.SPLIT then -- guarnizioni se è french split che non deriva da un french split local nSplitId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) local nSplitType = EgtGetInfo( nSplitId, WIN_SPLITTYPE, 'i') if nSplitType == WIN_SPLITTYPES.FRENCH then local nParentArea = EgtGetParent( nAreaId) local nParentSplit = EgtGetFirstNameInGroup( nParentArea, WIN_SPLIT) or GDB_ID.NULL local nSplitType = EgtGetInfo( nParentSplit, WIN_SPLITTYPE, 'i') if nSplitType ~= WIN_SPLITTYPES.FRENCH then CalcGaskets( nAreaId, bDraw) end end elseif nAreaType == WIN_AREATYPES.NULL then -- guarnizioni se non deriva da french split e ha come sottoarea un'anta local nParentArea = EgtGetParent( nAreaId) local nParentSplit = EgtGetFirstNameInGroup( nParentArea, WIN_SPLIT) or GDB_ID.NULL local nSplitType = EgtGetInfo( nParentSplit, WIN_SPLITTYPE, 'i') if nSplitType == WIN_SPLITTYPES.MULLION then local nChildArea = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') or GDB_ID.NULL local nChildType = EgtGetInfo( nChildArea, WIN_AREATYPE, 'i') if nChildType == WIN_AREATYPES.SASH then CalcGaskets( nAreaId, bDraw) end 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 ---------------------------------------------------------------------------------- ------------------------------ FUNZIONI ---------------------------------------- ---------------------------------------------------------------------------------- -- funzione che crea tutti i pezzi della finestra partendo dal telaio function WinCalculate.CreatePartFromArea( nFrameId) -- assegno il tipo di profilo alle curve del base outline CalculateAreaProfileType( nFrameId) -- calcolo outline a partire dal base outline CalculateAreaOutline( nFrameId) -- creo pezzi s_nSashNbr = 0 -- resetto il numero di ante del progetto CalculateAreaParts( nFrameId) -- calcolo le spine CalculateAreaDowels( nFrameId) -- calcolo preview 2d se richiesta if s_bCalcPreview then CalcPreview( nFrameId) end end --------------------------------------------------------------------- -- funzione che ricalcola i solidi ( per cambio modalità visualizzazione) function WinCalculate.RecalcSolids( nFrameId) -- scorro tutti i pezzi local nPartId = EgtGetFirstPart() while nPartId do -- se solidi non vanno calcolati elimino semplicemente il gruppo dei solidi da ogni pezzo if not s_bCalcSolid then local nSolidLayId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) or GDB_ID.NULL EgtErase( nSolidLayId) -- ricalcolo dei solidi else -- se fill, lo uso per ricalcolare strip local nPartType = EgtGetInfo( nPartId, WIN_PART_TYPE, 'i') if nPartType == WIN_PART_TYPES.FILL then local nAreaId = EgtGetInfo( nPartId, WIN_AREA, 'i') local nParentAreaId = EgtGetParent( nAreaId) local nParentOutlineLayId = EgtGetFirstNameInGroup( nParentAreaId, WIN_OUTLINE) local vParentOutlines = EgtGetAllInGroup( nParentOutlineLayId) for i = 1, #vParentOutlines do CreateStripFromOutline( nParentAreaId, vParentOutlines[i]) end -- verifico se solido da calcolare local nSolidLayId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) if not nSolidLayId then local nOutlineLayId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) local nGeoLayId = EgtGetFirstNameInGroup( nPartId, WIN_GEO) CalcFillSolid( nPartId, nOutlineLayId, nGeoLayId) end -- se pezzo, ricalcolo il suo solido else -- elimino gruppo dei solidi local nSolidLayId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) or GDB_ID.NULL EgtErase( nSolidLayId) -- ricalcolo il solido principale local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i') local nSolidId = CalcSolid( nPartId, nOutlineId) -- aggiungo lavorazioni local nProcLayId = EgtGetFirstNameInGroup( nPartId, WIN_PRC) local vProc = EgtGetAllInGroup( nProcLayId) for i = 1, #vProc do local nType = EgtGetInfo( vProc[i], WIN_PRC_FEATURE_TYPE) local nProfilingType = EgtGetInfo( vProc[i], WIN_PRC_PROFILE_INFO) if nType == WIN_PRC_TYPE.HOLE or ( nType == WIN_PRC_TYPE.PROFILING and nProfilingType == WIN_PRC_PROFILE_TYPE.GENERIC) then UpdateSolidWithProcessingSurf( vProc[i], nSolidId, nProcLayId) end end end end nPartId = EgtGetNextPart( nPartId) end -- accessori e ferramenta local nAuxGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AUX) if not s_bCalcSolid then EgtErase( nAuxGrp or GDB_ID.NULL) elseif not nAuxGrp then nAuxGrp = GetAuxLayer() -- ferramenta DrawHardware( nFrameId, nAuxGrp) -- accessori WinCalculate.AddAccessories( nFrameId, true) end end --------------------------------------------------------------------- return WinCalculate