diff --git a/Profiles/Profilo78 - Offset - Copy (48).nge b/Profiles/Profilo78 - Offset - Copy (48).nge new file mode 100644 index 0000000..1b10c42 Binary files /dev/null and b/Profiles/Profilo78 - Offset - Copy (48).nge differ diff --git a/Profiles/Profilo78 - Offset - Copy (49).nge b/Profiles/Profilo78 - Offset - Copy (49).nge new file mode 100644 index 0000000..5574fd5 Binary files /dev/null and b/Profiles/Profilo78 - Offset - Copy (49).nge differ diff --git a/Profiles/Profilo78 - Offset - Copy (50).nge b/Profiles/Profilo78 - Offset - Copy (50).nge new file mode 100644 index 0000000..1edd6b1 Binary files /dev/null and b/Profiles/Profilo78 - Offset - Copy (50).nge differ diff --git a/Profiles/Profilo78 - Offset - Copy (51).nge b/Profiles/Profilo78 - Offset - Copy (51).nge new file mode 100644 index 0000000..aa6055e Binary files /dev/null and b/Profiles/Profilo78 - Offset - Copy (51).nge differ diff --git a/Profiles/Profilo78 - Offset - Copy (52).nge b/Profiles/Profilo78 - Offset - Copy (52).nge new file mode 100644 index 0000000..2c8f86b Binary files /dev/null and b/Profiles/Profilo78 - Offset - Copy (52).nge differ diff --git a/Profiles/Profilo78 - Offset.nge b/Profiles/Profilo78 - Offset.nge index 1b10c42..b1df149 100644 Binary files a/Profiles/Profilo78 - Offset.nge and b/Profiles/Profilo78 - Offset.nge differ diff --git a/Profiles/WinConst.lua b/Profiles/WinConst.lua index eb051a6..92d8b25 100644 --- a/Profiles/WinConst.lua +++ b/Profiles/WinConst.lua @@ -81,10 +81,12 @@ WIN_AREATYPES = { -- tipo di split: -- mullion = montante -- french = battente / ricevente +-- mixed = cambio profilo WIN_SPLITTYPES = { NULL = 0, MULLION = 1, FRENCH = 2, + MIXED = 3, } -- tipi di riempimento interno @@ -105,6 +107,13 @@ WIN_SASHTYPES = { INACTIVE_OUT = 6, } +WIN_CHILDREN_TYPES = { + NULL = 0, + SASH = 1, + FILL = 2, + MIXED = 3, +} + WIN_SURF_APPROX = 0.05 WIN_PROFILE = 'Profile' @@ -135,10 +144,8 @@ WIN_AREATYPE = 'AreaType' WIN_SASH = 'Sash' WIN_FILL = 'Fill' WIN_FILLTYPE = 'FillType' -WIN_SIDE = 'Side' WIN_SPLITTYPE = 'SplitType' WIN_STARTJOINT = 'StartJoint' -WIN_ENDJOINT = 'EndJoint' WIN_SASHTYPE = 'SashType' WIN_REF_OUTLINE = 'OutlineRef' WIN_REF_PART = 'PartRef' @@ -159,6 +166,9 @@ WIN_FRENCH_IN = 'French_In' WIN_FRENCH_OUT = 'French_Out' WIN_SASH_SPLIT = 'Sash_Split' WIN_FRAME_SPLIT = 'Frame_Split' +WIN_MIXED_BOTTOM = 'Mixed_Bottom' +WIN_MIXED_TOP = 'Mixed_Top' +WIN_MIXED_SPLIT = 'Mixed_Split' WIN_REF = 'Ref' WIN_SECTION = 'Section' @@ -171,11 +181,13 @@ WIN_OUTOFST = 'OfstOut' WIN_CTRINOFST = 'OfstCtrIn' WIN_OFST = 'Ofst' WIN_SECTIONFRAME = 'SectionFrame' +WIN_MIXED_COMMON = 'Common' +WIN_SIMPLIFIED = 'Simplified' WIN_MINIZINKEN = 'MiniZinken' -WIN_STARTCPDELTA = 'StartCPDelta' -WIN_ENDCPDELTA = 'EndCPDelta' +-- WIN_STARTCPDELTA = 'StartCPDelta' +-- WIN_ENDCPDELTA = 'EndCPDelta' WIN_GEOWIDTH = 'GeoWidth' WIN_GLASSTHICKNESS = 'GlassThickness' WIN_SEMI_PROFILE = 'SemiProfileId' @@ -212,7 +224,8 @@ WIN_SOU = 'SOU' WIN_CHILD = 'CHILD' WIN_COPY = 'COPY' -WIN_OVERLAP = 'Overlap' +WIN_SASH_TOP_OVERLAP = 'SashTopOverlap' +WIN_SASH_BOTTOM_OVERLAP = 'SashBottomOverlap' WIN_DELTA = 'Delta' WIN_FILLOVERLAP = 'FillOverlap' WIN_FILLDELTA = 'FillDelta' @@ -220,7 +233,9 @@ WIN_GAPDELTA = 'GapDelta' WIN_GAPDELTAZ = 'GapDeltaZ' WIN_GAPDELTAIN = 'GapDeltaIn' WIN_GAPDELTAOUT = 'GapDeltaOut' - +WIN_FIXED_REF = 'FixedRef' +WIN_SASH_REF = 'SashRef' +WIN_SASH_DEPTH = 'SashDepth' WIN_PRC_PHASE = 'PHASE' WIN_PRC_PROFILE_TYPE = 'PROFILE_TYPE' WIN_PRC_NTOOLS = 'NTOOLS' @@ -231,12 +246,30 @@ WIN_PRC_OFFY_1 = 'OFFY_1' WIN_PRC_OFFZ_1 = 'OFFZ_1' WIN_PRC_OFFY_2 = 'OFFY_2' WIN_PRC_OFFZ_2 = 'OFFZ_2' +WIN_PRC_CLAMPV_1 = 'CLAMPV_1' +WIN_PRC_CLAMPV_2 = 'CLAMPV_2' +WIN_STRIP_DIST = 'StripDistance' +WIN_REF_SPLIT = 'RefSplit' WIN_CRV_ON_FRENCH_SPLIT = 'OutlineOnFrenchSplit' +WIN_PREV_OUTLINES = 'PrevOutlines' +WIN_NEXT_OUTLINES = 'NextOutlines' + +WIN_PRF_CHANGE = 'ProfileChange' +WIN_MIXED_OUTLINES = 'ProfileChangeOutlines' +WIN_MIXED_INTERSECTIONS = 'ProfileChangeIntersections' +WIN_SASH_CHILDREN = 'SashChildren' +WIN_FILL_CHILDREN = 'FillChildren' +WIN_MIXED_SPLIT_REF = 'MixedSplitRef' +WIN_MIXED_INTERS_REF = 'MixedIntersRef' +WIN_MIXED_REF_START = 'MixedRefEnd' +WIN_MIXED_REF_END = 'MixedRefStart' WIN_MAINGUIDE = 'MainGuide' WIN_SRF_MAIN = 'MainSurface' WIN_SRF_ORIGMAIN = 'OrigMainSurface' +WIN_SRF_START = 'StartSurface' +WIN_SRF_END = 'EndSurface' WIN_SRF_STRIP = 'StripSurface' WIN_BOTTOMRAIL = 'BottomRail' @@ -248,7 +281,8 @@ WIN_PRC_TYPE = { HOLE = 'Hole', PROFILING = 'Profiling', POCKET = 'Pocket', - CUT = 'Cut' + CUT = 'Cut', + STRIP_CUT = 'StripCut' } WIN_PRC_OVERMAT_IN = 'OVERMAT_IN' WIN_PRC_OVERMAT_OUT = 'OVERMAT_OUT' @@ -263,32 +297,15 @@ WIN_PRC_DWL_SIDETYPE = { } WIN_DOWEL = 'Dowel' -WIN_DWL_TOPPERPSTART = 'TopPerpStart' -WIN_DWL_TOPPERPEND = 'TopPerpEnd' -WIN_DWL_TOPPARASTART = 'TopParaStart' -WIN_DWL_TOPPARAEND = 'TopParaEnd' -WIN_DWL_BOTTOMPERPSTART = 'BottomPerpStart' -WIN_DWL_BOTTOMPERPEND = 'BottomPerpEnd' -WIN_DWL_BOTTOMPARASTART = 'BottomParaStart' -WIN_DWL_BOTTOMPARAEND = 'BottomParaEnd' -WIN_DWL_RAILBOTTOMPERPSTART = 'RailBottomPerpStart' -WIN_DWL_RAILBOTTOMPERPEND = 'RailBottomPerpEnd' -WIN_DWL_RAILBOTTOMPARASTART = 'RailBottomParaStart' -WIN_DWL_RAILBOTTOMPARAEND = 'RailBottomParaEnd' -WIN_DWL_SPLITPERPSTART = 'SplitPerpStart' -WIN_DWL_SPLITPERPEND = 'SplitPerpEnd' -WIN_DWL_SPLITPARASTART = 'SplitParaStart' -WIN_DWL_SPLITPARAEND = 'SplitParaEnd' -WIN_DWL_VERTICALSPLITPARASTART = 'VerticalSplitParaStart' -WIN_DWL_VERTICALSPLITPARAEND = 'VerticalSplitParaEnd' -WIN_DWL_VERTICALSPLITPERPSTART = 'VerticalSplitPerpStart' -WIN_DWL_VERTICALSPLITPERPEND = 'VerticalSplitPerpEnd' -WIN_DWL_HORIZONTALSPLITPARASTART = 'HorizontalSplitParaStart' -WIN_DWL_HORIZONTALSPLITPARAEND = 'HorizontalSplitParaEnd' -WIN_DWL_BOTTOMHORIZONTALSPLITPARASTART = 'BottomHorizontalSplitParaStart' -WIN_DWL_BOTTOMHORIZONTALSPLITPARAEND = 'BottomHorizontalSplitParaEnd' -WIN_DWL_HORIZONTALSPLITPERPSTART = 'HorizontalSplitPerpStart' -WIN_DWL_HORIZONTALSPLITPERPEND = 'HorizontalSplitPerpEnd' +WIN_DWL_TOP_PERP_LEN = 'TopPerpLen' +WIN_DWL_TOP_PARA_LEN = 'TopParaLen' +WIN_DWL_BOTTOM_PERP_LEN = 'BottomPerpLen' +WIN_DWL_BOTTOM_PARA_LEN = 'BottomParaLen' +WIN_DWL_RAILBOTTOM_PERP_LEN = 'RailBottomPerpLen' +WIN_DWL_RAILBOTTOM_PARA_LEN = 'RailBottomParaLen' +WIN_DWL_SPLIT_PERP_LEN = 'SplitPerpLen' +WIN_DWL_SPLIT_PARA_LEN = 'SplitParaLen' + WIN_PRJ_ORIGSPLIT = 'OrigSplit' diff --git a/Profiles/WinLib/WinCalculate.lua b/Profiles/WinLib/WinCalculate.lua index c606d85..981c50d 100644 --- a/Profiles/WinLib/WinCalculate.lua +++ b/Profiles/WinLib/WinCalculate.lua @@ -20,12 +20,19 @@ local WinCalculate = {} require( 'EgtBase') require( 'WinConst') -local bCalcSolid = false +local s_dDowelTol = 1 + +local s_bCalcSolid = false function WinCalculate.GetCalcSolid() - return bCalcSolid + return s_bCalcSolid end function WinCalculate.SetCalcSolid( bValue) - bCalcSolid = bValue + s_bCalcSolid = bValue +end + +local s_bSimplSolid = false +function WinCalculate.SetSimplifiedSolid( bValue) + s_bSimplSolid = bValue end --------------------------------------------------------------------- @@ -50,8 +57,15 @@ local function FindIntersectionPoint( nCrv1, nCrv2, ptRef) -- se entrambi archi elseif EgtGetType( nCrv1) == GDB_TY.CRV_ARC and EgtGetType( nCrv2) == GDB_TY.CRV_ARC then - -- TO DO. Al momento non ci sono esempi di questo tipo - + -- 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) + -- se arco e linea else local nLine = EgtIf( EgtGetType( nCrv1) == GDB_TY.CRV_LINE, nCrv1, nCrv2) @@ -125,6 +139,9 @@ 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') @@ -202,62 +219,138 @@ local function FindAssociatedPart( nOutlineId) end --------------------------------------------------------------------- ------------------ CALCOLO DEI PROFILI ------------------------------ ---------------------------------------------------------------------- --- funzione che verifica se ci sono Sash dopo -local function VerifyChildArea( nAreaId) - local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAASTERISK) - local nChildAreaType - if nChildAreaId then - nChildAreaType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, 'i') - if nChildAreaType == WIN_AREATYPES.SASH then - return true +-- 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 - if VerifyChildArea( nChildAreaId) then return true end + i = i + 1 end - while nChildAreaId and nChildAreaType ~= WIN_AREATYPES.SASH do - nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREAASTERISK) - if nChildAreaId then - nChildAreaType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, 'i') - if nChildAreaType == WIN_AREATYPES.SASH then - return true - end - end - if VerifyChildArea( nChildAreaId) then return true end - end - return false + -- se non trovo un tipo definito + return WIN_CHILDREN_TYPES.NULL end --------------------------------------------------------------------- --- funzione che identifica il tipo di split ( mullion, french, null) +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 impostato verifico se ha sash prima o dopo per capire se è implicitamente di tipo mullion - if not nSplitType then + -- 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 - -- devi confrontare il type con sash + -- 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 - -- verifico se ci sono Sash dopo - local nAreaId = EgtGetParent( nSplitLayerId) - local bSashAfter = VerifyChildArea( nAreaId) - -- se ci sono assegno tipo di profilo a mullion - if bSashAfter then - EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, WIN_SPLITTYPES.MULLION) + 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 - EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, WIN_SPLITTYPES.NULL) nSplitType = WIN_SPLITTYPES.NULL end - + EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, nSplitType) return nSplitType end @@ -292,9 +385,27 @@ local function CalcSplitProfileType( nSplitLayerId, nAreaId) if nParentAreaType == WIN_AREATYPES.SASH then EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_SPLIT) else - -- altrimenti vetro fisso 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 @@ -322,26 +433,6 @@ local function FindAdjacentSashType( nSplitId, nSouId) return nSashType end ---------------------------------------------------------------------- -local function GetSubAreaType( nAreaId) - - local vStack = { nAreaId} - local i = 1 - while vStack[i] do - -- verifico se area è di tipo sash o fill - local nType = EgtGetInfo( vStack[i], WIN_AREATYPE, 'i') - if nType == WIN_AREATYPES.FILL or nType == WIN_AREATYPES.SASH then - return nType - end - -- aggiungo le sue sottoaree ( se esistono) tra gli elementi da analizzare - local vSubAreas = EgtGetNameInGroup( vStack[i], WIN_AREA .. '*') or {} - vStack = EgtJoinTables( vStack, vSubAreas) - -- aggiorno il contatore - i = i + 1 - end - return nil -end - --------------------------------------------------------------------- -- funzione che imposta i tipi di profilo in base al tipo di pezzi local function CalcProfileType( nAreaId) @@ -349,26 +440,36 @@ local function CalcProfileType( nAreaId) -- FRAME if nAreaType == WIN_AREATYPES.FRAME then - -- recupero il tipo delle sottoaree - local nChildType = GetSubAreaType( nAreaId) -- assegno il profilo alle curve di outline local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) while nOutlineId do local sName = EgtGetName( nOutlineId) - if not nChildType or nChildType == WIN_AREATYPES.SASH then + -- recupero il tipo dei figli + local nChildrenType = GetChildrenType( nOutlineId) + + if nChildrenType == WIN_CHILDREN_TYPES.NULL or nChildrenType == WIN_CHILDREN_TYPES.SASH then if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_BOTTOM) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_TOP) end - else -- nChildType == WIN_AREATYPES.FILL + + elseif nChildrenType == WIN_CHILDREN_TYPES.FILL then if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_BOTTOM) EgtSetInfo( nOutlineLayerId, WIN_BOTTOMRAIL, true) else EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_TOP) end + + elseif nChildrenType == WIN_CHILDREN_TYPES.MIXED then + 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 @@ -441,10 +542,10 @@ local function CalcProfileType( nAreaId) end else local sName = EgtGetName( nOutlineId) - if sName ~= WIN_BOTTOM then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) - else + if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM) + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) end end nOutlineId = EgtGetNext( nOutlineId) @@ -455,10 +556,10 @@ local function CalcProfileType( nAreaId) local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) while nOutlineId do local sName = EgtGetName( nOutlineId) - if sName ~= WIN_BOTTOM then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) - else + if sName == WIN_BOTTOM then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM) + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) end nOutlineId = EgtGetNext( nOutlineId) end @@ -488,9 +589,10 @@ local function CalculateAreaProfileType( nAreaId) end ---------------------------------------------------------------------- ---------------------- CALCOLO OUTLINE ------------------------------- ---------------------------------------------------------------------- + +---------------------------------------------------------------------------------- +------------------------------ CALCOLO OUTLINE --------------------------------- +---------------------------------------------------------------------------------- -- funzione che calcola l'outline dall'area outline ( base outline) local function CalculateOutlineFromAreaOutline( nAreaId) @@ -536,19 +638,20 @@ local function CalculateOutlineFromAreaOutline( nAreaId) 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 + + -- 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 @@ -588,6 +691,11 @@ local function CalculateOutlineFromAreaOutline( nAreaId) -- 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 @@ -596,11 +704,8 @@ local function CalculateOutlineFromAreaOutline( nAreaId) local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) - -- recupero tipo di profili anta + -- recupero profilo local sSashProfile = EgtGetInfo( nBaseOutlineId, WIN_PROFILETYPE) - -- recupero profilo usato per anta - 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 @@ -613,6 +718,8 @@ local function CalculateOutlineFromAreaOutline( nAreaId) EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId) EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId) EgtSetInfo( nOutlineId, WIN_PROFILETYPE, sSashProfile) + EgtRemoveInfo( nOutlineId, WIN_PRF_CHANGE) + EgtRemoveInfo( nOutlineId, WIN_REF_SPLIT) -- 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 @@ -627,17 +734,13 @@ local function CalculateOutlineFromAreaOutline( nAreaId) nFrameBaseOutlineId = EgtGetInfo( nFrameBaseOutlineId, WIN_SOU , 'i') sFrameProfile = EgtGetInfo( nFrameBaseOutlineId or GDB_ID.NULL, WIN_PROFILETYPE) end - local nFrameProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_FRAME) local nFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileLayerId, sFrameProfile) - -- recupero le relative origini - local nFrameFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileId, WIN_SECTIONFRAME) - local frFrameProfileId = EgtFR( nFrameFrameProfileId) -- calcolo il box del riferimento del profilo del frame - local nRefFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileId, WIN_REF) - local b3FrameProfile = EgtGetBBoxRef( nRefFrameProfileId, GDB_BB.STANDARD, frFrameProfileId) + local b3FrameProfile = GetProfileLocalBox( nFrameProfileId) -- calcolo offset perpendicolare - local dOverlap = EgtGetInfo( nSashProfileId, WIN_OVERLAP, 'd') + 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 @@ -666,9 +769,7 @@ local function CalculateOutlineFromAreaOutline( nAreaId) -- recupero profilo usato per anta local sSplitProfile = EgtGetInfo( nBaseSplitId, WIN_PROFILETYPE) - local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) - local nSplitProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH) - local nSplitProfileId = EgtGetFirstNameInGroup( nSplitProfileLayerId, sSplitProfile) + local nSplitProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSplitProfile) -- calcolo offset sulla z dell'anta local dSplitZOffset = EgtGetInfo( nSplitProfileId, WIN_DELTA, 'd') -- sposto split in Z @@ -696,18 +797,16 @@ local function CalculateOutlineFromAreaOutline( nAreaId) nParentBaseOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_SOU , 'i') sParentProfile = EgtGetInfo( nParentBaseOutlineId or GDB_ID.NULL, WIN_PROFILETYPE) end - local nParentOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_COPY) + local nParentOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_COPY, 'i') local nParentProfileId = GetOutlineProfileId( nParentOutlineId, true) - - -- recupero le relative origini - local nFrameParentProfileId = EgtGetFirstNameInGroup( nParentProfileId, WIN_SECTIONFRAME) - local frParentProfileId = EgtFR(nFrameParentProfileId) + -- calcolo il box del riferimento del profilo del frame - local nRefParentProfileId = EgtGetFirstNameInGroup( nParentProfileId, WIN_REF) - local b3FrameProfile = EgtGetBBoxRef( nRefParentProfileId, GDB_BB.STANDARD, frParentProfileId) + local b3FrameProfile = GetProfileLocalBox( nParentProfileId) -- calcolo offset perpendicolare e sulla z dell'anta local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd') - local dFillPerpOffset = abs( b3FrameProfile:getMin():getX()) - dOverlap + 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 local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd') -- faccio offset e muovo in z @@ -737,55 +836,18 @@ end ---------------------------------------------------------------------- ----------------------- CALCOLO PEZZI ------------------------------ ---------------------------------------------------------------------- --- 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_GEOWIDTH, dGlassThickness) - return nGeoLayerId -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_GEOWIDTH, 'd') - local nSurfId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nCompoOutlineId, Z_AX() * dGlassThickness) - EgtErase( nCompoOutlineId) -end - --------------------------------------------------------------------- +---------------------------------------------------------------------------------- +------------------------ FUNZIONI AUX PER CALCOLO PEZZI ------------------------ +---------------------------------------------------------------------------------- -- funzione che restituisce il WIN_PRF in base al nome della curva local function GetOutlineProfileType( nOutlineId, bBottomRail) -- ricavo tipo dal nome local sName = EgtGetName( nOutlineId) local nProfileType = WIN_PRF.NULL - if bBottomRail then - nProfileType = WIN_PRF.BOTTOMRAIL - elseif sName == WIN_TOP then + if sName == WIN_TOP then nProfileType = WIN_PRF.TOP elseif sName == WIN_BOTTOM then - nProfileType = WIN_PRF.BOTTOM + nProfileType = EgtIf( bBottomRail, WIN_PRF.BOTTOMRAIL, WIN_PRF.BOTTOM) elseif sName == WIN_LEFT then nProfileType = WIN_PRF.LEFT elseif sName == WIN_RIGHT then @@ -825,15 +887,16 @@ local function GetSplitOtherOutline( nSplitId, nSurfSplit, nOutlineId, bPrevOrNe 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, 0.5) + EgtTrimCurveStartAtParam( nCompoTest, 1 - dParTest) EgtAddCurveCompoLine( nCompoTest, EgtSP( nCrv2)) - EgtTrimCurveEndAtParam( nCrv2, 0.5) + EgtTrimCurveEndAtParam( nCrv2, dParTest) else -- considero solo la parte iniziale del pezzo - EgtTrimCurveEndAtParam( nCompoTest, 0.5) - EgtTrimCurveStartAtParam( nCrv2, 0.5) + EgtTrimCurveEndAtParam( nCompoTest, dParTest) + EgtTrimCurveStartAtParam( nCrv2, 1 - dParTest) EgtAddCurveCompoLine( nCompoTest, EgtSP( nCrv2)) end EgtAddCurveCompoCurve( nCompoTest, nCrv2) @@ -850,10 +913,6 @@ local function GetSplitOtherOutline( nSplitId, nSurfSplit, nOutlineId, bPrevOrNe else vOutlineIds = { nOutlineId, nCrv} end - - -- aggiorno le info di intersezione dello split per non dover ripetere questo calcolo nelle future chiamate a GetPrevNextOutline - local vBaseOutlineId = { EgtGetInfo( vOutlineIds[1], WIN_COPY, 'i'), EgtGetInfo( vOutlineIds[2], WIN_COPY, 'i')} - EgtSetInfo( nSplitId, EgtIf( bPrevOrNext, WIN_SPLIT_STARTINTERS, WIN_SPLIT_ENDINTERS), vBaseOutlineId) end EgtErase( nCompoTest) @@ -890,10 +949,7 @@ local function GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) -- costruisco una regione approssimata per il pezzo dello split local nGrp = EgtGetParent( nOutlineId) local nSplitProfileId = GetOutlineProfileId( nOutlineId, false) - local nRefId = EgtGetFirstNameInGroup( nSplitProfileId, WIN_REF) - local nFrameId = EgtGetFirstNameInGroup( nSplitProfileId, WIN_SECTIONFRAME) - local frProfile = EgtFR( nFrameId) - local b3Profile = EgtGetBBoxRef( nRefId, GDB_BB.STANDARD, frProfile) + local b3Profile = GetProfileLocalBox( nSplitProfileId) local nCrvOut = EgtCopyGlob( nOutlineId, nGrp) local nCrvIn = EgtCopyGlob( nOutlineId, nGrp) EgtOffsetCurve( nCrvOut, b3Profile:getMax():getX()) @@ -926,32 +982,65 @@ 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 profilo di split + -- gestione particolare del caso di split o cambio profilo if not EgtGetFirstNameInGroup( nPrevProfileId, sPrevCtrIn) 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 _, _, dSide = EgtPointCurveDistSide( EgtMP( nOutlineId), nPrevSouId, Z_AX()) - if dSide == 1 then - sPrevCtrIn = WIN_CTRIN .. '1' -- dx + + 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 - sPrevCtrIn = WIN_CTRIN .. '2' -- sx + -- 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 +local function CreateGeoArea( nGeoLayId, nDestLayId) ---------------------------------------------------------------------- ---------------------------- GEO ----------------------------------- ---------------------------------------------------------------------- + local vCrvs = EgtGetAllInGroup( nGeoLayId) + local nCompoId = EgtCurveCompoByChain( nDestLayId, vCrvs, EgtSP( vCrvs[1]), false) + EgtChangeClosedCurveStartPoint( nCompoId, EgtSP( vCrvs[1])) + -- verifico che orientamento della composita rispecchi quello della curva out + if not AreSameVectorApprox( EgtSV( nCompoId), EgtSV( vCrvs[1])) then + EgtInvertCurve( nCompoId) + end + local nArea = EgtSurfFlatRegion( nDestLayId, nCompoId) + -- controllo per eventuale autointersezione del geo di un pezzo di split + local vtN = EgtSurfFrNormVersor( nArea) + if AreOppositeVectorApprox( vtN, Z_AX()) then + EgtErase( nArea) + local nGeoIn = EgtGetFirstNameInGroup( nGeoLayId, WIN_GEO_IN) + EgtChangeClosedCurveStartPoint( nCompoId, EgtSP( nGeoIn)) + nArea = EgtSurfFlatRegion( nDestLayId, nCompoId) + end + EgtErase( nCompoId) + + 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) @@ -991,9 +1080,9 @@ local function CalcFrameProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutl EgtSetInfo( nMainProfileId, WIN_PRF_TYPE, sMainProfileType) EgtSetName( nMainProfileId, WIN_PRF_MAIN) - -- recupero controprofili start e ne creo copia + -- 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 - -- se il tipo corrente è split il pezzo va tagliato con il bottomrail, altrimenti con il bottom local nOrigStartProfileId = GetOutlineProfileId( vPrevOutlineId[i], nProfileType == WIN_PRF.SPLIT) local nStartProfileId = EgtCopy( nOrigStartProfileId, nProfileLayerId) local sStartProfileType = EgtGetName( nStartProfileId) @@ -1001,7 +1090,7 @@ local function CalcFrameProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutl EgtSetName( nStartProfileId, WIN_PRF_START) end - -- recupero controprofili end e ne creo copia + -- 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) @@ -1015,6 +1104,8 @@ local function CalcFrameProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutl 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 @@ -1024,7 +1115,7 @@ local function GetDeltaProfile( nProfileId, sCtrIn) local dCPDelta = 0 local nSectionFrId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) - local frSectionFrame = EgtFR( nSectionFrId) + 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 @@ -1040,11 +1131,8 @@ end local function CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStartPartJointType, nEndPartJointType, nGeoLayerId, nProfileLayerId) local nCurrProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) - local nCurrProfileRefId = EgtGetFirstNameInGroup( nCurrProfileId, WIN_REF) -- calcolo spostamento della curva iniziale dovuto a posizione riferimento - local nProfileFrameId = EgtGetFirstNameInGroup( nCurrProfileId, WIN_SECTIONFRAME) - local frProfile = EgtFR( nProfileFrameId) - local b3CurrProfileFrame = EgtGetBBoxRef( nCurrProfileRefId, GDB_BB.STANDARD, frProfile) + local b3CurrProfileFrame = GetProfileLocalBox( nCurrProfileId) local dCurrOffset = b3CurrProfileFrame:getMax():getX() -- creo copie degli outline e le offsetto opportunamente @@ -1060,12 +1148,11 @@ local function CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStar EgtOffsetCurve( nCurrOffsetId, dCurrOffset - b3CurrProfileFrame:getDimX()) EgtInvertCurve( nCurrOffsetId) EgtSetName( nCurrOffsetId, WIN_GEO_IN) - local nSemiProfileIn = EgtGetFirstNameInGroup( nCurrProfileId, WIN_IN) or EgtGetFirstNameInGroup( nCurrProfileId, WIN_IN .. '2') + local nSemiProfileIn = EgtGetFirstNameInGroup( nCurrProfileId, WIN_IN) or EgtGetFirstNameInGroup( nCurrProfileId, WIN_IN .. '2') or EgtGetFirstNameInGroup( nCurrProfileId, WIN_MIXED_COMMON .. WIN_IN) EgtSetInfo( nCurrOffsetId, WIN_SEMI_PROFILE, nSemiProfileIn) -- curve left local vPrevProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_START) - local vStartCPDelta = {} for i = 1, #vPrevOutlineId do local nPrevCurveId local nPrevSemiProfile @@ -1076,32 +1163,28 @@ local function CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStar vtMedia = EgtSV( nOutlineId) vtMedia:rotate( Z_AX(), 90) end - table.insert( vStartCPDelta, 0) 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 dPrevCPDelta = GetDeltaProfile( vPrevProfileId[i], sCtrIn) - EgtOffsetCurve( nPrevCurveId, - dPrevCPDelta) - table.insert( vStartCPDelta, dPrevCPDelta) + local dCPDelta = GetDeltaProfile( vPrevProfileId[i], sCtrIn) + EgtOffsetCurve( nPrevCurveId, - dCPDelta) -- ricavo il semiprofilo associato nPrevSemiProfile = EgtGetFirstNameInGroup( vPrevProfileId[i], sCtrIn) else - table.insert( vStartCPDelta, 0) 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 - EgtSetInfo( nGeoLayerId, WIN_STARTCPDELTA, vStartCPDelta) - + -- curve right local vNextProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_END) - local vNextCPDelta = {} for i = 1, #vNextOutlineId do local nNextCurveId local nNextSemiProfile @@ -1110,74 +1193,34 @@ local function CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStar local vtMedia = ( ( EgtSV( vNextOutlineId[i]) - EgtEV( nOutlineId)) / 2) if not vtMedia:normalize() then vtMedia = EgtEV( nOutlineId) - vtMedia:rotate(Z_AX(), 90) + vtMedia:rotate( Z_AX(), 90) end - table.insert( vNextCPDelta, 0) 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 dNextCPDelta = GetDeltaProfile( vNextProfileId[i], sCtrIn) - EgtOffsetCurve( nNextCurveId, - dNextCPDelta) - table.insert( vNextCPDelta, dNextCPDelta) + local dCPDelta = GetDeltaProfile( vNextProfileId[i], sCtrIn) + EgtOffsetCurve( nNextCurveId, - dCPDelta) -- ricavo il semiprofilo associato nNextSemiProfile = EgtGetFirstNameInGroup( vNextProfileId[i], sCtrIn) else - table.insert( vNextCPDelta, 0) 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, nCurrOffsetId, GDB_IN.BEFORE) end - EgtSetInfo( nGeoLayerId, WIN_ENDCPDELTA, vNextCPDelta) -- trim delle curve TrimAndOrientOrderedCurveLayer( nGeoLayerId, false) - -- salvo spessore serramento nella curva out + -- salvo spessore serramento nel gruppo local dGeoWidth = b3CurrProfileFrame:getDimX() - EgtSetInfo( nCurrCurveId, WIN_GEOWIDTH, dGeoWidth) + EgtSetInfo( nGeoLayerId, WIN_GEOWIDTH, dGeoWidth) - return nCurrCurveId -end - ---------------------------------------------------------------------- --- funzione che calcola le lavorazioni di profiling -local function CalcProfilingProcessings( nPartId, nGeoLayerId) - - -- creo gruppo delle lavorazioni - local nProcGrp = EgtGroup( nPartId) - EgtSetName( nProcGrp, WIN_PRC) - EgtSetStatus( nProcGrp, GDB_ST.OFF) - -- recupero tutte le curve del geo - local vGeoCrvs = EgtGetAllInGroup( nGeoLayerId) - for i = 1, #vGeoCrvs do - -- copio curva - local nCrv = EgtCopyGlob( vGeoCrvs[i], nProcGrp) - - -- recupero il semiprofilo associato - local nSemiProfile = EgtGetInfo( nCrv, WIN_SEMI_PROFILE, 'i') - if nSemiProfile then - -- setto info di lavorazione - EgtSetInfo( nCrv, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) - -- recupero le info di lavorazione dal semiprofilo - CopyInfo( nCrv, nSemiProfile, WIN_PRC_PHASE) - CopyInfo( nCrv, nSemiProfile, WIN_PRC_PROFILE_TYPE) - 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 end --------------------------------------------------------------------- @@ -1190,6 +1233,8 @@ local function CalcFrameGeo( nPartId, nOutlineId, nOutlineCrvNbr, nOutlineLayerI -- 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 @@ -1228,752 +1273,1478 @@ local function CalcFrameGeo( nPartId, nOutlineId, nOutlineCrvNbr, nOutlineLayerI local nStartPartJointType = CalcPartJointType( nProfileTypeS, nStartJointType) local nEndPartJointType = CalcPartJointType( nProfileTypeE, nEndJointType) - -- salvo i valori joint su outline per disegno solido e calcolo dowels - EgtSetInfo( nOutlineId, WIN_STARTJOINT, nStartPartJointType) - EgtSetInfo( nOutlineId, WIN_ENDJOINT, nEndPartJointType) + -- salvo il valore di start joint su outline per calcolo dowels + -- 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 then + EgtSetInfo( nOutlineId, WIN_STARTJOINT, nStartPartJointType) + end -- creo il gruppo con i profili del pezzo local nProfileLayerId = CalcFrameProfiles( nPartId, nOutlineId, vPrevOutlineId, vNextOutlineId, nProfileType) -- creo lati dell'outline - local nGeoOutId = CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStartPartJointType, nEndPartJointType, nGeoLayerId, nProfileLayerId) + CreateFrameGeo( nOutlineId, vPrevOutlineId, vNextOutlineId, nStartPartJointType, nEndPartJointType, nGeoLayerId, nProfileLayerId) - -- calcolo le lavorazioni associate ai profili - CalcProfilingProcessings( nPartId, nGeoLayerId) - - return nGeoOutId -end - - ---------------------------------------------------------------------------------- ----------------------------------- DOWELS ---------------------------------------- ----------------------------------------------------------------------------------- -local function AddStartDowels( nOutlineId, nPrevOutlineId, nProfileLayerId, nDowelLayerId, nGeoLayerId, nMainExtrusionId) - - local sOutlineName = EgtGetName( nOutlineId) - local sPrevOutlineName = EgtGetName( nPrevOutlineId) - - local nGeoInId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN) - local nGeoLeftId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_LEFT) - - local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) - local nStartProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_START) - - local nStartJointType = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'i') - if nStartJointType == WIN_PART_JNT.ANGLED then - - elseif nStartJointType == WIN_PART_JNT.FULL then - -- recupero profondita' d'inizio e fine - local sStart = EgtIf( sOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPERPSTART, WIN_DWL_TOPPERPSTART) - local sEnd = EgtIf( sOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPERPEND, WIN_DWL_TOPPERPEND) - - -- calcolo il riferimento del profilo - local nFrameProfile = EgtGetFirstNameInGroup( nStartProfileId, WIN_SECTIONFRAME) - local frOrig = EgtFR( nFrameProfile, GDB_ID.ROOT) - frOrig:invert() - -- calcolo il riferimento su cui posizionare i dowel - local ptInt = EgtSP( nGeoLeftId) - local vtRef = EgtSV( nGeoLeftId) - local frDest = Frame3d( ptInt, - vtRef) - - -- ciclo sui fori trovati - local nOrigDowelId = EgtGetFirstNameInGroup( nStartProfileId, WIN_DOWEL .. '*') - while nOrigDowelId do - local dStart = EgtGetInfo( nOrigDowelId, sStart, 'd') - if not dStart then - dStart = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPSTART, 'd') or 0 - end - local dEnd = EgtGetInfo( nOrigDowelId, sEnd, 'd') - if not dEnd then - dEnd = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPEND, 'd') or 0 - end - - local nDowelId = EgtCopyGlob( nOrigDowelId, nDowelLayerId) - EgtSetColor( nDowelId, Color3d( 128, 128, 128)) - -- posiziono il dowel grazie ai riferimenti e assegno estrusione e spessore - EgtTransform( nDowelId, frOrig, GDB_RT.GLOB) - EgtTransform( nDowelId, frDest, GDB_RT.GLOB) - EgtMove( nDowelId, dStart * vtRef) - EgtModifyCurveExtrusion( nDowelId, - vtRef) - EgtModifyCurveThickness( nDowelId, - ( dEnd - dStart)) - -- setto info di lavorazione - EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) - EgtSetInfo( nDowelId, WIN_PRC_DWL_SIDE, WIN_PRC_DWL_SIDETYPE.IN) - - if bCalcSolid then - -- creo solido di estrusione - local nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nDowelLayerId, nDowelId, vtRef * ( dEnd - dStart + 1)) - EgtMove( nDowelExtrusionId, - vtRef) - -- sottraggo il dowel al solido - EgtSurfTmSubtract( nMainExtrusionId, nDowelExtrusionId) - EgtErase( nDowelExtrusionId) - end - - nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*') - end - - elseif nStartJointType == WIN_PART_JNT.SHORT then - -- recupero info di profondita' d'inizio e fine in base al profilo dello start - local sStart = WIN_DWL_TOPPARASTART - local sEnd = WIN_DWL_TOPPARAEND - if sPrevOutlineName == WIN_BOTTOM then - sStart = WIN_DWL_BOTTOMPARASTART - sEnd = WIN_DWL_BOTTOMPARAEND - end - if sOutlineName == WIN_SPLIT then - local sStartProfileType = EgtGetInfo( nStartProfileId, WIN_PRF_TYPE) - if sStartProfileType == WIN_RAIL_BOTTOM then - sStart = WIN_DWL_RAILBOTTOMPARASTART - sEnd = WIN_DWL_RAILBOTTOMPARAEND - elseif sStartProfileType == WIN_SASH_HORIZONTAL then - sStart = WIN_DWL_HORIZONTALSPLITPARASTART - sEnd = WIN_DWL_HORIZONTALSPLITPARAEND - elseif sStartProfileType == WIN_SASH_VERTICAL then - sStart = WIN_DWL_VERTICALSPLITPARASTART - sEnd = WIN_DWL_VERTICALSPLITPARAEND - elseif sStartProfileType == WIN_FRAME_SPLIT or sStartProfileType == WIN_SASH_SPLIT then - sStart = WIN_DWL_SPLITPARASTART - sEnd = WIN_DWL_SPLITPARAEND - end - end - - -- calcolo il riferimento del profilo - local nFrameProfile = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTIONFRAME) - local frOrig = EgtFR( nFrameProfile, GDB_ID.ROOT) - frOrig:invert() - -- calcolo il riferimento su cui posizionare i dowel - local nLeftCopy = EgtCopyGlob( nGeoLeftId, nDowelLayerId) - EgtExtendCurveStartByLen( nLeftCopy, 200) - EgtExtendCurveEndByLen( nLeftCopy, 200) - local ptInt = EgtIP( nOutlineId, nLeftCopy, ORIG()) - EgtErase( nLeftCopy) - if not ptInt then - return - end - - local dParRef = EgtCurveParamAtPoint( nOutlineId, ptInt) - local vtRef = EgtUV( nOutlineId, dParRef, -1) - local frDest = Frame3d( ptInt, - vtRef) - - -- ciclo sui fori trovati - local nOrigDowelId = EgtGetFirstNameInGroup( nMainProfileId, WIN_DOWEL .. '*') - while nOrigDowelId do - local dStart = EgtGetInfo( nOrigDowelId, sStart, 'd') - if not dStart then - dStart = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPARASTART, 'd') or 0 - end - local dEnd = EgtGetInfo( nOrigDowelId, sEnd, 'd') - if not dEnd then - dEnd = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPARAEND, 'd') or 0 - end - - local nDowelId = EgtCopyGlob( nOrigDowelId, nDowelLayerId) - EgtSetColor( nDowelId, Color3d( 128, 128, 128)) - -- posiziono il dowel grazie ai riferimenti e assegno estrusione e spessore - EgtTransform( nDowelId, frOrig) - EgtTransform( nDowelId, frDest) - EgtMove( nDowelId, vtRef * dStart) - EgtModifyCurveExtrusion( nDowelId, - vtRef) - EgtModifyCurveThickness( nDowelId, - ( dEnd - dStart)) - -- setto info di lavorazione - EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) - EgtSetInfo( nDowelId, WIN_PRC_DWL_SIDE, WIN_PRC_DWL_SIDETYPE.LEFT) - - if bCalcSolid then - -- creo solido di estrusione - local nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nDowelLayerId, nDowelId, vtRef * ( dEnd - dStart + 1)) - EgtMove( nDowelExtrusionId, - vtRef) - -- sottraggo il dowel al solido - EgtSurfTmSubtract( nMainExtrusionId, nDowelExtrusionId) - EgtErase( nDowelExtrusionId) - end - - nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*') - end - end end --------------------------------------------------------------------- -local function AddEndDowels( nOutlineId, nEndOutlineId, nProfileLayerId, nDowelLayerId, nGeoLayerId, nMainExtrusionId) - - local sOutlineName = EgtGetName( nOutlineId) - local sEndOutlineName = EgtGetName( nEndOutlineId) - - local nGeoInId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN) - local nGeoRightId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) - - local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) - local nEndProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END) - - local nEndJointType = EgtGetInfo( nOutlineId, WIN_ENDJOINT, 'i') - if nEndJointType == WIN_PART_JNT.ANGLED then - - elseif nEndJointType == WIN_PART_JNT.FULL then - -- recupero profondita' d'inizio e fine - local sStart = EgtIf( sOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPERPSTART, WIN_DWL_TOPPERPSTART) - local sEnd = EgtIf( sOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPERPEND, WIN_DWL_TOPPERPEND) - - -- calcolo il riferimento del profilo - local nFrameProfile = EgtGetFirstNameInGroup( nEndProfileId, WIN_SECTIONFRAME) - local frOrig = EgtFR( nFrameProfile, GDB_ID.ROOT) - frOrig:invert() - -- calcolo il riferimento su cui posizionare i dowel - local ptInt = EgtEP( nGeoRightId) - local vtRef = EgtEV( nGeoRightId) - local frDest = Frame3d( ptInt, - vtRef) +-- 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_GEOWIDTH, dGlassThickness) + return nGeoLayerId +end - -- ciclo sui fori trovati - local nOrigDowelId = EgtGetFirstNameInGroup( nEndProfileId, WIN_DOWEL .. '*') - while nOrigDowelId do - local dStart = EgtGetInfo( nOrigDowelId, sStart, 'd') - if not dStart then - dStart = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPSTART, 'd') or 0 - end - local dEnd = EgtGetInfo( nOrigDowelId, sEnd, 'd') - if not dEnd then - dEnd = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPEND, 'd') or 0 - end - - local nDowelId = EgtCopyGlob( nOrigDowelId, nDowelLayerId) - EgtSetColor( nDowelId, Color3d( 128, 128, 128)) - -- posiziono i fori grazie ai riferimenti e assegno estrusione e spessore - EgtTransform( nDowelId, frOrig) - EgtTransform( nDowelId, frDest) - EgtMove( nDowelId, - vtRef * dStart) - EgtModifyCurveExtrusion( nDowelId, vtRef) - EgtModifyCurveThickness( nDowelId, - ( dEnd - dStart)) - -- setto info di lavorazione - EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) - EgtSetInfo( nDowelId, WIN_PRC_DWL_SIDE, WIN_PRC_DWL_SIDETYPE.IN) - - if bCalcSolid then - -- creo solido di estrusione - local nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nDowelLayerId, nDowelId, - vtRef * ( dEnd - dStart + 1)) - EgtMove( nDowelExtrusionId, vtRef) - -- sottraggo il dowel al solido - EgtSurfTmSubtract( nMainExtrusionId, nDowelExtrusionId) - EgtErase( nDowelExtrusionId) - end - - nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*') - end - - elseif nEndJointType == WIN_PART_JNT.SHORT then - -- recupero profondita' d'inizio e fine - local sStart = WIN_DWL_TOPPARASTART - local sEnd = WIN_DWL_TOPPARAEND - if sEndOutlineName == WIN_BOTTOM then - sStart = WIN_DWL_BOTTOMPARASTART - sEnd = WIN_DWL_BOTTOMPARAEND - end - if sOutlineName == WIN_SPLIT then - local sEndProfileType = EgtGetInfo( nEndProfileId, WIN_PRF_TYPE) - if sEndProfileType == WIN_RAIL_BOTTOM then - sStart = WIN_DWL_RAILBOTTOMPARASTART - sEnd = WIN_DWL_RAILBOTTOMPARAEND - elseif sEndProfileType == WIN_SASH_HORIZONTAL then - -- non faccio nulla perche' e' uguale al top - elseif sEndProfileType == WIN_SASH_VERTICAL then - sStart = WIN_DWL_VERTICALSPLITPARASTART - sEnd = WIN_DWL_VERTICALSPLITPARAEND - elseif sEndProfileType == WIN_FRAME_SPLIT or sEndProfileType == WIN_SASH_SPLIT then - sStart = WIN_DWL_SPLITPARASTART - sEnd = WIN_DWL_SPLITPARAEND - end - end - -- calcolo il riferimento del profilo - local nFrameProfile = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTIONFRAME) - local frOrig = EgtFR( nFrameProfile, GDB_ID.ROOT) - frOrig:invert() - -- calcolo il riferimento su cui posizionare i dowel - local nRightCopy = EgtCopyGlob( nGeoRightId, nDowelLayerId) - EgtExtendCurveStartByLen( nRightCopy, 200) - EgtExtendCurveEndByLen( nRightCopy, 200) - local ptInt = EgtIP( nOutlineId, nRightCopy, ORIG()) - EgtErase( nRightCopy) - if not ptInt then - return + +---------------------------------------------------------------------------------- +----------------------- 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 - local dParRef = EgtCurveParamAtPoint( nOutlineId, ptInt) - local vtRef = EgtUV( nOutlineId, dParRef, -1) - local frDest = Frame3d( ptInt, - vtRef) - - -- ciclo sui fori trovati - local nOrigDowelId = EgtGetFirstNameInGroup( nMainProfileId, WIN_DOWEL .. '*') - while nOrigDowelId do - local dStart = EgtGetInfo( nOrigDowelId, sStart, 'd') - if not dStart then - dStart = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPARASTART, 'd') or 0 + 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 - local dEnd = EgtGetInfo( nOrigDowelId, sEnd, 'd') - if not dEnd then - dEnd = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPARAEND, 'd') or 0 - end - - local nDowelId = EgtCopyGlob( nOrigDowelId, nDowelLayerId) - EgtSetColor( nDowelId, Color3d( 128, 128, 128)) - -- posiziono i fori grazie ai riferimenti e assegno estrusione e spessore - EgtTransform( nDowelId, frOrig, GDB_RT.GLOB) - EgtTransform( nDowelId, frDest, GDB_RT.GLOB) - EgtMove( nDowelId, - vtRef * dStart) - EgtModifyCurveExtrusion( nDowelId, vtRef) - EgtModifyCurveThickness( nDowelId, - ( dEnd - dStart)) - -- setto info di lavorazione - EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) - EgtSetInfo( nDowelId, WIN_PRC_DWL_SIDE, WIN_PRC_DWL_SIDETYPE.RIGHT) - - if bCalcSolid then - -- creo solido di estrusione - local nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nDowelLayerId, nDowelId, - vtRef * ( dEnd - dStart + 1)) - EgtMove( nDowelExtrusionId, vtRef) - -- sottraggo il dowel al solido - EgtSurfTmSubtract( nMainExtrusionId, nDowelExtrusionId) - EgtErase( nDowelExtrusionId) - end - - nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*') end end + + return nGrp end --------------------------------------------------------------------- --- funzione che calcola intersezione, geometrie e superfici dei dowel degli split -local function CalSplitDowel( nSplitLayerId, nOutlineId, nProfileType, nPartId) +-- 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) - -- verifico se interseca l'outline che sto analizzando - local nSplitId = EgtGetFirstInGroup( nSplitLayerId) - local ptInt = EgtIP( nOutlineId, nSplitId, EgtSP( nSplitId)) - if not ptInt then - return - end - -- TO DO gestire il caso in cui lo split ha due intersezioni con l'outline + local nGrp = EgtGroup( nPartId) + EgtSetName( nGrp, WIN_MIXED_INTERSECTIONS) + EgtSetStatus( nGrp, GDB_ST.OFF) - -- se interseca, recupero il profilo dello split - local nOrigSplitProfileId = GetOutlineProfileId( nSplitId, false) - - -- creo copia del profilo - local nFrameProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) - local nSplitProfileId = EgtCopy( nOrigSplitProfileId, nFrameProfileLayerId) - local sSplitProfileType = EgtGetName( nOrigSplitProfileId) - EgtSetInfo( nSplitProfileId, WIN_PRF_TYPE, sSplitProfileType) - EgtSetName( nSplitProfileId, WIN_PRF_SPLIT) - - -- recupero intersezione 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, EgtSP( nSplitId)) - local sDowelRefSide = WIN_PRC_DWL_SIDETYPE.IN - if not ptInters and nProfileType == WIN_PRF.SPLIT then - nGeoCrvId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT) - ptInters = EgtIP( nGeoCrvId, nSplitId, EgtSP( nSplitId)) - sDowelRefSide = WIN_PRC_DWL_SIDETYPE.OUT - end - -- se non trovo intersezione esco ( TO DO da sistemare perchè anche se non trova intersezione potrebbe essere coinvolto dai dowels dello split!) - if not ptInters then - return - end - - -- recupero frame del profilo e lo applico a tutte le sue geometrie - local nSplitProfileFrameId = EgtGetFirstNameInGroup( nSplitProfileId, WIN_SECTIONFRAME) - local frInvertSplitProfile = EgtFR( nSplitProfileFrameId) - frInvertSplitProfile:invert() - EgtTransform( EgtGetAllInGroup( nSplitProfileId), frInvertSplitProfile) - -- assegno come riferimento del profilo il punto di intersezione e la direzione dello split - local vtDir = - EgtSV( nSplitId) -- se non fosse lineare potrebbe essere end vector ? - EgtChangeGroupFrame( nSplitProfileId, Frame3d( ptInters, vtDir)) - - -- calcolo la direzione del dowel sempre verso l'interno del pezzo - local vtDowelDir = Vector3d( vtDir) - local _, _, nSide = EgtPointCurveDistSide( ptInters + vtDowelDir, nGeoCrvId, Z_AX()) - if nSide == 1 then - -- se a destra della curva significa che la direzione è uscente dal pezzo e va invertita - vtDowelDir = - vtDowelDir - end - - -- recupero solido del pezzo ( se non esiste è nil) - local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) or GDB_ID.NULL - local nMainExtrusionId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_SRF_MAIN) - - -- creo fori per spine su Split - local nProcLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PRC) - - -- recupero profondita' d'inizio e fine - local sStart = WIN_DWL_TOPPERPSTART - local sEnd = WIN_DWL_TOPPERPEND - if nProfileType == WIN_PRF.BOTTOM then - sStart = WIN_DWL_BOTTOMPERPSTART - sEnd = WIN_DWL_BOTTOMPERPEND - elseif nProfileType == WIN_PRF.BOTTOMRAIL then - sStart = WIN_DWL_RAILBOTTOMPERPSTART - sEnd = WIN_DWL_RAILBOTTOMPERPEND - elseif nProfileType == WIN_PRF.SPLIT then - local sProfileType = EgtGetInfo( nOutlineId, WIN_PROFILETYPE) - if sProfileType == WIN_SASH_HORIZONTAL then - -- se poggia sul controprofilo CntrIn2 leggo le info dello split orizzontale, altrimenti vanno bene quelle del top - -- ( cfr AddStartDowels e AddEndDowels) - if AreSamePointApprox( ptInt, EgtSP( nSplitId)) then - sStart = WIN_DWL_HORIZONTALSPLITPERPSTART - sEnd = WIN_DWL_HORIZONTALSPLITPERPEND - end - elseif sProfileType == WIN_SASH_VERTICAL then - sStart = WIN_DWL_VERTICALSPLITPERPSTART - sEnd = WIN_DWL_VERTICALSPLITPERPEND - else -- sProfileType == WIN_FRAME_SPLIT - sStart = WIN_DWL_SPLITPERPSTART - sEnd = WIN_DWL_SPLITPERPEND - end - end - - -- ciclo sui fori trovati - local nOrigDowelId = EgtGetFirstNameInGroup( nSplitProfileId, WIN_DOWEL .. '*') - while nOrigDowelId do - local dStart = EgtGetInfo( nOrigDowelId, sStart, 'd') - if not dStart then - dStart = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPSTART, 'd') - end - local dEnd = EgtGetInfo( nOrigDowelId, sEnd, 'd') - if not dEnd then - dEnd = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPEND, 'd') - end - local nDowelId = EgtCopyGlob( nOrigDowelId, nProcLayerId) - EgtSetColor( nDowelId, Color3d( 128, 128, 128)) - - -- posiziono il dowel e gli assegno estrusione e spessore - EgtMove( nDowelId, vtDowelDir * dStart) - EgtModifyCurveExtrusion( nDowelId, - vtDowelDir) - EgtModifyCurveThickness( nDowelId, - ( dEnd - dStart)) - -- setto info di lavorazione - EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) - EgtSetInfo( nDowelId, WIN_PRC_DWL_SIDE, sDowelRefSide) - - if bCalcSolid then - -- creo solido di estrusione - local nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nDowelId, vtDowelDir * ( dEnd - dStart + 1)) - EgtMove( nDowelExtrusionId, - vtDowelDir) - -- sottraggo il dowel al solido - EgtSurfTmSubtract( nMainExtrusionId, nDowelExtrusionId) - EgtErase( nDowelExtrusionId) - end - - nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*') - end -end - ----------------------------------------------------------------------------------- --- funzione che cicla ricorsivamente sulle aree e sottoaree relative al pezzo per aggiungere gli split dowels -local function AddAreaSplitDowels( nOutlineId, nPartId, nProfileType, nAreaLayerId) - - -- verifico la presenza di eventuali split nell'area corrente - local nSplitLayerId = EgtGetFirstNameInGroup( nAreaLayerId, WIN_SPLIT) - if nSplitLayerId then - local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL - if nSplitType ~= WIN_SPLITTYPES.FRENCH then - CalSplitDowel( nSplitLayerId, nOutlineId, nProfileType, nPartId) - end - end - - -- verifico la presenza di split nelle sottoaree - local nChildAreaId = EgtGetFirstNameInGroup( nAreaLayerId, WIN_AREA .. '*') - while nChildAreaId do - local nAreaType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, 'i') - if nAreaType == WIN_AREATYPES.SPLIT then - AddAreaSplitDowels( nOutlineId, nPartId, nProfileType, nChildAreaId) - end - nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*') - end -end - ----------------------------------------------------------------------------------- --- funzione che aggiunge al solido i dowels degli split che lo intersecano -local function AddSplitDowels( nOutlineId, nOutlineLayerId, nPartId, nProfileType) - - -- se profilo bottom con BottomRail esco ( gli split dowels saranno aggiuti sul BottomRail associato) - if nProfileType == WIN_PRF.BOTTOM then - local bBottomRail = EgtGetInfo( nOutlineLayerId, WIN_BOTTOMRAIL, 'b') or false - if bBottomRail then - return - end - end - - -- recupero area del pezzo - local nAreaLayerId = EgtGetParent( nOutlineLayerId) - -- aggiungo gli split dowels a partire dall'area corrente - AddAreaSplitDowels( nOutlineId, nPartId, nProfileType, nAreaLayerId) -end - ---------------------------------------------------------------------- --- funzione che crea i fori per le spine -local function CalcFrameDowels( nPartId, nOutlineId, nOutlineLayerId, nProfileType) - - -- creo fori per spine su Start ed End - local vPrevOutlineId, vNextOutlineId = GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) + -- recupero il profilo dell'outline local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) - local nProcLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PRC) - local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO) - local nMainExtrusionId - if bCalcSolid then - local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) - nMainExtrusionId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_SRF_MAIN) + 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}) + + -- cancello curve di costruzione + EgtErase( { nCrv1, nCrv2, nCrv3, nCrv4}) + + -- assegno riferimento + EgtSetInfo( vOutlines[i], WIN_MIXED_INTERS_REF, nCrv) end - for i = 1, #vPrevOutlineId do - AddStartDowels( nOutlineId, vPrevOutlineId[i], nProfileLayerId, nProcLayerId, nGeoLayerId, nMainExtrusionId) - end - for i = 1, #vNextOutlineId do - AddEndDowels( nOutlineId, vNextOutlineId[i], nProfileLayerId, nProcLayerId, nGeoLayerId, nMainExtrusionId) - end - - -- split dowels - AddSplitDowels( nOutlineId, nOutlineLayerId, nPartId, nProfileType) 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) + -- recupero le info di lavorazione dal semiprofilo + CopyInfo( nCrv, nSemiProfile, WIN_PRC_PHASE) + CopyInfo( nCrv, nSemiProfile, WIN_PRC_PROFILE_TYPE) + 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 lavorazione per l'innesto dello split sul telaio nel caso di cambio profilo +local function CalcMixedFrameMillingProcessings( nIntersCrv, nOutlineId, dOffs, dDepth, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId) + + local nMilling = EgtCopyGlob( nIntersCrv, nProcLayerId) + EgtExtendCurveStartByLen( nMilling, 100) + + -- calcolo il tratto di outline + local nOutlineCrv = EgtCopyGlob( nOutlineId, nProcLayerId) + EgtOffsetCurve( nOutlineCrv, - dOffs) + if bSashFill then + EgtInvertCurve( nOutlineCrv) + end + local pt1 = EgtIP( nMilling, nOutlineCrv, ORIG()) + local pt2 = EgtIP( nOutlineCrv, nSplitRef, ORIG()) + local dParS = EgtCurveParamAtPoint( nOutlineCrv, pt1) + local dParE = EgtCurveParamAtPoint( nOutlineCrv, pt2) + EgtTrimCurveStartEndAtParam( nOutlineCrv, dParS, dParE) + + -- aggiungo il tratto derivante dall'outline + if not AreSamePointApprox( pt1, EgtEP( nMilling)) then + local dParTrim = EgtCurveParamAtPoint( nMilling, pt1) + EgtTrimCurveEndAtParam( nMilling, dParTrim) + end + EgtAddCurveCompoCurve( nMilling, nOutlineCrv) + + -- aggiungo tratto di uscita a 45° + local vtDir2 = EgtEV( nMilling) + vtDir2:rotate( Z_AX(), EgtIf( bSashFill, - 45, 45)) + EgtAddCurveCompoLine( nMilling, EgtEP( nMilling) + vtDir2 * 100) + + if bSashFill then + EgtInvertCurve( nMilling) + end + EgtModifyCurveThickness( nMilling, - dDepth) + EgtSetInfo( nMilling, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) + EgtTrimCurveWithRegion( nMilling, 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) + -- 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 + local nSemiProfile = EgtGetFirstNameInGroup( nMainProfileId, EgtGetName( vCrvs[i]) .. WIN_IN) + GetProcessingInfoFromSemiProfile( nCrv, nSemiProfile) + 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 + local dOffs1 = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '1', 'd') + local dDepth1 = EgtGetInfo( nMainProfileId, WIN_SASH_DEPTH .. '1', 'd') + CalcMixedFrameMillingProcessings( vInters[i], nOutlineId, dOffs1, dDepth1, nSplitRef, bSashFill, nProcLayerId, nSurfGeoId) + -- Fresatura 2 + local dOffs2 = EgtGetInfo( nMainProfileId, WIN_SASH_REF .. '2', 'd') + local dDepth2 = EgtGetInfo( nMainProfileId, WIN_SASH_DEPTH .. '2', 'd') + CalcMixedFrameMillingProcessings( vInters[i], nOutlineId, dOffs2, dDepth2, 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) + -- 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) + EgtSetName( nMillingLeft, WIN_LEFT) + EgtSetInfo( nMillingLeft, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) + -- 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) + + -- right + local nMixedRight = EgtGetInfo( nSplitId, WIN_MIXED_REF_END, 'i') + local nIntersRight = EgtGetInfo( nMixedRight, WIN_MIXED_INTERS_REF, 'i') + local nMillingRight = EgtCopyGlob( nIntersRight, nProcLayerId) + EgtSetName( nMillingRight, WIN_RIGHT) + EgtSetInfo( nMillingRight, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.PROFILING) + 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) + +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) + EgtSurfFrOffset( nSurfGeo, 50 * GEO.EPS_SMALL) + + -- recupero il gruppo dei profili + local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) + local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) + + -- 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) + -- 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) +end + + ---------------------------------------------------------------------------------- ---------------------------------- SOLIDO ---------------------------------------- ---------------------------------------------------------------------------------- --- funzione che recupera tipo di inizio e fine pezzo -local function CalcStartEndProfileType( nProfileType, nOutlineId, vStartProfileId, vEndProfileId) - - local vsStartProfileType = {} - local vsEndProfileType = {} - - if nProfileType == WIN_PRF.SPLIT then - local vStartBaseOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'vi') - for i = 1, #vStartProfileId do - local nStartId = EgtGetInfo( vStartBaseOutlineId[i], WIN_COPY, 'i') - local sStartProfileType = GetProfileCtrIn( nStartId, nOutlineId, vStartProfileId[i]) - table.insert( vsStartProfileType, WIN_OFST .. sStartProfileType) - end - - local vEndBaseOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'vi') - for i = 1, #vEndProfileId do - local nEndId = EgtGetInfo( vEndBaseOutlineId[i], WIN_COPY, 'i') - local sEndProfileType = GetProfileCtrIn( nEndId, nOutlineId, vEndProfileId[i]) - table.insert( vsEndProfileType, WIN_OFST .. sEndProfileType) - end - +-- funzione che costruisce una superficie estrudendo il profilo sProfileName lungo l'outline +local function CreateProfileSurf( nOutlineId, nProfileId, sProfileName, 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 - local StartJointType = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'i') - if StartJointType == WIN_PART_JNT.ANGLED then - vsStartProfileType = { WIN_MINIZINKEN} - elseif StartJointType == WIN_PART_JNT.SHORT then - vsStartProfileType = { WIN_CTRINOFST} - elseif StartJointType == WIN_PART_JNT.FULL then - vsStartProfileType = { WIN_OUTOFST} - end - - local EndJointType = EgtGetInfo( nOutlineId, WIN_ENDJOINT, 'i') - if EndJointType == WIN_PART_JNT.ANGLED then - vsEndProfileType = { WIN_MINIZINKEN} - elseif EndJointType == WIN_PART_JNT.SHORT then - vsEndProfileType = { WIN_CTRINOFST} - elseif EndJointType == WIN_PART_JNT.FULL then - vsEndProfileType = { WIN_OUTOFST} + nGuideId = EgtCurveCompo( nLayerId, nGuideId) + EgtAddCurveCompoLineTg( nGuideId, dExtraLen) + EgtAddCurveCompoLineTg( nGuideId, dExtraLen, false) + 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 - return vsStartProfileType, vsEndProfileType + -- recupero il profilo da estrudere + local nOrigProfileId = EgtGetFirstNameInGroup( nProfileId, sProfileName) + local nSectionId = EgtCopyGlob( nOrigProfileId, 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( nSectionId, frProfile, GDB_RT.GLOB) + EgtTransform( nSectionId, frDest, GDB_RT.GLOB) + + -- creo la superfice di estrusione + local nStmId = EgtSurfTmSwept( nLayerId, nSectionId, nGuideId, false, WIN_SURF_APPROX) + EgtErase( nGuideId) + EgtErase( nSectionId) + + return nStmId end --------------------------------------------------------------------- --- funzione che crea il solido del pezzo del telaio -local function CalcFrameSolid( nPartId, nOutlineId, nGeoId, nProfileType) +-- 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 la superficie per il taglio a 45° + local nIntersCrvId = EgtGetInfo( nMixedOutlineId, WIN_MIXED_INTERS_REF, 'i') + local nGuideId = EgtCopyGlob( nIntersCrvId, nLayerId) + EgtExtendCurveStartByLen( nGuideId, 10) + EgtExtendCurveEndByLen( nGuideId, 10) + EgtMove( nGuideId, Z_AX()) + if EgtGetName( nMixedOutlineId) ~= WIN_SASH then + EgtInvertCurve( nGuideId) + end + local dDepth = EgtGetInfo( nProfileId, WIN_SASH_DEPTH .. '2', 'd') + local nCutStmId = EgtSurfTmByRegionExtrusion( nLayerId, nGuideId, - ( dDepth + 2) * Z_AX()) + EgtErase( nGuideId) + + return nTrimStmId, nCutStmId +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) + + -- 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) + +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, nAuxStart = CreateMixedSplitTrimSurf( nPrevMixedOutline, nPrevProfileId, dGeoWidth, nSolidLayerId) + EgtSetName( nStmTrimStart, WIN_SRF_START) + EgtSetStatus( nStmTrimStart, GDB_ST.OFF) + EgtSurfTmIntersect( nMainExtrusionId, nStmTrimStart) + EgtSurfTmIntersect( nMainExtrusionId, nAuxStart) + EgtErase( nAuxStart) + + -- c) trim end + local nNextProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END) + local nNextMixedOutline = EgtGetInfo( nOutlineId, WIN_MIXED_REF_END, 'i') + local nStmTrimEnd, nAuxEnd = CreateMixedSplitTrimSurf( nNextMixedOutline, nNextProfileId, dGeoWidth, nSolidLayerId) + EgtSetName( nStmTrimEnd, WIN_SRF_END) + EgtSetStatus( nStmTrimEnd, GDB_ST.OFF) + EgtSurfTmIntersect( nMainExtrusionId, nStmTrimEnd) + EgtSurfTmIntersect( nMainExtrusionId, nAuxEnd) + EgtErase( nAuxEnd) +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 layer delle lavorazioni per i dowels - local nProcLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PRC) - - -- recupero profili e controprofili + -- recupero profilo principale local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) - local nMainProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) - local vStartProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_START) - local vEndProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_END) - - -- recupero geo - local nGeoLayerId = EgtGetParent( nGeoId) - local vPrevGeoId = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT) - local vNextGeoId = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) - -- recupero BBox e larghezza del geo - local dGeoWidth = EgtGetInfo( nGeoId, WIN_GEOWIDTH, 'd') - - -- recupero i controprofili in base al tipo di giunzioni - local vsStartProfileType, vsEndProfileType = CalcStartEndProfileType( nProfileType, nOutlineId, vStartProfileId, vEndProfileId) - - -- verifico se outline è split interno ad area di split per controlli su inversione del profilo - local bSplitInsideSplitArea = false - if nProfileType == WIN_PRF.SPLIT then - local nAreaId = EgtGetParent( EgtGetParent( nOutlineId)) - local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') - bSplitInsideSplitArea = ( nAreaType == WIN_AREATYPES.SPLIT) - end - -- a) MAIN EXTRUSION - -- creo guida Main - local nGuideId = EgtCopy( nOutlineId, nSolidLayerId) - EgtSetName( nGuideId, WIN_MAINGUIDE) - EgtSetStatus( nGuideId, GDB_ST.OFF) - EgtExtendCurveStartByLen( nGuideId, 2 * dGeoWidth) - EgtExtendCurveEndByLen( nGuideId, 2 * dGeoWidth) - -- recupero frame del profilo - local nMainProfileFrameId = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTIONFRAME) - local frInvertMainProfile = EgtFR( nMainProfileFrameId) - frInvertMainProfile:invert() - -- lo applico a tutte le geometrie del profilo - EgtTransform( EgtGetAllInGroup( nMainProfileId), frInvertMainProfile) - -- assegno come riferimento del profilo il punto start dell'outline - EgtChangeGroupFrame( nMainProfileId, Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId))) - -- recupero outline del profilo Main e lo estrudo - local nMainOutlineId = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTION) - local nMainExtrusionId = EgtSurfTmSwept( nSolidLayerId, nMainOutlineId, nGuideId, false, WIN_SURF_APPROX) - EgtSetName( nMainExtrusionId, WIN_SRF_MAIN) - -- creo una copia dell'estrusione principale per trim successivi + -- 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) START PROFILE - local vStartDelta = EgtGetInfo( nGeoLayerId, WIN_STARTCPDELTA, 'vd') + -- 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 - -- posiziono il profilo Start - local nRefStartProfileId = EgtGetFirstNameInGroup( vStartProfileId[i], WIN_REF) - local b3RefStartProfile = EgtGetBBoxGlob( nRefStartProfileId, GDB_BB.STANDARD) - -- creo guida per estrusione con estensione in tangenza - local nStartGuideId = EgtCopy( vPrevGeoId[i], nSolidLayerId) - if EgtGetType( nStartGuideId) == GDB_TY.CRV_LINE then - EgtExtendCurveStartByLen( nStartGuideId, 4 * dGeoWidth) - EgtExtendCurveEndByLen( nStartGuideId, 4 * dGeoWidth) - else - nStartGuideId = EgtCurveCompo( nSolidLayerId, nStartGuideId) - EgtAddCurveCompoLineTg( nStartGuideId, 4 * dGeoWidth) - EgtAddCurveCompoLineTg( nStartGuideId, 4 * dGeoWidth, false) - end - -- recupero frame del profilo - local nStartProfileFrameId = EgtGetFirstNameInGroup( vStartProfileId[i], WIN_SECTIONFRAME) - local frStartProfile = EgtFR( nStartProfileFrameId) - -- lo sposto se controprofilo - frStartProfile:move( - frStartProfile:getVersX() * vStartDelta[i]) - frStartProfile:invert() - -- lo applico a tutte le geometrie del profilo - EgtTransform( EgtGetAllInGroup( vStartProfileId[i]), frStartProfile) - -- assegno come riferimento del profilo il punto start dell'outline - EgtChangeGroupFrame( vStartProfileId[i], Frame3d( EgtSP( nStartGuideId), - EgtSV( nStartGuideId))) - - if bSplitInsideSplitArea then - -- verifico se il suo start deriva da uno split - local vStartId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'vi') - local nStartSouId = vStartId[i] - local sStartSouName - repeat - nStartSouId = EgtGetInfo( nStartSouId, WIN_SOU, 'i') - sStartSouName = EgtGetName( nStartSouId or GDB_ID.NULL) - until not nStartSouId or sStartSouName == WIN_SPLIT - if sStartSouName == WIN_SPLIT then - -- recupero vettore tangente nel punto medio della curva di contorno - local ptMidStart = EgtMP( vStartId[i]) - local vtMidStart = EgtMV( vStartId[i]) - -- recupero vettore tangente nello stesso punto della curva split originale - local dMidStartOnStartSou = EgtCurveParamAtPoint( nStartSouId, ptMidStart) - local vtMidStartSou = EgtUV( nStartSouId, dMidStartOnStartSou, -1) - -- se i due vettori non sono orientati nella stessa direzione - if not AreSameVectorApprox( vtMidStart, vtMidStartSou) then - -- ruoto di 180 gradi il profilo - local frStartProfileS = EgtFR( nStartProfileFrameId, GDB_ID.ROOT) - EgtRotate( vStartProfileId[i], frStartProfileS:getOrigin(), frStartProfileS:getVersY(), 180, GDB_RT.GLOB) - end - end - end - - -- recupero outline del profilo Start e lo estrudo - local nOutStartProfileId - if vsStartProfileType[i] == WIN_MINIZINKEN then - nOutStartProfileId = EgtLine( vStartProfileId[i], EgtSP( vPrevGeoId[i]), EgtSP( vPrevGeoId[i]) - Z_AX() * b3RefStartProfile:getDimY(), GDB_RT.GLOB) - EgtInvertCurve( nOutStartProfileId) - else - nOutStartProfileId = EgtGetFirstNameInGroup( vStartProfileId[i], vsStartProfileType[i]) - end - local nStartExtrusionId = EgtSurfTmSwept( nSolidLayerId, nOutStartProfileId, nStartGuideId, false, WIN_SURF_APPROX) - -- 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, nStartExtrusionId) - EgtErase( nStartExtrusionId) - EgtErase( nStartGuideId) + -- 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) END PROFILE - local vEndDelta = EgtGetInfo( nGeoLayerId, WIN_ENDCPDELTA, 'vd') + + -- 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 - -- posiziono il profilo End - local nRefEndProfileId = EgtGetFirstNameInGroup( vEndProfileId[i], WIN_REF) - local b3RefEndProfile = EgtGetBBoxGlob( nRefEndProfileId, GDB_BB.STANDARD) - -- creo guida per estrusione - local nEndGuideId = EgtCopy( vNextGeoId[i], nSolidLayerId) - if EgtGetType( nEndGuideId) == GDB_TY.CRV_LINE then - EgtExtendCurveStartByLen( nEndGuideId, 4 * dGeoWidth) - EgtExtendCurveEndByLen( nEndGuideId, 4 * dGeoWidth) - else - nEndGuideId = EgtCurveCompo( nSolidLayerId, nEndGuideId) - EgtAddCurveCompoLineTg( nEndGuideId, 4 * dGeoWidth) - EgtAddCurveCompoLineTg( nEndGuideId, 4 * dGeoWidth, false) - end - -- recupero frame del profilo - local nEndProfileFrameId = EgtGetFirstNameInGroup( vEndProfileId[i], WIN_SECTIONFRAME) - local frEndProfile = EgtFR( nEndProfileFrameId) - frEndProfile:move( - frEndProfile:getVersX() * vEndDelta[i]) - frEndProfile:invert() - -- lo applico a tutte le geometrie del profilo - EgtTransform( EgtGetAllInGroup( vEndProfileId[i]), frEndProfile) - -- assegno come riferimento del profilo il punto start dell'outline - EgtChangeGroupFrame( vEndProfileId[i], Frame3d( EgtSP( nEndGuideId), - EgtSV( nEndGuideId))) - - -- verifico se necessario ruotare di 180 gradi il profilo - if bSplitInsideSplitArea then - -- verifico se end deriva da split - local vEndId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'vi') - local nEndSouId = vEndId[i] - local sEndSouName - repeat - nEndSouId = EgtGetInfo( nEndSouId, WIN_SOU) - sEndSouName = EgtGetName( nEndSouId or GDB_ID.NULL) - until not nEndSouId or sEndSouName == WIN_SPLIT - if sEndSouName == WIN_SPLIT then - -- recupero vettore tangente nel punto medio della curva di contorno - local ptMidEnd = EgtMP( vEndId[i]) - local vtMidEnd = EgtMV( vEndId[i]) - -- recupero vettore tangente nello stesso punto della curva split originale - local dMidStartOnEndSou = EgtCurveParamAtPoint( nEndSouId, ptMidEnd) - local vtMidEndSou = EgtUV( nEndSouId, dMidStartOnEndSou, -1) - -- se i due vettori non sono orientati nella stessa direzione - if not AreSameVectorApprox( vtMidEnd, vtMidEndSou) then - -- ruoto di 180 gradi il profilo - local frEndProfileS = EgtFR( nEndProfileFrameId, GDB_ID.ROOT) - EgtRotate( vEndProfileId[i], frEndProfileS:getOrigin(), frEndProfileS:getVersY(), 180, GDB_RT.GLOB) - end - end - end - - -- recupero outline del profilo End e lo estrudo - local nOutEndProfileId - if vsEndProfileType[i] == WIN_MINIZINKEN then - nOutEndProfileId = EgtLine( vEndProfileId[i], EgtSP( vNextGeoId[i]), EgtSP( vNextGeoId[i]) - Z_AX() * b3RefEndProfile:getDimY(), GDB_RT.GLOB) - EgtInvertCurve( nOutEndProfileId) - else - nOutEndProfileId = EgtGetFirstNameInGroup( vEndProfileId[i], vsEndProfileType[i]) - end - local nEndExtrusionId = EgtSurfTmSwept( nSolidLayerId, nOutEndProfileId, nEndGuideId, false, WIN_SURF_APPROX) + -- 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, nEndExtrusionId) - EgtErase( nEndExtrusionId) - EgtErase( nEndGuideId) + EgtSurfTmIntersect( nMainExtrusionId, nTrimSurf) end +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_GEOWIDTH, 'd') + local nSurfId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nCompoOutlineId, Z_AX() * dGlassThickness) + EgtErase( nCompoOutlineId) +end + + + +---------------------------------------------------------------------------------- +---------------------------------- DOWELS ---------------------------------------- +---------------------------------------------------------------------------------- +-- funzione che calcola il riferimento dove posizionare i dowels +local function CreateDowelFrameDest( nRefProfileType, nPrevGeo, nGeo, nRefOutline, bFullOrShort, bSashOrFrame) + + -- 1) la direzione z è quella del pezzo short nel caso rettangolare + local vtZ + if nRefProfileType == WIN_PRF.TOP then + vtZ = - X_AX() + elseif nRefProfileType == WIN_PRF.BOTTOM or nRefProfileType == WIN_PRF.BOTTOMRAIL then + vtZ = X_AX() + elseif nRefProfileType == WIN_PRF.LEFT then + vtZ = - Y_AX() + elseif nRefProfileType == WIN_PRF.RIGHT then + vtZ = Y_AX() + end + local frDest = Frame3d( ORIG(), - vtZ) + + -- 2) punto di origine + local nPrevRight = EgtGetFirstNameInGroup( nPrevGeo, WIN_GEO_RIGHT) + local ptRef1 = EgtIf( bFullOrShort, EgtSP( nPrevRight), EgtEP( nPrevRight)) + local nLeft = EgtGetFirstNameInGroup( nGeo, WIN_GEO_LEFT) + local ptRef2 = EgtIf( bFullOrShort, 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, sLenKey, 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 + local dLen = EgtGetInfo( nOrigDowelId, sLenKey, 'd') + s_dDowelTol + EgtModifyCurveExtrusion( nDowelId, - vtDir) + EgtModifyCurveThickness( nDowelId, - dLen) + + -- setto info di lavorazione + EgtSetInfo( nDowelId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) + EgtSetInfo( nDowelId, WIN_PRC_DWL_SIDE, sDowelSide) + + -- eventuale aggiornamento del solido + if nMainExtrusionId then + -- creo solido di estrusione del dowel + local nDowelExtrusionId + if s_bSimplSolid then + -- creo foro grossolano per velocizzare operazioni di subtract + local nDowelApprox = EgtCopyGlob( nDowelId, nLayerId) + EgtApproxCurve( nDowelApprox, GDB_CA.LINES, 0.2) + nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nLayerId, nDowelApprox, vtDir * dLen) + EgtErase( nDowelApprox) + else + nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nLayerId, nDowelId, vtDir * dLen) + end + -- sottraggo il dowel al solido + EgtSurfTmSubtract( nMainExtrusionId, nDowelExtrusionId) + EgtErase( nDowelExtrusionId) + 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, sLenKey, sPrevLenKey) + + local dMove = 0 + -- se le curve sono due linee ortogonali non serve correzione + if EgtGetType( nOutlineId) == GDB_TY.CRV_LINE and EgtGetType( nPrevOutlineId) == GDB_TY.CRV_LINE then + local vt1 = EgtSV( nPrevOutlineId) + local vt2 = EgtSV( nOutlineId) + local dAng = GetAngleXY( vt1, vt2) + if abs( abs( dAng) - 90) < GEO.EPS_SMALL then + return dMove + end + 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 dLen = EgtGetInfo( nDowel1, sLenKey, 'd') + s_dDowelTol + 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 dPrevLen = EgtGetInfo( nDowel2, sPrevLenKey, 'd') + s_dDowelTol + local dMove2 = EgtCAvToolPosStm( EgtCP( nDowel2) + frDest:getVersZ() * dPrevLen, - frDest:getVersZ(), nTestSurf, vtMove) + + EgtErase( nDowel1) + EgtErase( nDowel2) + + -- calcolo la correzione complessiva + dMove = max( dMove1, dMove2) + return dMove +end + +--------------------------------------------------------------------- +-- funzione che calcola i dowels tra due pezzi +local function CalcDowels( nOutlineId, nPrevOutlineId, bSashOrFrame, bBottomRail) + + -- recupero i pezzi + local nPart = EgtGetInfo( nOutlineId, WIN_REF_PART, 'i') + local nPrevPart = EgtGetInfo( nPrevOutlineId, WIN_REF_PART, 'i') + if bBottomRail then + if EgtGetName( nOutlineId) == WIN_BOTTOM then + nPart = EgtGetInfo( nOutlineId, WIN_REF_BOTTOMRAIL_PART, 'i') + else + nPrevPart = EgtGetInfo( nPrevOutlineId, WIN_REF_BOTTOMRAIL_PART, 'i') + 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) + + -- recupero i geo + local nGeo = EgtGetFirstNameInGroup( nPart, WIN_GEO) + local nPrevGeo = EgtGetFirstNameInGroup( nPrevPart, WIN_GEO) + + -- recupero i tipi di profilo + local nPrevProfileType = GetOutlineProfileType( nPrevOutlineId, bBottomRail) + local nProfileType = GetOutlineProfileType( nOutlineId, bBottomRail) + -- 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 bBottomRail 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) + local sLenKey = EgtIf( nProfileType == WIN_PRF.BOTTOM, WIN_DWL_BOTTOM_PERP_LEN, WIN_DWL_TOP_PERP_LEN) + local sPrevLenKey = EgtIf( nProfileType == WIN_PRF.BOTTOM, WIN_DWL_BOTTOM_PARA_LEN, WIN_DWL_TOP_PARA_LEN) + + -- 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( nOutlineId, nPrevOutlineId, nProfileId) -- controprofilo in del pezzo corrente + nTestSurf = CreateProfileSurf( nOutlineId, 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( nPrevOutlineId, 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( nPrevOutlineId, nOutlineId, nPrevProfileId) + nTestSurf2 = CreateProfileSurf( nPrevOutlineId, 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 = 1, 3 do + -- recupero i dowels della fila k-esima + local vDowels = EgtGetNameInGroup( nPrevProfileId, WIN_DOWEL .. 'Row' .. tostring( k)) + if not vDowels then + break + end + -- 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 dMove = CalcDowelFrameCorrection( nOutlineId, nPrevOutlineId, nDowelRef, frOrig, frDest, nTestSurfInverted, nTestSurf, nTestSurf2, vtMove, nLayerId, sLenKey, sPrevLenKey) + local frDestDowel = Frame3d( frDest) + frDestDowel:move( dMove * vtMove) + for i = 1, #vDowels do + -- dowels per pezzo corrente ( full) + CreateDowel( vDowels[i], nLayerId, frOrig, frDestDowel, - frDestDowel:getVersZ(), nTestSurfInverted, sLenKey, WIN_PRC_DWL_SIDETYPE.IN, nSolidId) + -- dowels per prezzo precedente ( short) + CreateDowel( vDowels[i], nPrevLayerId, frOrig, frDestDowel, frDestDowel:getVersZ(), nTestSurf, sPrevLenKey, WIN_PRC_DWL_SIDETYPE.RIGHT, nPrevSolidId) + 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.BOTTOM_RAIL then + sLenKey = WIN_DWL_BOTTOMRAIL_PARA_LEN + sPrevLenKey = WIN_DWL_BOTTOMRAIL_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( nPrevOutlineId, nOutlineId, nPrevProfileId) -- controprofilo del pezzo full + nTestSurf = CreateProfileSurf( nPrevOutlineId, 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( nOutlineId, 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( nOutlineId, 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 = 1, 3 do + -- recupero i dowels sulla fila k-esima + local vDowels = EgtGetNameInGroup( nProfileId, WIN_DOWEL .. 'Row' .. tostring(k)) + if not vDowels then + break + end + -- 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 dMove = CalcDowelFrameCorrection( nOutlineId, nPrevOutlineId, nDowelRef, frOrig, frDest, nTestSurf, nTestSurfInverted, nTestSurf2, vtMove, nLayerId, sLenKey, sPrevLenKey) + local frDestDowel = Frame3d( frDest) + frDestDowel:move( dMove * vtMove) + for i = 1, #vDowels do + -- dowels per pezzo corrente ( short) + CreateDowel( vDowels[i], nLayerId, frOrig, frDestDowel, - frDestDowel:getVersZ(), nTestSurf, sLenKey, WIN_PRC_DWL_SIDETYPE.LEFT, nSolidId) + -- dowels per prezzo precedente ( full) + CreateDowel( vDowels[i], nPrevLayerId, frOrig, frDestDowel, frDestDowel:getVersZ(), nTestSurfInverted, sPrevLenKey, WIN_PRC_DWL_SIDETYPE.IN, nPrevSolidId) + end + end + + EgtErase( nTestSurf) + EgtErase( nTestSurfInverted) + EgtErase( nTestSurf2) + end + +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_DWL_SIDETYPE.RIGHT + if bStartOrEnd then + sSplitDowelSide = WIN_PRC_DWL_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) + + local ptRef = EgtIf( bStartOrEnd, EgtSP( nSplitId), EgtEP( nSplitId)) + + for i = 1, #vOutlines do + + -- recupero il pezzo associato e il suo outline di riferimento + local nPartId = FindAssociatedPart( vOutlines[i]) + 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_DWL_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_DWL_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 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 sCtr + local bChangeProfile = EgtGetInfo( nSplitId, WIN_PRF_CHANGE, 'b') or false + if bChangeProfile then + sCtr = WIN_OFST .. WIN_SASH .. WIN_CTRIN + else + sCtr = WIN_OFST .. GetProfileCtrIn( nOutlineId, nSplitId, nProfileId) + end + nTestSurf = CreateProfileSurf( nOutlineId, nProfileId, sCtr, 100, nLayerId) + 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) + + -- aggiungo i dowels + local vDowels = EgtGetNameInGroup( nSplitProfile, WIN_DOWEL .. '*') or {} + for i = 1, #vDowels do + -- split + local nDowel1 = CreateDowel( vDowels[i], nSplitLayerId, frOrig, frDest, vtSplitDir, nTestSurf, sSplitLenKey, 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 nDowel2 = CreateDowel( vDowels[i], nLayerId, frOrig, frDest, vtDir, nTestSurfInverted, sLenKey, 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 bBottomRail = EgtGetInfo( nOutlineLayerId, WIN_BOTTOMRAIL, 'b') or false + -- 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, false) + -- bottomrail + if bBottomRail and ( EgtGetName( nOutline) == WIN_BOTTOM or EgtGetName( nPrevOutline) == WIN_BOTTOM) then + CalcDowels( nOutline, nPrevOutline, false, true) + 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 dMainStripMinDelta = EgtIf( bMainInvertOffset, - b3MainStrip:getMax():getX(), b3MainStrip:getMin():getX()) + local dMainStripMaxDelta = EgtIf( bMainInvertOffset, - b3MainStrip:getMin():getX(), b3MainStrip:getMax():getX()) + + 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) + -- 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]) + local nNextPartId = FindAssociatedPart( vNextOutlineId[1]) + + -- 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) + + -- estrudo Strip start + local b3RefStartProfile = GetProfileLocalBox( nStartProfileId) + local nStartStripProfileId = EgtLine( nStartProfileId, ptStripMinStart, ptStripMinStart - Z_AX() * b3RefStartProfile:getDimY(), GDB_RT.GLOB) + EgtInvertCurve( nStartStripProfileId) + local nStartStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nStartStripProfileId, nStartStripGuideId, false, WIN_SURF_APPROX) + + -- 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) + EgtInvertCurve( nEndStripGuideId) + + -- estrudo Strip end + local b3RefEndProfile = GetProfileLocalBox( nEndProfileId) + local nEndStripProfileId = EgtLine( nEndProfileId, ptStripMinEnd, ptStripMinEnd - Z_AX() * b3RefEndProfile:getDimY(), GDB_RT.GLOB) + EgtInvertCurve( nEndStripProfileId) + local nEndStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nEndStripProfileId, nEndStripGuideId, false, WIN_SURF_APPROX) + + -- intersezione con main + EgtSurfTmIntersect( nMainStripExtrusionId, nEndStripExtrusionId) + + -- cancello curve e superfici di costruzione + EgtErase( nSectionId) + EgtErase( { nMainStripMinOffsetId, nMainStripMaxOffsetId}) + EgtErase( { nStartStripMinOffsetId, nStartStripMaxOffsetId, nStartStripGuideId, nStartStripProfileId, nStartStripExtrusionId}) + EgtErase( { nEndStripMinOffsetId, nEndStripMaxOffsetId, nEndStripGuideId, nEndStripProfileId, nEndStripExtrusionId}) + +end + + + +---------------------------------------------------------------------------------- +----------------------------- CALCOLO PEZZI ------------------------------------ +---------------------------------------------------------------------------------- -- funzione che calcola l'ingombro dei pezzi del telaio e i loro solidi local function CreatePartFromOutline( nAreaLayerId, nOutlineId, nOutlineCrvNbr, bBottomRail) @@ -2021,13 +2792,18 @@ local function CreatePartFromOutline( nAreaLayerId, nOutlineId, nOutlineCrvNbr, -- ricavo il tipo di profilo local nProfileType = GetOutlineProfileType( nOutlineId, bBottomRail) -- disegno ingombro - local nGeoId = CalcFrameGeo( nPartId, nOutlineId, nOutlineCrvNbr, nOutlineLayerId, nProfileType) - -- disegno solido - if bCalcSolid then - CalcFrameSolid( nPartId, nOutlineId, nGeoId, nProfileType) + CalcFrameGeo( nPartId, nOutlineId, nOutlineCrvNbr, nOutlineLayerId, nProfileType) + -- 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) + -- disegno solido + if s_bCalcSolid then + CalcSolid( nPartId, nOutlineId) end - -- calcolo i fori per le spine - CalcFrameDowels( nPartId, nOutlineId, nOutlineLayerId, nProfileType) -- b) Fill elseif nAreaType == WIN_AREATYPES.FILL then @@ -2046,161 +2822,13 @@ local function CreatePartFromOutline( nAreaLayerId, nOutlineId, nOutlineCrvNbr, -- disegno ingombro local nGeoLayerId = CalcFillGeo( nPartId, nOutlineLayerId) -- disegno solido - if bCalcSolid then + if s_bCalcSolid then CalcFillSolid( nPartId, nOutlineLayerId, nGeoLayerId) end end return nPartId end - ---------------------------------------------------------------------- ----------------------------- STRIP ---------------------------------- ---------------------------------------------------------------------- --- funzione che restitutisce lo Strip piu' vicino --- ( analoga a GetProfileCtrIn) -local function GetStripNearestToOutline( nPrevProfileId, nPrevOutlineId, nOutlineId) - local nStripId = EgtGetFirstNameInGroup( nPrevProfileId, WIN_STRIP) - -- gestione particolare del caso di profilo di split - if not nStripId 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 _, _, dSide = EgtPointCurveDistSide( EgtMP( nOutlineId), nPrevSouId, Z_AX()) - if dSide == 1 then - nStripId = EgtGetFirstNameInGroup( nPrevProfileId, WIN_STRIP .. '1') -- dx - else - nStripId = EgtGetFirstNameInGroup( nPrevProfileId, WIN_STRIP .. '2') -- sx - end - end - - 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 dMainStripMinDelta = EgtIf( bMainInvertOffset, - b3MainStrip:getMax():getX(), b3MainStrip:getMin():getX()) - local dMainStripMaxDelta = EgtIf( bMainInvertOffset, - b3MainStrip:getMin():getX(), b3MainStrip:getMax():getX()) - - 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) - -- recupero layer per solido e per profili di estrusione - local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) - local nMainProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) - - -- 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) - local nPrevOutlineId = vPrevOutlineId[1] - local nNextOutlineId = vNextOutlineId[1] - - -- recupero i pezzi precedente e successivo, prendendo eventualmente quelli di bottomrail - local nPrevPartId = FindAssociatedPart( nPrevOutlineId) - local nNextPartId = FindAssociatedPart( nNextOutlineId) - - -- recupero profilo e controprofili - 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 - local nMainStripId = GetStripNearestToOutline( nMainProfileId, nOutlineId, nPrevOutlineId) - -- estrudo MainStrip - local nMainStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nMainStripId, 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, nPrevOutlineId, 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( nPrevOutlineId, 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) - - -- estrudo Strip start - local nStartProfileFrameId = EgtGetFirstNameInGroup( nStartProfileId, WIN_SECTIONFRAME) - local frStartProfile = EgtFR( nStartProfileFrameId, GDB_ID.ROOT) - local nRefStartProfileId = EgtGetFirstNameInGroup( nStartProfileId, WIN_REF) - local b3RefStartProfile = EgtGetBBoxRef( nRefStartProfileId, GDB_BB.STANDARD, frStartProfile) - local nStartStripProfileId = EgtLine( nStartProfileId, ptStripMinStart, ptStripMinStart - Z_AX() * b3RefStartProfile:getDimY(), GDB_RT.GLOB) - EgtInvertCurve( nStartStripProfileId) - local nStartStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nStartStripProfileId, nStartStripGuideId, false, WIN_SURF_APPROX) - - -- intersezione con main - EgtSurfTmIntersect( nMainStripExtrusionId, nStartStripExtrusionId) - - -- c) taglio con end - -- recupero strip piu' vicino ad outline - local nEndStripId = GetStripNearestToOutline( nEndProfileId, nNextOutlineId, nOutlineId) - - -- disegno guida end per lo strip trovando le intersezioni degli outline minimi e massimi tra MainStrip ed EndStrip - local nEndStripMinOffsetId, nEndStripMaxOffsetId = CreateStripGuideLines( nNextOutlineId, 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) - EgtInvertCurve( nEndStripGuideId) - - -- estrudo Strip end - local nEndProfileFrameId = EgtGetFirstNameInGroup( nEndProfileId, WIN_SECTIONFRAME) - local frEndProfile = EgtFR( nEndProfileFrameId, GDB_ID.ROOT) - local nRefEndProfileId = EgtGetFirstNameInGroup( nEndProfileId, WIN_REF) - local b3RefEndProfile = EgtGetBBoxRef(nRefEndProfileId, GDB_BB.STANDARD, frEndProfile) - local nEndStripProfileId = EgtLine( nEndProfileId, ptStripMinEnd, ptStripMinEnd - Z_AX() * b3RefEndProfile:getDimY(), GDB_RT.GLOB) - EgtInvertCurve( nEndStripProfileId) - local nEndStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nEndStripProfileId, nEndStripGuideId, false, WIN_SURF_APPROX) - - -- intersezione con main - EgtSurfTmIntersect( nMainStripExtrusionId, nEndStripExtrusionId) - - -- cancello curve e superfici di costruzione - EgtErase( { nMainStripMinOffsetId, nMainStripMaxOffsetId}) - EgtErase( { nStartStripMinOffsetId, nStartStripMaxOffsetId, nStartStripGuideId, nStartStripProfileId, nStartStripExtrusionId}) - EgtErase( { nEndStripMinOffsetId, nEndStripMaxOffsetId, nEndStripGuideId, nEndStripProfileId, nEndStripExtrusionId}) - -end - --------------------------------------------------------------------- -- funzione che cicla ricorsivamente su aree e sottoaree per calcolare i pezzi local function CalculateAreaParts( nAreaId) @@ -2242,22 +2870,14 @@ local function CalculateAreaParts( nAreaId) EgtSetName( nSelectionLayerId, WIN_SPLITSELECTION) EgtSetStatus( nSelectionLayerId, GDB_ST.OFF) local nSplitPartGeoId = EgtGetFirstNameInGroup( nSplitPartId, WIN_GEO) - -- costruisco curva semplificata a partire dai lati out e in per evitare problemi con autointersezioni del geo - local nGeoOut = EgtGetFirstNameInGroup( nSplitPartGeoId, WIN_GEO_OUT) - local nGeoIn = EgtGetFirstNameInGroup( nSplitPartGeoId, WIN_GEO_IN) - local nCompoId = EgtCurveCompo( nSelectionLayerId, nGeoOut, false) - EgtAddCurveCompoLine( nCompoId, EgtSP( nGeoIn)) - EgtAddCurveCompoCurve( nCompoId, nGeoIn, false) - EgtCloseCurveCompo( nCompoId) - local nSelectionArea = EgtSurfFlatRegion( nSelectionLayerId, nCompoId) + local nSelectionArea = CreateGeoArea( nSplitPartGeoId, nSelectionLayerId) EgtSetColor( nSelectionArea, 'YELLOW') EgtSetAlpha( nSelectionArea, 10) EgtMove( nSelectionArea, 10 * Z_AX()) - EgtErase( nCompoId) end end elseif nAreaType ~= WIN_AREATYPES.FILL then - if bCalcSolid then + if s_bCalcSolid then --- verifico se area successiva e' un fill local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAASTERISK) local nChildAreaType = EgtGetInfo( nChildAreaId or GDB_ID.NULL, WIN_AREATYPE, "i") @@ -2295,17 +2915,20 @@ local function CalculateAreaParts( nAreaId) end ---------------------------------------------------------------------- -------------------------- FUNZIONI ---------------------------------- ---------------------------------------------------------------------- + +---------------------------------------------------------------------------------- +------------------------------ FUNZIONI ---------------------------------------- +---------------------------------------------------------------------------------- -- funzione che crea tutti i pezzi della finestra partendo dal telaio function WinCalculate.CreatePartFromArea( nFrameId) - -- assengo il tipo di profilo alle curve del base outline + -- assegno il tipo di profilo alle curve del base outline CalculateAreaProfileType( nFrameId) -- calcolo outline a partire dal base outline CalculateAreaOutline( nFrameId) -- creo pezzi CalculateAreaParts( nFrameId) + -- calcolo le spine + CalculateAreaDowels( nFrameId) end --------------------------------------------------------------------- @@ -2387,6 +3010,12 @@ function WinCalculate.PrepareProject() local nProfileGrp = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) EgtErase( nProfileGrp) + -- cancello eventuali gruppi ausiliari per cambio profilo + local nMixedOutlines = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_OUTLINES) + EgtErase( nMixedOutlines or GDB_ID.NULL) + local nMixedIntersections = EgtGetFirstNameInGroup( nPartId, WIN_MIXED_INTERSECTIONS) + EgtErase( nMixedIntersections or GDB_ID.NULL) + -- accendo gruppo delle lavorazioni local nProcLay = EgtGetFirstNameInGroup( nPartId, WIN_PRC) EgtSetStatus( nProcLay, GDB_ST.ON) @@ -2417,9 +3046,10 @@ function WinCalculate.PrepareProject() end ---------------------------------------------------------------------- ------------------------- FERRAMENTA --------------------------------- ---------------------------------------------------------------------- + +---------------------------------------------------------------------------------- +---------------------------------- FERRAMENTA ---------------------------------- +---------------------------------------------------------------------------------- local function SearchSash( nAreaId, SashList) -- verifico il tipo local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') @@ -2558,7 +3188,7 @@ local function SearchSash( nAreaId, SashList) end -- funzione che aggiunge l'hardware -function WinCalculate.AddHardwareForSash( nFrameId) +function WinCalculate.AddHardwareForSash( nFrameId, bOnlyRequest) -- cerco ed indicizzo ante del serramento local SashList = {} SearchSash( nFrameId, SashList) @@ -2651,9 +3281,13 @@ function WinCalculate.AddHardwareForSash( nFrameId) -- Scrittura nuova linea fhInput:write( sText .. '\n') - -- Chiudo file CNC + -- Chiudo file fhInput:close() + if bOnlyRequest then + return sInputFile + end + -- attendo scrittura output local nWait = 0 while not EgtExistsFile( sOutputFile) and nWait < 20 do @@ -2733,7 +3367,7 @@ function WinCalculate.AddHardwareForSash( nFrameId) EgtAddCurveCompoArcTg( nSolidPocketOutlineId, ptCenter + dLength / 2 * X_AX(), false) -- per solido local nSolidPocketId - if bCalcSolid then + if s_bCalcSolid then -- costruisco asola come volume chiuso per eseguire operazioni booleane con il solido e la creo più grande per non avere geometrie a filo local dExtra = 1 EgtAddCurveCompoLineTg( nSolidPocketOutlineId, dExtra) @@ -2791,7 +3425,7 @@ function WinCalculate.AddHardwareForSash( nFrameId) EgtSetColor( nHoleId, EgtStdColor( 'GRAY')) EgtSetInfo( nHoleId, WIN_PRC_FEATURE_TYPE, WIN_PRC_TYPE.HOLE) -- per solido - if bCalcSolid then + if s_bCalcSolid then local nSolidHoleId = EgtSurfTmByRegionExtrusion( nProcLayerId, nHoleId, - ( dDepth + 1) * Z_AX()) EgtMove( nSolidHoleId, Z_AX()) EgtTransform( nSolidHoleId, frHdwFrame) diff --git a/Profiles/WinProject.lua b/Profiles/WinProject.lua index 6426d15..ae23a86 100644 --- a/Profiles/WinProject.lua +++ b/Profiles/WinProject.lua @@ -106,4 +106,9 @@ local function WinCalculate_AddHardware() end _G.WinCalculate_AddHardware = WinCalculate_AddHardware +local function WinCreate_GetHardwareOptionPath() + WDG.HWDOPTPATH = WinCalculate.AddHardwareForSash(WDG.AREAID, true) +end +_G.WinCreate_GetHardwareOptionPath = WinCreate_GetHardwareOptionPath + ---------------------------------------------------------------------