From 67589d44efedfdb6e81f1093d5ec325661a81e01 Mon Sep 17 00:00:00 2001 From: SaraP Date: Tue, 4 Nov 2025 11:41:44 +0100 Subject: [PATCH] DataWindow : - arco a 3 centri - migliorie e correzioni varie per gestire correttamente l'arco a 3 centri ( calcolo solidi, strip, outline del fill). --- Designing/Main.lua | 148 ++-- Designing/WinConst.lua | 4 +- Designing/WinLib/WinCalculate.lua | 1083 ++++++++++++++----------- Designing/WinLib/WinCreate.lua | 115 +-- Designing/WinLib/WinManageProject.lua | 2 +- Designing/WinProject.lua | 4 +- 6 files changed, 782 insertions(+), 574 deletions(-) diff --git a/Designing/Main.lua b/Designing/Main.lua index cedaa6e..40d21d6 100644 --- a/Designing/Main.lua +++ b/Designing/Main.lua @@ -59,16 +59,15 @@ WinCreate.ImportProfile( sProfilePath) -- creo telaio -local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, WindowWidth, WindowHeight) --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER_SIDE, vFrameJoints, WindowWidth, WindowHeight, WindowHeight + 800) --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER_SIDE, vFrameJoints, WindowWidth, WindowHeight + 500, WindowHeight) +local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, {WindowWidth, WindowHeight}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER_SIDE, vFrameJoints, {WindowWidth, WindowHeight, WindowHeight + 800}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER_SIDE, vFrameJoints, {WindowWidth, WindowHeight + 500, WindowHeight}) -- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.ROUND_ARC, vFrameJoints, WindowWidth, WindowHeight) --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.SEGMENTAL_ARC, { FrameJointType, FrameJointType, FrameJointType, FrameJointType}, 1500, 1800, 2200) --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER, { FrameJointType, FrameJointType, FrameJointType, FrameJointType, FrameJointType}, WindowWidth, WindowHeight, WindowHeight + 500) --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.POINTED_ARC, { FrameJointType, FrameJointType, FrameJointType, FrameJointType, FrameJointType}, 900, 1500, 2100) --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.POINTED_ARC, { FrameJointType, FrameJointType, FrameJointType, FrameJointType, FrameJointType}, 1500, 1500, 2400) - - +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.SEGMENTAL_ARC, { FrameJointType, FrameJointType, FrameJointType, FrameJointType}, {1500, 1800, 2200}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER, { FrameJointType, FrameJointType, FrameJointType, FrameJointType, FrameJointType}, {WindowWidth, WindowHeight, WindowHeight + 500}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.POINTED_ARC, { FrameJointType, FrameJointType, FrameJointType, FrameJointType, FrameJointType}, {1500, 1500, 2400}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.TRG, { FrameJointType, FrameJointType, FrameJointType}, {1500, 1500, 500}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.THREE_CENTERED_ARC, { FrameJointType, FrameJointType, WIN_JNT.ANGLED, WIN_JNT.ANGLED, WIN_JNT.ANGLED, WIN_JNT.ANGLED}, {1500, 1500, 1800, 200}) ------------------------ Aggiunta split a griglia ------------------------ @@ -187,48 +186,54 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- { WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.FIXED}) -- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000592', 'Sx') +-- local nSashGrpId = EgtGetParent( vSash[1]) +-- WinCreate.AddHardware( nSashGrpId, '000592', 'Sx') -- anta mobile a dx -- local vSash = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, {0.5}, vSashJoints, { WIN_SASHTYPES.SLIDE_FIXED, WIN_SASHTYPES.SLIDE_MOVABLE}, -- { WIN_OPENING_TYPES.FIXED, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT}) -- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000592', 'Dx') +-- local nSashGrpId = EgtGetParent( vSash[1]) +-- WinCreate.AddHardware( nSashGrpId, '000592', 'Dx') -- 2 ante mobili, sx davanti -- local vSash = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, {0.5}, vSashJoints, { WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE_BACK}, -- { WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT}) -- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000593', 'Sx') +-- local nSashGrpId = EgtGetParent( vSash[1]) +-- WinCreate.AddHardware( nSashGrpId, '000593', 'Sx') -- 2 ante mobili, dx davanti -- local vSash = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, {0.5}, vSashJoints, { WIN_SASHTYPES.SLIDE_MOVABLE_BACK, WIN_SASHTYPES.SLIDE_MOVABLE}, -- { WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT}) -- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000593', 'Dx') +-- local nSashGrpId = EgtGetParent( vSash[1]) +-- WinCreate.AddHardware( nSashGrpId, '000593', 'Dx') -- 4 ante, le centrali sono mobili --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, 4500, 2100) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, {4500, 2100}) -- local vSash = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, {0.25, 0.25, 0.25}, vSashJoints, { WIN_SASHTYPES.SLIDE_FIXED, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_FIXED}, -- { WIN_OPENING_TYPES.FIXED, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT, WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.FIXED}) -- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[3], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[4], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000594', 'Dx') +-- local nSashGrpId = EgtGetParent( vSash[1]) +-- WinCreate.AddHardware( nSashGrpId, '000594', 'Dx') -- 4 ante mobili --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, 4500, 2100) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, {4500, 2100}) -- local vSash = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, {0.25, 0.25, 0.25}, vSashJoints, { WIN_SASHTYPES.SLIDE_MOVABLE_BACK, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE_BACK}, -- { WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT, WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT}) -- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[3], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSash[4], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000595', 'Dx') +-- local nSashGrpId = EgtGetParent( vSash[1]) +-- WinCreate.AddHardware( nSashGrpId, '000595', 'Dx') @@ -319,7 +324,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- local nSash3Id = WinCreate.AddSash( vAreas[3], vSashJoints) -- WinCreate.AddFill( nSash3Id, WIN_FILLTYPES.GLASS) --- tre ante orizzontale e verticale +-- tre ante una sopra e due sotto -- local vAreas1 = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, WIN_MEASURE.PERCENTAGE, { 0.5}) -- local vAreas2 = WinCreate.AddSplits( vAreas1[2], WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.PERCENTAGE, { 0.5}) -- local nSash1Id = WinCreate.AddSash( vAreas1[1], vSashJoints, WIN_OPENING_TYPES.FIXED) @@ -329,7 +334,6 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- local nSash3Id = WinCreate.AddSash( vAreas2[2], vSashJoints, WIN_OPENING_TYPES.TILTTURN_RIGHT) -- WinCreate.AddFill( nSash3Id, WIN_FILLTYPES.GLASS) - -- sei ante (1) -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, WIN_MEASURE.PERCENTAGE, { 0.5}) -- local vAreas1 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.PERCENTAGE, { 0.33, 0.33}) @@ -347,7 +351,6 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- local nSash6Id = WinCreate.AddSash( vAreas2[3], vSashJoints) -- WinCreate.AddFill( nSash6Id, WIN_FILLTYPES.GLASS) - -- sei ante (2) -- local vAreas = WinCreate.AddGridSplits( nFrameId, WIN_MEASURE.PERCENTAGE, {0.33, 0.33}, {0.5}, false) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints) @@ -400,7 +403,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind ------------------------ Finestre con ante singole e ante battenti/riceventi ------------------------ -- tre ante : singola / ricevente / battente --- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.ABSOLUT, { WindowWidth / 3}) +-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.PERCENTAGE, { 0.33}) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, WIN_OPENING_TYPES.TILTTURN_LEFT) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- local vSashes = WinCreate.AddSashGroup( vAreas[2], WIN_MEASURE.PERCENTAGE, {0.5}, vSashJoints, { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE}, @@ -424,6 +427,15 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- WinCreate.AddFill( vAreasSash3[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreasSash3[2], WIN_FILLTYPES.GLASS) +-- 3 ante : sopra battente / ricevente, sotto singola +-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, WIN_MEASURE.PERCENTAGE, { 0.7}) +-- local nSash0Id = WinCreate.AddSash( vAreas[2], vSashJoints, WIN_OPENING_TYPES.FIXED) +-- WinCreate.AddFill( nSash0Id, WIN_FILLTYPES.GLASS) +-- local vSashes = WinCreate.AddSashGroup( vAreas[1], WIN_MEASURE.PERCENTAGE, { 0.5}, vSashJoints, {WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE}, +-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT}) +-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) +-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) + -- 4 ante : sopra anta singola e sotto singola ( con split) / battente / ricevente -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, WIN_MEASURE.PERCENTAGE, { 0.3}) -- local vAreas1 = WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.PERCENTAGE, { 0.3}) @@ -439,7 +451,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- sei ante : divisione orizzontale e per ogni divisione anta singola / battente/ ricevente --- local vAreas = WinCreate.AddGridSplits( nFrameId, WIN_MEASURE.ABSOLUT, {WindowWidth / 3}, {WindowHeight / 2}, false) +-- local vAreas = WinCreate.AddGridSplits( nFrameId, WIN_MEASURE.PERCENTAGE, {0.33}, {0.5}, false) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, WIN_OPENING_TYPES.TILTTURN_LEFT) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- local nSash2Id = WinCreate.AddSash( vAreas[3], vSashJoints, WIN_OPENING_TYPES.TILTTURN_LEFT) @@ -457,11 +469,11 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind ------------------------ Ferramenta ------------------------ --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, 1500, 2100) --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.ROUND_ARC, vFrameJoints, 1500, 2100) --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.SEGMENTAL_ARC, { FrameJointType, FrameJointType, FrameJointType, FrameJointType}, 1500, 1500, 1700) --- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER_SIDE, vFrameJoints, 1500, 1800 + 1200, 1800) - +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, {1500, 2100}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.ROUND_ARC, vFrameJoints, {1500, 2100}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.SEGMENTAL_ARC, { FrameJointType, FrameJointType, FrameJointType, FrameJointType}, {1500, 1500, 1700}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER_SIDE, vFrameJoints, {1500, 1800 + 1200, 1800}) +-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER, vFrameJoints, {1500, 1500, 1800}) -- anta singola -- local nSashId = WinCreate.AddSash( nFrameId, vSashJoints, WIN_OPENING_TYPES.TILTTURN_LEFT) @@ -473,19 +485,19 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- -- WinCreate.AddHardware( nSashId, '000604', 'Sx') -- trapezio -- 2 ante singole - local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.PERCENTAGE, { 0.5}) - local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, WIN_OPENING_TYPES.TILTTURN_LEFT) - local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, WIN_OPENING_TYPES.TILTTURN_RIGHT) - WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) - WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS) - WinCreate.AddHardware( nSash1Id, '000558', 'Sx') - WinCreate.AddHardware( nSash2Id, '000558', 'Dx') --- -- WinCreate.AddHardware( nSash1Id, '000610', 'Sx') -- arco a tutto sesto --- -- WinCreate.AddHardware( nSash2Id, '000610', 'Dx') --- -- WinCreate.AddHardware( nSash1Id, '000611', 'Sx') -- arco ribassato --- -- WinCreate.AddHardware( nSash2Id, '000611', 'Dx') --- -- WinCreate.AddHardware( nSash1Id, '000604', 'Sx') -- trapezio --- -- WinCreate.AddHardware( nSash2Id, '000604', 'Dx') +-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.PERCENTAGE, { 0.5}) +-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, WIN_OPENING_TYPES.TILTTURN_LEFT) +-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, WIN_OPENING_TYPES.TILTTURN_RIGHT) +-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) +-- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS) +-- WinCreate.AddHardware( nSash1Id, '000558', 'Sx') +-- WinCreate.AddHardware( nSash2Id, '000558', 'Dx') +-- WinCreate.AddHardware( nSash1Id, '000610', 'Sx') -- arco a tutto sesto +-- WinCreate.AddHardware( nSash2Id, '000610', 'Dx') +-- WinCreate.AddHardware( nSash1Id, '000611', 'Sx') -- arco ribassato +-- WinCreate.AddHardware( nSash2Id, '000611', 'Dx') +-- WinCreate.AddHardware( nSash1Id, '000604', 'Sx') -- trapezio +-- WinCreate.AddHardware( nSash2Id, '000604', 'Dx') -- 2 ante singole con apertura sul montante -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.PERCENTAGE, { 0.5}) @@ -496,32 +508,35 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- WinCreate.AddHardware( nSash1Id, '000558', 'Sx') -- WinCreate.AddHardware( nSash2Id, '000558', 'Sx') --- 3 ante : singola / battente / ricevente --- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.PERCENTAGE, { 0.5}) --- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, WIN_OPENING_TYPES.TILTTURN_LEFT) +-- 3 ante : sotto singola, sopra battente / ricevente +-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, WIN_MEASURE.PERCENTAGE, { 0.6}) +-- local nSash1Id = WinCreate.AddSash( vAreas[2], vSashJoints, WIN_OPENING_TYPES.TILTTURN_LEFT) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddHardware( nSash1Id, '000558', 'Sx') --- local vSashes = WinCreate.AddSashGroup( vAreas[2], WIN_MEASURE.PERCENTAGE, { 0.5}, vSashJoints, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE}, +-- local vSashes = WinCreate.AddSashGroup( vAreas[1], WIN_MEASURE.PERCENTAGE, { 0.5}, vSashJoints, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE}, -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT}) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( vAreas[2], '000559', 'Sx') +-- local nSashGrpId = EgtGetParent( vSashes[1]) +-- WinCreate.AddHardware( nSashGrpId, '000559', 'Sx') -- 2 ante : battente / ricevente -- local vSashes = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, { 0.5}, vSashJoints, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE}, -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT}) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000559', 'Sx') --- -- WinCreate.AddHardware( nFrameId, '000598', 'Sx') -- arco tutto sesto --- -- WinCreate.AddHardware( nFrameId, '000599', 'Sx') -- arco ribassato +-- local nSashGrpId = EgtGetParent( vSashes[1]) +-- WinCreate.AddHardware( nSashGrpId, '000559', 'Sx') +-- -- WinCreate.AddHardware( nSashGrpId, '000598', 'Sx') -- arco tutto sesto +-- -- WinCreate.AddHardware( nSashGrpId, '000599', 'Sx') -- arco ribassato -- 2 ante : ricevente / battente -- local vSashes = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, { 0.5}, vSashJoints, { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE}, -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT}) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000559', 'Dx') +-- local nSashGrpId = EgtGetParent( vSashes[1]) +-- WinCreate.AddHardware( nSashGrpId, '000559', 'Dx') -- 3 ante : battente / battente / ricevente -- local vSashes = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, { 0.33, 0.33}, vSashJoints, { WIN_SASHTYPES.ACTIVE_OUT, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.INACTIVE}, @@ -529,7 +544,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000564', 'Sx') +-- local nSashGrpId = EgtGetParent( vSashes[1]) +-- WinCreate.AddHardware( nSashGrpId, '000564', 'Sx') -- 3 ante : ricevente / battente / battente -- local vSashes = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, { 0.33, 0.33}, vSashJoints, { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.ACTIVE_OUT}, @@ -537,7 +553,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000564', 'Dx') +-- local nSashGrpId = EgtGetParent( vSashes[1]) +-- WinCreate.AddHardware( nSashGrpId, '000564', 'Dx') -- 3 ante : battente / ricevente / ricevente -- local vSashes = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, { 0.33, 0.33}, vSashJoints, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.INACTIVE_OUT}, @@ -545,7 +562,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000565', 'Sx') +-- local nSashGrpId = EgtGetParent( vSashes[1]) +-- WinCreate.AddHardware( nSashGrpId, '000565', 'Sx') -- 3 ante : ricevente / ricevente / battente -- local vSashes = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, { 0.33, 0.33}, vSashJoints, { WIN_SASHTYPES.INACTIVE_OUT, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.ACTIVE}, @@ -553,7 +571,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000565', 'Dx') +-- local nSashGrpId = EgtGetParent( vSashes[1]) +-- WinCreate.AddHardware( nSashGrpId, '000565', 'Dx') -- 4 ante : battente / battente / ricevente / ricevente -- local vSashes = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, { 0.25, 0.25, 0.25}, vSashJoints, { WIN_SASHTYPES.ACTIVE_OUT, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.INACTIVE_OUT}, @@ -562,7 +581,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[4], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000575', 'Sx') +-- local nSashGrpId = EgtGetParent( vSashes[1]) +-- WinCreate.AddHardware( nSashGrpId, '000575', 'Sx') -- 4 ante : ricevente / ricevente / battente / battente -- local vSashes = WinCreate.AddSashGroup( nFrameId, WIN_MEASURE.PERCENTAGE, { 0.25, 0.25, 0.25}, vSashJoints, { WIN_SASHTYPES.INACTIVE_OUT, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.ACTIVE_OUT}, @@ -571,7 +591,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[4], WIN_FILLTYPES.GLASS) --- WinCreate.AddHardware( nFrameId, '000575', 'Dx') +-- local nSashGrpId = EgtGetParent( vSashes[1]) +-- WinCreate.AddHardware( nSashGrpId, '000575', 'Dx') -- vasistas -- local nSashId = WinCreate.AddSash( nFrameId, vSashJoints, WIN_OPENING_TYPES.TILTONLY_TOP) @@ -580,22 +601,21 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, vFrameJoints, Wind ----------------------------------------------------------------------------------- - -- imposto se calcolare solidi/preview o meno ---WinCalculate.SetCalcSolid( true) ---WinCalculate.SetCalcPreview( true) +WinCalculate.SetCalcSolid( true) +WinCalculate.SetCalcPreview( true) -- creo i pezzi WinCalculate.CreatePartFromArea( nFrameId) -WinCalculate.AddHardware( nFrameId, true, true, true, true) ---WinCalculate.AddAccessories( nFrameId, true) +-- WinCalculate.AddHardware( nFrameId, true, false, false, false) +-- WinCalculate.AddAccessories( nFrameId, true) -- tronchetti -- local nLogsNbr = 7 -- local vSections = { 100, 150, 80, 130, 120, 180} --- -- local nLogsNbr = 0 -- numero minimo --- -- local vSections = { 120} +-- local nLogsNbr = 0 -- numero minimo +-- local vSections = { 120} -- local bAlign = false -- local dOverMatOut = 10 -- local dOverMatIn = 7 @@ -617,8 +637,8 @@ WinCalculate.AddHardware( nFrameId, true, true, true, true) -- WinCalculate.CreateArcLogs( vParts[i], nLogsNbr, vSections, bAlign, dOverMatOut, dOverMatIn, dOverMatExt, dOverMatInt, bCutExtremities) -- end -- end - - + + EgtZoom( SCE_ZM.ALL) diff --git a/Designing/WinConst.lua b/Designing/WinConst.lua index 0ccaf24..99b6ec9 100644 --- a/Designing/WinConst.lua +++ b/Designing/WinConst.lua @@ -27,6 +27,7 @@ WIN_FRAME_TYPES = { SEGMENTAL_ARC = 5, POINTED_ARC = 6, TRG = 7, + THREE_CENTERED_ARC = 8, } -- forme per anta @@ -192,6 +193,7 @@ WIN_THRESHOLD_PROFILE = 'ThresholdProfile' WIN_SLIDE_WINDOW = 'SlideWindow' WIN_SASH_NBR = 'SashNbr' WIN_AREA_NBR = 'AreaNbr' +WIN_REF_SURF = 'SurfRef' -- PROFILI @@ -387,8 +389,6 @@ WIN_SOLID = 'Solid' WIN_MAINGUIDE = 'MainGuide' WIN_SRF_MAIN = 'MainSurface' WIN_SRF_ORIGMAIN = 'OrigMainSurface' -WIN_SRF_START = 'StartSurface' -WIN_SRF_END = 'EndSurface' WIN_SRF_STRIP = 'StripSurface' diff --git a/Designing/WinLib/WinCalculate.lua b/Designing/WinLib/WinCalculate.lua index e43dc27..9e7b48f 100644 --- a/Designing/WinLib/WinCalculate.lua +++ b/Designing/WinLib/WinCalculate.lua @@ -93,7 +93,7 @@ local function FindIntersectionPoint( nCrv1, nCrv2, ptRef) -- caso arco-arco : cerco intersezione tra le due circonferenze nCrvA = EgtCircle( nGrp, EgtCP( nCrv1), EgtArcRadius( nCrv1)) nCrvB = EgtCircle( nGrp, EgtCP( nCrv2), EgtArcRadius( nCrv2)) - + else -- caso arco-linea : cerco intersezione fra la linea e la circonferenza local nArc = EgtIf( EgtGetType( nCrv1) == GDB_TY.CRV_ARC, nCrv1, nCrv2) @@ -114,17 +114,18 @@ end --------------------------------------------------------------------- -- funzione che data una lista di curve ordinate e orientate che creano una curva chiusa, ne individua la regione definita local function CalcIntersectionRegion( vCrvs, nGrp) - + local nSurfId -- gruppo temporaneo per i conti local nGrpTmp = EgtGroup( nGrp) EgtSetStatus( nGrpTmp, GDB_ST.OFF) - -- costruisco la regione definita da tutti i semipiani delle linee che compongono il contorno - local bArcs = false + -- costruisco le regioni definite dai semipiani delle linee che compongono il contorno e + -- costruisco le circonferenze associate agli archi verificando non ve ne siano di coincidenti local dExtraLen = 10000 local vSemiPlaneSurfs = {} + local tArcs = {} for i = 1, #vCrvs do if EgtGetType( vCrvs[i]) == GDB_TY.CRV_LINE then local vtDir = EgtSV( vCrvs[i]) @@ -134,101 +135,125 @@ local function CalcIntersectionRegion( vCrvs, nGrp) local frRect = Frame3d( EgtSP( vCrvs[i]) - vtDir * dExtraLen, vtDir, vtOrtho, Z_AX()) EgtTransform( nSemiPlaneId, frRect) table.insert( vSemiPlaneSurfs, nSemiPlaneId) + else - bArcs = true + -- creo circonferenza corrispondente + local nCircleId = EgtCopyGlob( vCrvs[i], nGrpTmp) + local dAngOld = EgtArcAngCenter( vCrvs[i]) + EgtModifyArcAngCenter( nCircleId, EgtIf( dAngOld > 0, 360, -360)) + -- verifico se coincide con altra circonferenza già costruita + local dRad = EgtArcRadius( nCircleId) + local ptC = EgtCP( nCircleId) + local bOverlap = false + for j = 1, #tArcs do + if AreSamePointApprox( tArcs[j].ptC, ptC) and abs( tArcs[j].dRad - dRad) < GEO.EPS_SMALL then + bOverlap = true + table.insert( tArcs[j].nArcId, vCrvs[i]) + break + end + end + if not bOverlap then + table.insert( tArcs, { nCircleId = nCircleId, nArcId = {vCrvs[i]}, dRad = dRad, ptC = ptC}) + end end end + + -- calcolo la regione definita dai semipiani for i = 2, #vSemiPlaneSurfs do EgtSurfFrIntersect( vSemiPlaneSurfs[1], vSemiPlaneSurfs[i]) EgtErase( vSemiPlaneSurfs[i]) end nSurfId = vSemiPlaneSurfs[1] - -- se presenti archi, calcolo le regioni associate limitandole con i semipiani - if bArcs then - local vArcSurfs = {} + -- se presenti archi, calcolo il loro contributo alla regione + if #tArcs > 0 then + local nCrvBorder = EgtExtractSurfFrChunkLoops( nSurfId, 0, nGrpTmp) - - for i = 1, #vCrvs do - if EgtGetType( vCrvs[i]) == GDB_TY.CRV_ARC then + + -- riordino circonferenze per raggio decrescente ( per gestire prima quelle più grandi che potrebbero contenere le altre) + table.sort( tArcs, function ( a, b) return a.dRad > b.dRad end) + + for i = 1, #tArcs do + local nCircleId = tArcs[i].nCircleId + -- limito la circonferenza alla regione + local nSurfTrim = EgtSurfFlatRegion( nGrpTmp, nCrvBorder) + local nCrv, nCnt = EgtTrimCurveWithRegion( nCircleId, nSurfTrim, true, false) + + if not nCrv then + -- è errore, lo ignoro + nCnt = 0 + end + + if nCnt > 0 then + -- unisco tratto iniziale e finale se consecutivi + if nCnt > 1 and AreSamePointApprox( EgtSP( nCrv), EgtEP( nCrv + nCnt - 1)) then + EgtModifyCurveStartPoint( nCrv, EgtSP( nCrv + nCnt - 1)) + EgtErase( nCrv + nCnt - 1) + nCnt = nCnt - 1 + end - -- creo circonferenza corrispondente - local nCircleId = EgtCopyGlob( vCrvs[i], nGrpTmp) - local dAngOld = EgtArcAngCenter( vCrvs[i]) - EgtModifyArcAngCenter( nCircleId, EgtIf( dAngOld > 0, 360, -360)) - - -- limito la circonferenza alla regione definita dei semipiani - local nCrv, nCnt = EgtTrimCurveWithRegion( nCircleId, nSurfId, true, false) - - if nCnt > 0 then - -- unisco tratto iniziale e finale se consecutivi - if nCnt > 1 and AreSamePointApprox( EgtSP( nCrv), EgtEP( nCrv + nCnt - 1)) then - EgtModifyCurveStartPoint( nCrv, EgtSP( nCrv + nCnt - 1)) - EgtErase( nCrv + nCnt - 1) - nCnt = nCnt - 1 - end - - -- spezzo in corrispondenza di eventuali punti tangenti alla regione dei semipiani - local vArcs = EgtTableFill( nCrv, nCnt) - for j = nCrv, nCrv + nCnt - 1 do - local nInters, nPntCnt, nCrvCnt = EgtCurveCurveInters( j, nCrvBorder, nGrpTmp) - local nCurrCrv = j - for nPntId = nInters, nInters + nPntCnt - 1 do - local dPar = EgtCurveParamAtPoint( nCurrCrv, EgtSP( nPntId)) - local nNewCrv = EgtSplitCurveAtParam( nCurrCrv, dPar) - if nNewCrv then - table.insert( vArcs, nNewCrv) - nCurrCrv = nNewCrv - end + -- spezzo in corrispondenza di eventuali punti tangenti alla regione + local vArcs = EgtTableFill( nCrv, nCnt) + for j = nCrv, nCrv + nCnt - 1 do + local nInters, nPntCnt, nCrvCnt = EgtCurveCurveInters( j, nCrvBorder, nGrpTmp) + local nCurrCrv = j + for nPntId = nInters, nInters + nPntCnt - 1 do + local dPar = EgtCurveParamAtPoint( nCurrCrv, EgtSP( nPntId)) + local nNewCrv = EgtSplitCurveAtParam( nCurrCrv, dPar) + if nNewCrv then + table.insert( vArcs, nNewCrv) + nCurrCrv = nNewCrv end end - - -- considero solo i tratti che poggiano sulla curva orginale - for j = 1, #vArcs do - local dParS = EgtCurveParamAtPoint( vCrvs[i], EgtSP( vArcs[j])) - local dParE = EgtCurveParamAtPoint( vCrvs[i], EgtEP( vArcs[j])) - - local bOk = false + end + + -- considero solo i tratti che poggiano sulle curve orginali + for j = 1, #vArcs do + + local bOk = false + for k = 1, #tArcs[i].nArcId do + local nOrigArc = tArcs[i].nArcId[k] + local dParS = EgtCurveParamAtPoint( nOrigArc, EgtSP( vArcs[j])) + local dParE = EgtCurveParamAtPoint( nOrigArc, EgtEP( vArcs[j])) if not dParS and not dParE then -- se il nuovo tratto non poggia sull'originale, verifico se è l'originale a poggiare sul nuovo - local dPar1 = EgtCurveParamAtPoint( vArcs[j], EgtSP( vCrvs[i])) - local dPar2 = EgtCurveParamAtPoint( vArcs[j], EgtEP( vCrvs[i])) + local dPar1 = EgtCurveParamAtPoint( vArcs[j], EgtSP( nOrigArc)) + local dPar2 = EgtCurveParamAtPoint( vArcs[j], EgtEP( nOrigArc)) if dPar1 or dPar2 then bOk = true + break end elseif dParS and abs( dParS - 1) > GEO.EPS_SMALL then bOk = true + break elseif dParE and dParE > GEO.EPS_SMALL then bOk = true + break end - - if not bOk then - EgtErase( vArcs[j]) - else - local dParS = EgtCurveParamAtPoint( nCrvBorder, EgtSP( vArcs[j]), 100 * GEO.EPS_SMALL) - local dParE = EgtCurveParamAtPoint( nCrvBorder, EgtEP( vArcs[j]), 100 * GEO.EPS_SMALL) - local nBorderCopy = EgtCopyGlob( nCrvBorder, nGrpTmp) - EgtTrimCurveStartEndAtParam( nBorderCopy, dParE, dParS) - local nCompo = EgtCurveCompo( nGrpTmp, { nBorderCopy, vArcs[j]}) - local nTrimSurf = EgtSurfFlatRegion( nGrpTmp, nCompo) - table.insert( vArcSurfs, nTrimSurf) - end + end + + if not bOk then + EgtErase( vArcs[j]) + else + -- modifico il bordo con il nuovo tratto + local dParS = EgtCurveParamAtPoint( nCrvBorder, EgtSP( vArcs[j]), 100 * GEO.EPS_SMALL) + local dParE = EgtCurveParamAtPoint( nCrvBorder, EgtEP( vArcs[j]), 100 * GEO.EPS_SMALL) + EgtTrimCurveStartEndAtParam( nCrvBorder, dParE, dParS) + EgtAddCurveCompoCurve( nCrvBorder, vArcs[j]) end end end end - - for i = 1, #vArcSurfs do - EgtSurfFrIntersect( nSurfId, vArcSurfs[i]) - EgtErase( vArcSurfs[i]) - end + + -- ricostruisco la superficie + nSurfId = EgtSurfFlatRegion( nGrpTmp, nCrvBorder) end - + EgtRelocateGlob( nSurfId, nGrp) EgtErase( nGrpTmp) return nSurfId end - + --------------------------------------------------------------------- -- Gestione delle curve superflue in TrimOrderedCurves : le modalità di trattamento sono indicate da nMode e sono le seguenti -- 0/nil = curva eliminata ( caso standard) @@ -247,14 +272,17 @@ local function AdjustExtraCurvesForTrim( nCrvId, nSurfId, nMode) EgtErase( nCrvId) elseif nMode == 2 then - -- se la curva è fuori dalla regione allora non va eliminata ma viene settata info che indica di ignorarla + -- se la curva è fuori dalla regione non va eliminata ma viene settata info che indica di ignorarla. Se è on o in allora il suo contributo è lo stesso di un'altra + -- curva di bordo quindi può essere eliminata local nTestCrv = EgtCopyGlob( nCrvId, EgtGetParent( nSurfId)) local nTmp, nCnt = EgtTrimCurveWithRegion( nTestCrv, nSurfId, true, true) if nCnt > 0 then - -- se la curva è on o in non ha senso considerarla, il suo contributo è lo stesso di un'altra curva di bordo - -- elimino il profilo corrispondente + -- elimino il profilo corrispondente solo se non è curva in o out ( per non eliminare il profilo principale) local nSemiProfileId = EgtGetInfo( nCrvId, WIN_SEMI_PROFILE, 'i') - EgtErase( EgtGetParent( nSemiProfileId)) + local nProfileId = EgtGetParent( nSemiProfileId) + if EgtGetName( nProfileId) ~= WIN_PRF_MAIN then + EgtErase( nProfileId) + end -- elimino la curva EgtErase( nCrvId) else @@ -268,95 +296,95 @@ end -- funzione che data una lista di curve ordinate e orientate le estende o le taglia per creare una curva chiusa local function TrimOrderedCurves( vCrvs, nExtraCurvesMode) - -- costruisco la regione definita dalle curve - local nGrpTmp = EgtGroup( GDB_ID.ROOT) - EgtSetStatus( nGrpTmp, GDB_ST.OFF) - local nSurfId = CalcIntersectionRegion( vCrvs, nGrpTmp) + -- costruisco la regione definita dalle curve + local nGrpTmp = EgtGroup( GDB_ID.ROOT) + EgtSetStatus( nGrpTmp, GDB_ST.OFF) + local nSurfId = CalcIntersectionRegion( vCrvs, nGrpTmp) - -- copia estesa delle curve - local dExtraLen = 10000 - local vCopies = {} - for i = 1, #vCrvs do - vCopies[i] = EgtCopyGlob( vCrvs[i], nGrpTmp) - if EgtGetType( vCrvs[i]) == GDB_TY.CRV_LINE then - -- se linea allungo le estremità - EgtExtendCurveStartByLen( vCopies[i], dExtraLen) - EgtExtendCurveEndByLen( vCopies[i], dExtraLen) - else - -- se arco lo trasformo in una circonferenza - local dAngOld = EgtArcAngCenter( vCrvs[i]) - EgtModifyArcAngCenter( vCopies[i], EgtIf( dAngOld > 0, 360, -360)) - end - end - - -- recupero le curve di bordo della regione - local nBorderId = EgtExtractSurfFrChunkLoops( nSurfId, 0, nGrpTmp) - local nCrvBorder, nCnt = EgtExplodeCurveCompo( nBorderId) + -- copia estesa delle curve + local dExtraLen = 10000 + local vCopies = {} + for i = 1, #vCrvs do + vCopies[i] = EgtCopyGlob( vCrvs[i], nGrpTmp) + if EgtGetType( vCrvs[i]) == GDB_TY.CRV_LINE then + -- se linea allungo le estremità + EgtExtendCurveStartByLen( vCopies[i], dExtraLen) + EgtExtendCurveEndByLen( vCopies[i], dExtraLen) + else + -- se arco lo trasformo in una circonferenza + local dAngOld = EgtArcAngCenter( vCrvs[i]) + EgtModifyArcAngCenter( vCopies[i], EgtIf( dAngOld > 0, 360, -360)) + end + end + + -- recupero le curve di bordo della regione + local nBorderId = EgtExtractSurfFrChunkLoops( nSurfId, 0, nGrpTmp) + local nCrvBorder, nCnt = EgtExplodeCurveCompo( nBorderId) - -- individuo una curva di vCrvs e un tratto di nCrvBorder in corrispondenza biunivoca per gestire correttamente il ciclo - -- ( possono esserci curve di vCrvs senza corrispondente o con più corrispondenti tra le curve di bordo) - local nFirstIdxCrv = 1 - local nFirstIdxBorder = 1 - for i = 1, #vCrvs do - local vCrvBorderRef = {} - for nId = nCrvBorder, nCrvBorder + nCnt - 1 do - local dDist = EgtPointCurveDist( EgtMP( nId), vCopies[i]) - if dDist < GEO.EPS_SMALL then - table.insert( vCrvBorderRef, nId) - end - end - if #vCrvBorderRef == 1 then - -- preparo indici in modo che siano 0-based - nFirstIdxCrv = i - 1 - nFirstIdxBorder = vCrvBorderRef[1] - nCrvBorder - break - end - end - - local vResultCurves = {} - local nC = nFirstIdxCrv - local nB = nFirstIdxBorder - repeat - -- se ho terminato le curve di bordo da associare devo cancellare tutte le curve rimaste - if nB == nFirstIdxBorder and nC ~= nFirstIdxCrv then - AdjustExtraCurvesForTrim( vCrvs[nC+1], nSurfId, nExtraCurvesMode) - - else - local dDist = EgtPointCurveDist( EgtMP( nCrvBorder + nB), vCopies[nC+1]) - -- se trovo corrispondenza - if dDist < GEO.EPS_SMALL then - -- assegno il nome - local sName = EgtGetName( vCrvs[nC+1]) - if sName then - EgtSetName( nCrvBorder + nB, sName) - end - -- copio le info - local vInfo = EgtGetAllInfo( vCrvs[nC+1]) - for j = 1, #vInfo do - local sInfo = EgtSplitString( vInfo[j], '=') - EgtSetInfo( nCrvBorder + nB, sInfo[1], sInfo[2]) - end - -- riposiziono - EgtRelocateGlob( nCrvBorder + nB, vCrvs[nC+1], GDB_IN.AFTER) - -- modifico l'id sostutuendolo alla curva originale - EgtErase( vCrvs[nC+1]) - EgtChangeId( nCrvBorder + nB, vCrvs[nC+1]) - - table.insert( vResultCurves, vCrvs[nC+1]) - -- passo alla curva di bordo successiva - nB = ( nB + 1) % nCnt - else - -- la curva non appartiene al bordo, quindi va gestita opportunamente - AdjustExtraCurvesForTrim( vCrvs[nC+1], nSurfId, nExtraCurvesMode) - end - end - - -- passo alla curva successiva - nC = ( nC + 1) % #vCrvs - until nC == nFirstIdxCrv + -- individuo una curva di vCrvs e un tratto di nCrvBorder in corrispondenza biunivoca per gestire correttamente il ciclo + -- ( possono esserci curve di vCrvs senza corrispondente o con più corrispondenti tra le curve di bordo) + local nFirstIdxCrv = 1 + local nFirstIdxBorder = 1 + for i = 1, #vCrvs do + local vCrvBorderRef = {} + for nId = nCrvBorder, nCrvBorder + nCnt - 1 do + local dDist = EgtPointCurveDist( EgtMP( nId), vCopies[i]) + if dDist < GEO.EPS_SMALL then + table.insert( vCrvBorderRef, nId) + end + end + if #vCrvBorderRef == 1 then + -- preparo indici in modo che siano 0-based + nFirstIdxCrv = i - 1 + nFirstIdxBorder = vCrvBorderRef[1] - nCrvBorder + break + end + end + + local vResultCurves = {} + local nC = nFirstIdxCrv + local nB = nFirstIdxBorder + repeat + -- se ho terminato le curve di bordo da associare devo cancellare tutte le curve rimaste + if nB == nFirstIdxBorder and nC ~= nFirstIdxCrv then + AdjustExtraCurvesForTrim( vCrvs[nC+1], nSurfId, nExtraCurvesMode) + + else + local dDist = EgtPointCurveDist( EgtMP( nCrvBorder + nB), vCopies[nC+1]) + -- se trovo corrispondenza + if dDist < GEO.EPS_SMALL then + -- assegno il nome + local sName = EgtGetName( vCrvs[nC+1]) + if sName then + EgtSetName( nCrvBorder + nB, sName) + end + -- copio le info + local vInfo = EgtGetAllInfo( vCrvs[nC+1]) + for j = 1, #vInfo do + local sInfo = EgtSplitString( vInfo[j], '=') + EgtSetInfo( nCrvBorder + nB, sInfo[1], sInfo[2]) + end + -- riposiziono + EgtRelocateGlob( nCrvBorder + nB, vCrvs[nC+1], GDB_IN.AFTER) + -- modifico l'id sostutuendolo alla curva originale + EgtErase( vCrvs[nC+1]) + EgtChangeId( nCrvBorder + nB, vCrvs[nC+1]) + + table.insert( vResultCurves, vCrvs[nC+1]) + -- passo alla curva di bordo successiva + nB = ( nB + 1) % nCnt + else + -- la curva non appartiene al bordo, quindi va gestita opportunamente + AdjustExtraCurvesForTrim( vCrvs[nC+1], nSurfId, nExtraCurvesMode) + end + end + + -- passo alla curva successiva + nC = ( nC + 1) % #vCrvs + until nC == nFirstIdxCrv - EgtErase( nGrpTmp) - return vResultCurves + EgtErase( nGrpTmp) + return vResultCurves end --------------------------------------------------------------------- @@ -407,10 +435,10 @@ local function FindAssociatedPart( nOutlineId, bUseBottomRail) local nPartId = EgtGetInfo( nCrvId, WIN_REF_PART, 'i') if not nPartId then -- cerco la prima curva da cui deriva che ha un pezzo associato + -- recupero il base outline da cui deriva local nBaseOutline = EgtGetInfo( nOutlineId, WIN_COPY, 'i') - while not nPartId do - -- recupero il base outline da cui deriva - nBaseOutline = EgtGetInfo( nBaseOutline, WIN_SOU, 'i') + nBaseOutline = EgtGetInfo( nBaseOutline, WIN_SOU, 'i') + while nBaseOutline and not nPartId do -- verifico se ha un profilo associato ( e quindi un pezzo) local sProfileType = EgtGetInfo( nBaseOutline, WIN_PROFILETYPE) if sProfileType then @@ -418,6 +446,7 @@ local function FindAssociatedPart( nOutlineId, bUseBottomRail) nCrvId = EgtGetInfo( nBaseOutline, WIN_COPY, 'i') nPartId = EgtGetInfo( nCrvId, WIN_REF_PART, 'i') end + nBaseOutline = EgtGetInfo( nBaseOutline, WIN_SOU, 'i') end end @@ -1002,6 +1031,150 @@ local function CalculateSplitOutline( nAreaId) end end +--------------------------------------------------------------------- +local function CalculateFillOutline( nAreaId, nAreaLayerId, nOutlineLayerId) + + -- recupero area parent di tipo telaio/anta che la contiene + local vSplitAreas = {} + local nParentArea = EgtGetParent( nAreaId) + local nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i') + while nAreaType ~= WIN_AREATYPES.FRAME and nAreaType ~= WIN_AREATYPES.SASH do + if nAreaType == WIN_AREATYPES.SPLIT then + table.insert( vSplitAreas, nParentArea) + end + nParentArea = EgtGetParent( nParentArea) + nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i') + end + + -- 1) calcolo l'area complessiva di fill definita dal suo parent + local nParentOutlineLayer = EgtGetFirstNameInGroup( nParentArea, WIN_OUTLINE) + local vAdjustZ = {} + local nRefZ + local nParentOutlineId = EgtGetFirstInGroup( nParentOutlineLayer) + while nParentOutlineId do + -- copio la curva di outline del parent + local nOutlineId = EgtCopy( nParentOutlineId, nOutlineLayerId) + EgtSetInfo( nOutlineId, WIN_REF_OUTLINE, nParentOutlineId) + + -- recupero il suo profilo per calcolare l'offset perpendicolare + local nParentProfileId = GetOutlineProfileId( nParentOutlineId, true) + local b3FrameProfile = GetProfileLocalBox( nParentProfileId) + local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd') or 0 + local dDimRef = b3FrameProfile:getMin():getX() + local dFillPerpOffset = abs( dDimRef) - dOverlap + if EgtGetName( nParentProfileId) == WIN_FILL_RAIL then + -- se bottom rail considero la distanza necessaria per il numero di bottomrail richiesti + local nBottomRails = EgtGetInfo( nParentOutlineId, WIN_BOTTOMRAIL, 'i') + local dRailDelta1 = EgtGetInfo( nParentProfileId, WIN_RAILDELTA .. '1', 'd') + local dRailDelta2 = EgtGetInfo( nParentProfileId, WIN_RAILDELTA .. '2', 'd') + dFillPerpOffset = dFillPerpOffset + dRailDelta1 + ( nBottomRails - 1) * dRailDelta2 + end + EgtOffsetCurve( nOutlineId, - dFillPerpOffset) + + -- movimento in z : se non è definito ( come nel caso di alcuni pezzi di telaio con cambio profilo) salvo la curva per correggere la sua z in seguito, se è definito salvo + -- una curva come riferimento per le curve da correggere + local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd') + if not dFillZOffset then + table.insert( vAdjustZ, nOutlineId) + else + nRefZ = nOutlineId + EgtMove( nOutlineId, Z_AX() * dFillZOffset) + end + + nParentOutlineId = EgtGetNext( nParentOutlineId) + end + -- sistemo quote per tratti che non avevano movimento in z definito nel profilo + for i = 1, #vAdjustZ do + EgtMove( vAdjustZ[i], ( EgtSP( nRefZ):getZ() - EgtSP( vAdjustZ[i]):getZ()) * Z_AX()) + end + -- accorcio gli offset + local vCrvs = TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1) + + + -- 2) taglio con split + if #vSplitAreas == 0 then + return + end + -- creo bordo complessivo dell'outline, salvando le info come temp prop della curva per non perderle + local vRefOutlines = {} + for i = 1, #vCrvs do + vRefOutlines[i] = EgtGetInfo( vCrvs[i], WIN_REF_OUTLINE, 'i') + end + local nCompo = EgtCurveCompo( nOutlineLayerId, vCrvs) + for i = 0, #vCrvs - 1 do + EgtCurveCompoSetTempProp( nCompo, i, vRefOutlines[i+1]) + end + + -- recupero gli split coinvolti nell'area fill + local tabSplits = {} + local vBaseOutlines = EgtGetAllInGroup( nAreaLayerId) + for i = 1, #vBaseOutlines do + -- verifico se deriva da split + local nSouId = EgtGetInfo( vBaseOutlines[i], WIN_SOU, 'i') + while nSouId and EgtGetName( nSouId) ~= WIN_SPLIT do + nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') + end + if nSouId then + tabSplits[nSouId] = vBaseOutlines[i] + end + end + + -- taglio con split + for i = #vSplitAreas, 1, -1 do + local nSplitBaseOutline = EgtGetFirstNameInGroup( vSplitAreas[i], WIN_BASESPLIT) + local vSplitBaseOutlines = EgtGetAllInGroup( nSplitBaseOutline) + for j = 1, #vSplitBaseOutlines do + -- verifico sia uno split coinvolto nell'area fill considerata + if tabSplits[vSplitBaseOutlines[j]] then + + -- a) creo la curva di outline corrispondente allo split + local nSplitOutline = EgtGetInfo( vSplitBaseOutlines[j], WIN_COPY, 'i') + local nOutlineId = EgtCopy( nSplitOutline, nOutlineLayerId) + -- verifico orientamento + local nRefCrv = EgtGetPrev( tabSplits[vSplitBaseOutlines[j]]) or EgtGetNext( tabSplits[vSplitBaseOutlines[j]]) + local _, _, nSide = EgtPointCurveDistSide( EgtMP( nRefCrv), vSplitBaseOutlines[j], Z_AX()) + if nSide == 1 then + EgtInvertCurve( nOutlineId) + end + -- calcolo gli offset + local nParentProfileId = GetOutlineProfileId( nSplitOutline, true) + local b3FrameProfile = GetProfileLocalBox( nParentProfileId) + local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd') + local bMixedSplit = EgtGetInfo( nSplitOutline, WIN_PRF_CHANGE, 'b') or false + local dDimRef = EgtIf( bMixedSplit, b3FrameProfile:getMax():getX(), b3FrameProfile:getMin():getX()) + local dFillPerpOffset = abs( dDimRef) - dOverlap + EgtOffsetCurve( nOutlineId, - dFillPerpOffset) + -- movimento in z + local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd') + EgtMove( nOutlineId, Z_AX() * dFillZOffset) + + -- b) aggiorno la curva complessiva di outline con la curva appena calcolata + local ptS = EgtIP( nOutlineId, nCompo, EgtSP( nOutlineId)) + local ptE = EgtIP( nOutlineId, nCompo, EgtEP( nOutlineId)) + local dBorderParS = EgtCurveParamAtPoint( nCompo, ptS) + local dBorderParE = EgtCurveParamAtPoint( nCompo, ptE) + EgtTrimCurveStartEndAtParam( nCompo, dBorderParE, dBorderParS) + local dSplitParS = EgtCurveParamAtPoint( nOutlineId, ptS) + local dSplitParE = EgtCurveParamAtPoint( nOutlineId, ptE) + EgtTrimCurveStartEndAtParam( nOutlineId, dSplitParS, dSplitParE) + EgtAddCurveCompoCurve( nCompo, nOutlineId) + local _, dParEnd = EgtCurveDomain( nCompo) + EgtCurveCompoSetTempProp( nCompo, dParEnd - 1, EgtIf( nSide == 1, - nSplitOutline, nSplitOutline)) + end + end + end + + -- spezzo la curva di outline nelle sue sottocurve e riassegno le info + local vTempProps = EgtCurveCompoGetTempProp( nCompo) + local nCrv, nCnt = EgtExplodeCurveCompo( nCompo) + for i = 0, nCnt - 1 do + EgtSetInfo( nCrv + i, WIN_REF_OUTLINE, vTempProps[i+1]) + if vTempProps[i+1] < 0 then + EgtSetInfo( nCrv + i, WIN_INV_SPLIT, true) + end + end +end + --------------------------------------------------------------------- -- funzione che calcola l'outline dall'area outline ( base outline) local function CalculateOutlineFromAreaOutline( nAreaId) @@ -1160,56 +1333,8 @@ local function CalculateOutlineFromAreaOutline( nAreaId) -- FILL elseif nAreaType == WIN_AREATYPES.FILL then - -- ciclo su BaseArea riempimento - local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId) - while nBaseOutlineId do - -- recupero la curva di outline del base outline da cui deriva e la copio - local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') - local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') or GDB_ID.NULL - local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) - - if nOutlineId then - -- sistemo le info - EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId) - EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId) - - -- recupero a ritroso il profilo dell'elemento su cui poggia ( anta, split o frame) - local nParentBaseOutlineId = nSouId - local sParentProfile = EgtGetInfo( nParentBaseOutlineId, WIN_PROFILETYPE) - while not sParentProfile and nParentBaseOutlineId do - nParentBaseOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_SOU , 'i') - sParentProfile = EgtGetInfo( nParentBaseOutlineId or GDB_ID.NULL, WIN_PROFILETYPE) - end - local nParentOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_COPY, 'i') - local nParentProfileId = GetOutlineProfileId( nParentOutlineId, true) - sParentProfile = EgtGetName( nParentProfileId) - - -- calcolo il box del riferimento del profilo del frame - local b3FrameProfile = GetProfileLocalBox( nParentProfileId) - -- calcolo offset perpendicolare e sulla z dell'anta - local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd') - local bMixedSplit = ( EgtGetInfo( nParentOutlineId, WIN_PRF_CHANGE, 'b') or false) and EgtGetName( nParentOutlineId) == WIN_SPLIT - local dDimRef = EgtIf( bMixedSplit, b3FrameProfile:getMax():getX(), b3FrameProfile:getMin():getX()) - local dFillPerpOffset = abs( dDimRef) - dOverlap - if sParentProfile == WIN_FILL_RAIL then - -- se bottom rail considero la distanza necessaria per il numero di bottomrail richiesti - local nBottomRails = EgtGetInfo( nParentOutlineId, WIN_BOTTOMRAIL, 'i') - local dRailDelta1 = EgtGetInfo( nParentProfileId, WIN_RAILDELTA .. '1', 'd') - local dRailDelta2 = EgtGetInfo( nParentProfileId, WIN_RAILDELTA .. '2', 'd') - dFillPerpOffset = dFillPerpOffset + dRailDelta1 + ( nBottomRails - 1) * dRailDelta2 - end - -- faccio offset - EgtOffsetCurve( nOutlineId, - dFillPerpOffset) - - -- movimento in z - local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd') - EgtMove( nOutlineId, Z_AX() * dFillZOffset) - end - - nBaseOutlineId = EgtGetNext( nBaseOutlineId) - end - -- accorcio gli offset - TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1) + CalculateFillOutline( nAreaId, nAreaOutlineLayerId, nOutlineLayerId) + end end @@ -1357,80 +1482,114 @@ end -- funzione che verifica gli outlines prev/next per lo split controllando l'interferenza tra i profili local function TestSplitTrimOutlines( nOutlineId, vTrimOutlines, nMainProfile, b3Profile, nGrpTmp, bPrevOrNext) - if #vTrimOutlines == 1 then - -- verifico se conviene testare la curva precedente o successiva - local bBefore = false - local nRefCurve - local ptRef = EgtIf( bPrevOrNext, EgtSP( nOutlineId), EgtEP( nOutlineId)) - local dPar = EgtCurveParamAtPoint( vTrimOutlines[1], ptRef) - if dPar > 0.5 then - nRefCurve = EgtGetNext( vTrimOutlines[1]) or EgtGetFirstInGroup( EgtGetParent( vTrimOutlines[1])) - else - bBefore = true - nRefCurve = EgtGetPrev( vTrimOutlines[1]) or EgtGetLastInGroup( EgtGetParent( vTrimOutlines[1])) - end + local vRealTrimOutlines = {} + + -- 1) recupero le curve da testare + local vTestOutlines = {} + + -- a) curve individuate dalle intersezioni degli outlines + for i = 1, #vTrimOutlines do + vTestOutlines[i] = vTrimOutlines[i] + end + + -- b) curve vicine a quelle individuate dalle intersezioni che interferiscono con l'outline ( guardando interferenza grossolana dei pezzi) + -- recupero le curve di bordo del pezzo di split + local nOutlineCopyId = EgtCopyGlob( nOutlineId, nGrpTmp) + if bPrevOrNext then + EgtTrimCurveEndAtParam( nOutlineCopyId, 0.5) + else + EgtTrimCurveStartAtParam( nOutlineCopyId, 0.5) + end + local nOutId = EgtOffsetCurveAdv( nOutlineCopyId, b3Profile:getMax():getX()) + local nInId = EgtOffsetCurveAdv( nOutlineCopyId, b3Profile:getMin():getX()) - -- primo test : controllo interferenza tra i box dei pezzi - local nRefPart = FindAssociatedPart( nRefCurve, true) + -- curve precedenti + local nTestCurve = EgtGetPrev( vTrimOutlines[1]) or EgtGetLastInGroup( EgtGetParent( vTrimOutlines[1])) + local bInters = true + while bInters and nTestCurve ~= vTrimOutlines[#vTrimOutlines] do + + local nRefPart = FindAssociatedPart( nTestCurve, true) local nRefGeo = EgtGetFirstNameInGroup( nRefPart, WIN_GEO) local nRefSurf = EgtGetFirstNameInGroup( nRefGeo, WIN_GEO_SURF) - local nOutId = EgtOffsetCurveAdv( nOutlineId, b3Profile:getMax():getX()) - local nInId = EgtOffsetCurveAdv( nOutlineId, b3Profile:getMin():getX()) - EgtRelocateGlob( nOutId, nGrpTmp) - EgtRelocateGlob( nInId, nGrpTmp) - local _, nCnt1 = EgtTrimCurveWithRegion( nOutId, nRefSurf, true, false) - local _, nCnt2 = EgtTrimCurveWithRegion( nInId, nRefSurf, true, false) - if nCnt1 == 0 and nCnt2 == 0 then - return vTrimOutlines + local nClassOut = EgtCurveWithRegionClassify( nOutId, nRefSurf) + if nClassOut == GDB_CRC.OUT then + local nClassIn = EgtCurveWithRegionClassify( nInId, nRefSurf) + -- se non c'è interferenza interrompo la ricerca + if nClassIn == GDB_CRC.OUT then + bInters = false + end end - - if bBefore then - vTrimOutlines = { nRefCurve, vTrimOutlines[1]} - else - vTrimOutlines = { vTrimOutlines[1], nRefCurve} + -- se interferenza lo aggiungo tra le curve da controllare + if bInters then + table.insert( vTestOutlines, 1, nTestCurve) + nTestCurve = EgtGetPrev( nTestCurve) or EgtGetLastInGroup( EgtGetParent( nTestCurve)) end end - local vRealTrimOutlines = {} - - -- recupero i profili e i controprofili con cui tagliare - local nProfile1 = GetOutlineProfileId( vTrimOutlines[1], true) - local nProfile2 = GetOutlineProfileId( vTrimOutlines[2], true) - local sCtrIn1 = GetProfileCtrIn( vTrimOutlines[1], nOutlineId, nProfile1) - local sCtrIn2 = GetProfileCtrIn( vTrimOutlines[2], nOutlineId, nProfile2) + -- curve successive + nTestCurve = EgtGetNext( vTrimOutlines[#vTrimOutlines]) or EgtGetFirstInGroup( EgtGetParent( vTrimOutlines[1])) + bInters = true + while bInters and nTestCurve ~= vTrimOutlines[1] do + + local nRefPart = FindAssociatedPart( nTestCurve, true) + local nRefGeo = EgtGetFirstNameInGroup( nRefPart, WIN_GEO) + local nRefSurf = EgtGetFirstNameInGroup( nRefGeo, WIN_GEO_SURF) + + local nClassOut = EgtCurveWithRegionClassify( nOutId, nRefSurf) + if nClassOut == GDB_CRC.OUT then + local nClassIn = EgtCurveWithRegionClassify( nInId, nRefSurf) + if nClassIn == GDB_CRC.OUT then + bInters = false + end + end + if bInters then + table.insert( vTestOutlines, nTestCurve) + nTestCurve = EgtGetNext( nTestCurve) or EgtGetFirstInGroup( EgtGetParent( nTestCurve)) + end + end - -- creo il solido + -- 2) testo le curve controllando intersezione tra le superfici dei pezzi + -- creo il solido principale local dExtraLen = b3Profile:getDimX() local nMainSurf = CreateProfileSurf( nOutlineId, nMainProfile, WIN_SECTION, 4 * dExtraLen, nGrpTmp) EgtCutSurfTmPlane( nMainSurf, EgtMP( nOutlineId), EgtIf( bPrevOrNext, 1, -1) * EgtSV( nOutlineId)) - -- testo la curva 1 - local nTestSurf1 = CreateProfileSurf( vTrimOutlines[1], nProfile1, sCtrIn1, 4 * dExtraLen, nGrpTmp) - if AreSameVectorApprox( EgtEV( vTrimOutlines[1]), EgtSV( vTrimOutlines[2])) then - EgtCutSurfTmPlane( nTestSurf1, EgtEP( vTrimOutlines[1]), EgtEV( vTrimOutlines[1]), false) - else - local nTrimSurf2 = CreateProfileSurf( vTrimOutlines[2], nProfile2, WIN_OFST .. sCtrIn2, 4 * dExtraLen, nGrpTmp) - EgtSurfTmCut( nTestSurf1, nTrimSurf2, true, false) - end - local nId, _, nCrvCnt = EgtSurfTmSurfTmInters( nMainSurf, nTestSurf1, nGrpTmp) - if nId and nCrvCnt > 0 then - vRealTrimOutlines[1] = vTrimOutlines[1] - end - - -- testo la curva 2 - local nTestSurf2 = CreateProfileSurf( vTrimOutlines[2], nProfile2, sCtrIn2, 4 * dExtraLen, nGrpTmp) - if AreSameVectorApprox( EgtEV( vTrimOutlines[1]), EgtSV( vTrimOutlines[2])) then - EgtCutSurfTmPlane( nTestSurf2, EgtEP( vTrimOutlines[1]), - EgtEV( vTrimOutlines[1]), false) - else - local nTrimSurf1 = CreateProfileSurf( vTrimOutlines[1], nProfile1, WIN_OFST .. sCtrIn1, 4 * dExtraLen, nGrpTmp) - EgtSurfTmCut( nTestSurf2, nTrimSurf1, true, false) - end - local nId2, _, nCrvCnt2 = EgtSurfTmSurfTmInters( nMainSurf, nTestSurf2, nGrpTmp) - if nId2 and nCrvCnt2 > 0 then - table.insert( vRealTrimOutlines, vTrimOutlines[2]) + -- recupero profili per i conti + local vProfiles = {} + local vsCtrIn = {} + for i = 1, #vTestOutlines do + vProfiles[i] = GetOutlineProfileId( vTestOutlines[i], true) + vsCtrIn[i] = GetProfileCtrIn( vTestOutlines[i], nOutlineId, vProfiles[i]) end + -- testo le curve + for i = 1, #vTestOutlines do + -- creo la superficie di test limitandola con le sue vicine + local nTestSurf = CreateProfileSurf( vTestOutlines[i], vProfiles[i], vsCtrIn[i], 4 * dExtraLen, nGrpTmp) + if i > 1 then + if AreSameVectorApprox( EgtEV( vTestOutlines[i-1]), EgtSV( vTestOutlines[i])) then + EgtCutSurfTmPlane( nTestSurf, EgtEP( vTestOutlines[i-1]), - EgtEV( vTestOutlines[i-1]), false) + else + local nTrimSurf = CreateProfileSurf( vTestOutlines[i-1], vProfiles[i-1], WIN_OFST .. vsCtrIn[i-1], 4 * dExtraLen, nGrpTmp) + EgtSurfTmCut( nTestSurf, nTrimSurf, true, false) + end + end + if i < #vTestOutlines then + if AreSameVectorApprox( EgtEV( vTestOutlines[i]), EgtSV( vTestOutlines[i+1])) then + EgtCutSurfTmPlane( nTestSurf, EgtEP( vTestOutlines[i]), EgtEV( vTestOutlines[i]), false) + else + local nTrimSurf = CreateProfileSurf( vTestOutlines[i+1], vProfiles[i+1], WIN_OFST .. vsCtrIn[i+1], 4 * dExtraLen, nGrpTmp) + EgtSurfTmCut( nTestSurf, nTrimSurf, true, false) + end + end + -- calcolo intersezione con il solido : se c'è intersezione è una vera curva di trim, altrimenti non va considerata + local nId, _, nCrvCnt = EgtSurfTmSurfTmInters( nMainSurf, nTestSurf, nGrpTmp) + if nId and nCrvCnt > 0 then + table.insert( vRealTrimOutlines, vTestOutlines[i]) + end + end + return vRealTrimOutlines end @@ -1820,52 +1979,6 @@ local function CalcFrameGeo( nPartId, nOutlineId, nOutlineCrvNbr, nOutlineLayerI end ---------------------------------------------------------------------- -local function AddFillGeoCurve( nTestOutlineId, nOtherGeoId, nGeoLayerId) - - -- verifico se la curva da testare è quella già presente nell'outline - local bAdd = true - local nRef = EgtGetInfo( abs( nTestOutlineId), WIN_COPY, 'i') - local nOtherOutlineId = abs( EgtGetInfo( nOtherGeoId, WIN_REF_OUTLINE, 'i')) - local nOtherBaseOutlineId = EgtGetInfo( nOtherOutlineId, WIN_COPY, 'i') - local nOtherSouId = EgtGetInfo( nOtherBaseOutlineId, WIN_SOU, 'i') - while nOtherSouId and bAdd do - bAdd = ( nOtherSouId ~= nRef) - nOtherSouId = EgtGetInfo( nOtherSouId, WIN_SOU, 'i') - end - - if not bAdd then - return - end - - -- aggiungo al geo - local nNewCrv = EgtCopyGlob( abs( nTestOutlineId), nGeoLayerId) - - -- setto info per recuperare outline che lo ha generato - EgtSetInfo( nNewCrv, WIN_REF_OUTLINE, abs( nTestOutlineId)) - - -- recupero offset dal profilo - local nRefPart = FindAssociatedPart( abs( nTestOutlineId), true) - local nProfileLayId = EgtGetFirstNameInGroup( nRefPart, WIN_PROFILE) - local nProfileId = EgtGetFirstNameInGroup( nProfileLayId, WIN_PRF_MAIN) - local b3Profile = GetProfileLocalBox( nProfileId) - local dOverlap = EgtGetInfo( nProfileId, WIN_FILLOVERLAP, 'd') - local dDimRef = b3Profile:getMin():getX() - local dFillPerpOffset = abs( dDimRef) - dOverlap - - EgtOffsetCurve( nNewCrv, - dFillPerpOffset) - - -- applico movimento in z - local dFillZOffset = EgtGetInfo( nProfileId, WIN_FILLDELTA, 'd') - EgtMove( nNewCrv, Z_AX() * dFillZOffset) - - if nTestOutlineId < 0 then - EgtInvertCurve( nNewCrv) - end - - return nNewCrv -end - --------------------------------------------------------------------- -- funzione che calcola l'ingombro del fill local function CalcFillGeo( nPartId, nOutlineLayerId) @@ -1880,60 +1993,6 @@ local function CalcFillGeo( nPartId, nOutlineLayerId) EgtSetInfo( nCrv, WIN_REF_OUTLINE, vOutlineIds[i]) end - -- verifico che nel caso di split i suoi prev e next siano stati considerati correttamente dall'outline, altrimenti li aggiungo - local bExtraCrvs = false - local vGeoIds = EgtGetAllInGroup( nGeoLayerId) - for i = 1, #vGeoIds do - local nRefBaseSplit = EgtGetInfo( vOutlineIds[i], WIN_REF_SPLIT, 'i') - if nRefBaseSplit then - - local nRefSplit = EgtGetInfo( nRefBaseSplit, WIN_COPY, 'i') - local vPrevOutlines = EgtGetInfo( nRefSplit, WIN_PREV_OUTLINES, 'vi') - local vNextOutlines = EgtGetInfo( nRefSplit, WIN_NEXT_OUTLINES, 'vi') - -- se la curva è invertita devo scambiare prev e next - local bInverted = EgtGetInfo( vOutlineIds[i], WIN_INV_SPLIT, 'b') or false - if bInverted then - vPrevOutlines, vNextOutlines = vNextOutlines, vPrevOutlines - end - - -- sistemo i precedenti - local nPrevIdx = EgtIf( i == 1, #vOutlineIds, i-1) - local nOldCrv = vGeoIds[i] - for j = #vPrevOutlines, 1, -1 do - local nPrevCrv = AddFillGeoCurve( vPrevOutlines[j], vGeoIds[nPrevIdx], nGeoLayerId) - if nPrevCrv then - bExtraCrvs = true - else - -- se non è stata aggiunta era già la curva presente nel geo - nPrevCrv = vGeoIds[nPrevIdx] - nPrevIdx = EgtIf( nPrevIdx == 1, #vOutlineIds, nPrevIdx-1) - end - EgtRelocateGlob( nPrevCrv, nOldCrv, GDB_IN.BEFORE) - nOldCrv = nPrevCrv - end - - -- sistemo i successivi - local nNextIdx = EgtIf( i == #vOutlineIds, 1, i+1) - nOldCrv = vGeoIds[i] - for j = 1, #vNextOutlines do - local nNextCrv = AddFillGeoCurve( vNextOutlines[j], vGeoIds[nNextIdx], nGeoLayerId) - if nNextCrv then - bExtraCrvs = true - else - nNextCrv = vGeoIds[nNextIdx] - nNextIdx = EgtIf( nNextIdx == #vOutlineIds, 1, nNextIdx+1) - end - EgtRelocateGlob( nNextCrv, nOldCrv, GDB_IN.AFTER) - nOldCrv = nNextCrv - end - end - end - - -- se sono state aggiunte delle curve è necessario trimmarle - if bExtraCrvs then - TrimOrderedCurves( EgtGetAllInGroup( nGeoLayerId)) - end - -- recupero e salvo spessore vetro local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) local nSashProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH) @@ -2429,7 +2488,7 @@ local function AdjustProcessingLength( nCrvId, nSemiProfileId, nGeoAreaId, nPrev EgtErase( nNewId + nCnt - 1) nCnt = nCnt - 1 end - local nPrcOutId = EgtGetFirstNameInGroup( EgtGetParent( nCrvId), WIN_GEO_OUT) + local nPrcOutId = EgtGetFirstNameInGroup( EgtGetParent( nGeoAreaId), WIN_GEO_OUT) local ptRef = EgtIf( EgtGetName( nCrvId) == WIN_LEFT, EgtSP( nPrcOutId), EgtEP( nPrcOutId)) local nIdRef local dSqMinDist = GEO.INFINITO @@ -2581,16 +2640,22 @@ local function CalcGeoRaw( nPartId) -- recupero le curve del raw e applico i sovramateriali local nOut = EgtGetFirstNameInGroup( nGeoRawLayerId, WIN_GEO_OUT) - EgtOffsetCurve( nOut, dOvermatOut) + if not EgtOffsetCurve( nOut, dOvermatOut) then + EgtErase( nOut) + end local nIn = EgtGetFirstNameInGroup( nGeoRawLayerId, WIN_GEO_IN) - EgtOffsetCurve( nIn, dOvermatIn) + if not EgtOffsetCurve( nIn, dOvermatIn) then + EgtErase( nIn) + end local vRight = EgtGetNameInGroup( nGeoRawLayerId, WIN_GEO_RIGHT) for i = 1, #vRight do local bExtra = EgtGetInfo( vRight[i], WIN_GEO_EXTRA, 'b') or false if bExtra then EgtErase( vRight[i]) else - EgtOffsetCurve( vRight[i], dOvermatRight) + if not EgtOffsetCurve( vRight[i], dOvermatRight) then + EgtErase( vRight[i]) + end end end local vLeft = EgtGetNameInGroup( nGeoRawLayerId, WIN_GEO_LEFT) @@ -2599,7 +2664,9 @@ local function CalcGeoRaw( nPartId) if bExtra then EgtErase( vLeft[i]) else - EgtOffsetCurve( vLeft[i], dOvermatLeft) + if not EgtOffsetCurve( vLeft[i], dOvermatLeft) then + EgtErase( vLeft[i]) + end end end @@ -2624,7 +2691,7 @@ end ---------------------------------- SOLIDO ---------------------------------------- ---------------------------------------------------------------------------------- -- funzione che crea la superficie di trim per il solido -local function CreateTrimSurf( nGeoId, nProfileId, dGeoWidth, nLayerId) +local function CreateTrimSurf( nGeoId, nOutlineId, dGeoWidth, nLayerId) -- recupero profilo di riferimento dalla curva geo local nOrigTrimProfileId = EgtGetInfo( nGeoId, WIN_SEMI_PROFILE, 'i') @@ -2636,8 +2703,7 @@ local function CreateTrimSurf( nGeoId, nProfileId, dGeoWidth, 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) + local nTrimSurf = EgtSurfTmByExtrusion( nLayerId, nGuideId, - Z_AX() * dGeoWidth * 2, WIN_SURF_APPROX) EgtInvertSurf( nTrimSurf) EgtErase( nGuideId) return nTrimSurf @@ -2647,10 +2713,8 @@ local function CreateTrimSurf( nGeoId, nProfileId, dGeoWidth, nLayerId) -- 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 = abs( EgtGetInfo( nGeoId, WIN_REF_OUTLINE, 'i')) -- calcolo la superficie di estrusione - return CreateProfileSurf( nRefOutline, nProfileId, sTrimProfileName, 4 * dGeoWidth, nLayerId) + return CreateProfileSurf( nOutlineId, EgtGetParent( nOrigTrimProfileId), sTrimProfileName, 4 * dGeoWidth, nLayerId) end end @@ -2788,19 +2852,19 @@ local function CalcMixedFrameSolid( nOutlineId, nSolidLayerId, nProfileLayerId, -- 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) + local nStartOutlineId = EgtGetInfo( nPrevGeoId, WIN_REF_OUTLINE, 'i') + local nTrimSurfStart = CreateTrimSurf( nPrevGeoId, nStartOutlineId, dGeoWidth, nSolidLayerId) EgtSetStatus( nTrimSurfStart, GDB_ST.OFF) EgtSurfTmIntersect( vMainExtrusions[1], nTrimSurfStart) + EgtSetInfo( nPrevGeoId, WIN_REF_SURF, nTrimSurfStart) -- c) TRIM END local nNextGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) - local nEndProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END) - local nTrimSurfEnd = CreateTrimSurf( nNextGeoId, nEndProfileId, dGeoWidth, nSolidLayerId) - EgtSetName( nTrimSurfEnd, WIN_SRF_END) + local nEndOutlineId = EgtGetInfo( nNextGeoId, WIN_REF_OUTLINE, 'i') + local nTrimSurfEnd = CreateTrimSurf( nNextGeoId, nEndOutlineId, dGeoWidth, nSolidLayerId) EgtSetStatus( nTrimSurfEnd, GDB_ST.OFF) EgtSurfTmIntersect( vMainExtrusions[1], nTrimSurfEnd) + EgtSetInfo( nNextGeoId, WIN_REF_SURF, nTrimSurfEnd) return vMainExtrusions[1] end @@ -2822,21 +2886,44 @@ local function CalcMixedSplitSolid( nOutlineId, nSolidLayerId, nProfileLayerId, local nPrevProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_START) local nPrevMixedOutline = EgtGetInfo( nOutlineId, WIN_MIXED_REF_START, 'i') local nStmTrimStart = CreateMixedSplitTrimSurf( nPrevMixedOutline, nPrevProfileId, dGeoWidth, nSolidLayerId) - EgtSetName( nStmTrimStart, WIN_SRF_START) EgtSetStatus( nStmTrimStart, GDB_ST.OFF) EgtSurfTmIntersect( nMainExtrusionId, nStmTrimStart) - + local nGeoLayerId = EgtGetFirstNameInGroup( EgtGetParent( nSolidLayerId), WIN_GEO) + local nPrevGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_LEFT) + EgtSetInfo( nPrevGeoId, WIN_REF_SURF, nStmTrimStart) + -- c) trim end local nNextProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_END) local nNextMixedOutline = EgtGetInfo( nOutlineId, WIN_MIXED_REF_END, 'i') local nStmTrimEnd = CreateMixedSplitTrimSurf( nNextMixedOutline, nNextProfileId, dGeoWidth, nSolidLayerId) - EgtSetName( nStmTrimEnd, WIN_SRF_END) EgtSetStatus( nStmTrimEnd, GDB_ST.OFF) EgtSurfTmIntersect( nMainExtrusionId, nStmTrimEnd) + local nNextGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) + EgtSetInfo( nNextGeoId, WIN_REF_SURF, nStmTrimEnd) return nMainExtrusionId end +--------------------------------------------------------------------- +-- funzione che verifica se due curve del geo sono concatenabili, ovvero se hanno lo stesso profilo e i corrispondenti outline coincidono o sono in tangenza +local function CheckChainability( nGeoCrv1, nGeoCrv2) + + -- verifico profili + local sProfile1 = EgtGetInfo( nGeoCrv1, WIN_PROFILETYPE) + local sProfile2 = EgtGetInfo( nGeoCrv2, WIN_PROFILETYPE) + local nSemiProfileId1 = EgtGetInfo( nGeoCrv1, WIN_SEMI_PROFILE, 'i') + local nSemiProfileId2 = EgtGetInfo( nGeoCrv2, WIN_SEMI_PROFILE, 'i') + if sProfile1 == sProfile2 and nSemiProfileId1 and nSemiProfileId2 and EgtGetName( nSemiProfileId1) == EgtGetName( nSemiProfileId2) then + -- verifico outlines + local nRefOutline1 = EgtGetInfo( nGeoCrv1, WIN_REF_OUTLINE, 'i') + local nRefOutline2 = EgtGetInfo( nGeoCrv2, WIN_REF_OUTLINE, 'i') + if nRefOutline1 == nRefOutline2 or AreSameVectorApprox( EgtEV( nRefOutline1), EgtSV( nRefOutline2)) then + return true + end + end + return false +end + --------------------------------------------------------------------- -- funzione che crea il solido del pezzo local function CalcSolid( nPartId, nOutlineId) @@ -2871,27 +2958,50 @@ local function CalcSolid( nPartId, nOutlineId) EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN) EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF) - -- b) trim con i controprofili sullo start + -- b) trim con i controprofili su start e su end + local vGeoId = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) local vPrevGeoId = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_LEFT) - local vStartProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_START) - for i = 1, #vPrevGeoId do - -- creo la superficie di trim - local nTrimSurf = CreateTrimSurf( vPrevGeoId[i], vStartProfileId[i], dGeoWidth, nSolidLayerId) - EgtSetStatus( nTrimSurf, GDB_ST.OFF) - EgtSetName( nTrimSurf, WIN_SRF_START) - -- eseguo intersezione per ottenere un solido unico ( tagliare le due superfici con EgtSurfTmCut e poi unirle potrebbe creare piccoli buchi legati alle diverse approssimazioni) - EgtSurfTmIntersect( nMainExtrusionId, nTrimSurf) + EgtJoinTables( vGeoId, vPrevGeoId) + -- verifico quali curve di trim conviene concatenare per evitare booleane problematiche con tratti sovrapposti + local vChains = {{ vGeoId[1]}} + for i = 2, #vGeoId do + if CheckChainability( vGeoId[i-1], vGeoId[i]) then + -- aggiugno alla catena corrente + table.insert( vChains[#vChains], vGeoId[i]) + else + -- creo una nuova catena + table.insert( vChains, { vGeoId[i]}) + end end - -- c) trim con i controprofili sull'end - local vNextGeoId = EgtGetNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) - local vEndProfileId = EgtGetNameInGroup( nProfileLayerId, WIN_PRF_END) - for i = 1, #vNextGeoId do - -- creo la superficie di trim - local nTrimSurf = CreateTrimSurf( vNextGeoId[i], vEndProfileId[i], dGeoWidth, nSolidLayerId) + -- calcolo le superfici di trim + for i = 1, #vChains do + local nTrimSurf + if #vChains[i] == 1 then + local nRefOutlineId = EgtGetInfo( vChains[i][1], WIN_REF_OUTLINE, 'i') + nTrimSurf = CreateTrimSurf( vChains[i][1], abs( nRefOutlineId), dGeoWidth, nSolidLayerId) + -- assegno alla curva del geo la superficie di trim creata + EgtSetInfo( vChains[i][1], WIN_REF_SURF, nTrimSurf) + else + -- costruisco la guida a partire dagli outlines + local vRefOutlineIds = {} + for j = 1, #vChains[i] do + local nCurrOutline = EgtGetInfo( vChains[i][j], WIN_REF_OUTLINE, 'i') + -- verifico di non inserire un outline doppio + if j == 1 or nCurrOutline ~= vRefOutlineIds[#vRefOutlineIds] then + table.insert( vRefOutlineIds, abs( nCurrOutline)) + end + end + local nGuideId = EgtCurveCompo( nSolidLayerId, vRefOutlineIds, false) + nTrimSurf = CreateTrimSurf( vChains[i][1], nGuideId, dGeoWidth, nSolidLayerId) + -- assegno ad ogni curva del geo la superficie di trim creata + for j = 1, #vChains[i] do + EgtSetInfo( vChains[i][j], WIN_REF_SURF, nTrimSurf) + end + EgtErase( nGuideId) + end + EgtSetStatus( nTrimSurf, GDB_ST.OFF) - EgtSetName( nTrimSurf, WIN_SRF_END) - -- eseguo intersezione per ottenere un solido unico EgtSurfTmIntersect( nMainExtrusionId, nTrimSurf) end @@ -3197,7 +3307,8 @@ local function CalcDowels( nOrigOutlineId, nOrigPrevOutlineId, bSashOrFrame, nBo nTestSurf = CreateProfileSurf( nOrigOutlineId, nProfileId, sCtrIn, 100, nLayerId) else -- è la superficie che viene utilizzata per trimmare l'end del pezzo prev - local nOrigSurf = EgtGetFirstNameInGroup( nPrevSolidLay, WIN_SRF_END) + local nGeoCrv = EgtGetFirstNameInGroup( nPrevGeo, WIN_GEO_RIGHT) + local nOrigSurf = EgtGetInfo( nGeoCrv, WIN_REF_SURF, 'i') nTestSurf = EgtCopyGlob( nOrigSurf, nLayerId) end local nTestSurfInverted = EgtCopyGlob( nTestSurf, nLayerId) @@ -3210,7 +3321,8 @@ local function CalcDowels( nOrigOutlineId, nOrigPrevOutlineId, bSashOrFrame, nBo if not s_bCalcSolid or s_bSimplSolid then nTestSurf2 = CreateProfileSurf( nOrigPrevOutlineId, nPrevProfileId, WIN_OFST .. WIN_OUT, 100, nLayerId) else - local nOrigSurf = EgtGetFirstNameInGroup( nSolidLay, WIN_SRF_START) + local nGeoCrv = EgtGetFirstNameInGroup( nGeo, WIN_GEO_LEFT) + local nOrigSurf = EgtGetInfo( nGeoCrv, WIN_REF_SURF, 'i') nTestSurf2 = EgtCopyGlob( nOrigSurf, nLayerId) end EgtInvertSurf( nTestSurf2) @@ -3286,7 +3398,8 @@ local function CalcDowels( nOrigOutlineId, nOrigPrevOutlineId, bSashOrFrame, nBo local sCtrIn = WIN_OFST .. GetProfileCtrIn( nOrigPrevOutlineId, nOutlineId, nPrevProfileId) -- controprofilo del pezzo full nTestSurf = CreateProfileSurf( nOrigPrevOutlineId, nPrevProfileId, sCtrIn, 100, nLayerId) else - local nOrigSurf = EgtGetFirstNameInGroup( nSolidLay, WIN_SRF_START) + local nGeoCrv = EgtGetFirstNameInGroup( nGeo, WIN_GEO_LEFT) + local nOrigSurf = EgtGetInfo( nGeoCrv, WIN_REF_SURF, 'i') nTestSurf = EgtCopyGlob( nOrigSurf, nLayerId) end local nTestSurfInverted = EgtCopyGlob( nTestSurf, nLayerId) @@ -3298,7 +3411,8 @@ local function CalcDowels( nOrigOutlineId, nOrigPrevOutlineId, bSashOrFrame, nBo if not s_bCalcSolid or s_bSimplSolid then nTestSurf2 = CreateProfileSurf( nOrigOutlineId, nProfileId, WIN_OFST .. WIN_OUT, 100, nLayerId) else - local nOrigSurf = EgtGetFirstNameInGroup( nPrevSolidLay, WIN_SRF_END) + local nGeoCrv = EgtGetFirstNameInGroup( nPrevGeo, WIN_GEO_RIGHT) + local nOrigSurf = EgtGetInfo( nGeoCrv, WIN_REF_SURF, 'i') nTestSurf2 = EgtCopyGlob( nOrigSurf, nLayerId) end EgtInvertSurf( nTestSurf2) @@ -3365,11 +3479,10 @@ local function CalcSplitDowels( nSplitId, bStartOrEnd) local nSplitLayerId = EgtGetFirstNameInGroup( nSplitPart, WIN_PRC) -- recupero eventuale solido e superifici usate per il suo trim - local nSplitSolidId, vTestSurf + local nSplitSolidId 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 @@ -3463,7 +3576,8 @@ local function CalcSplitDowels( nSplitId, bStartOrEnd) end else -- è la stessa superficie utilizzata per il trim del solido - nTestSurf = EgtCopyGlob( vTestSurf[i], nSplitLayerId) + local nTrimSurf = EgtGetInfo( vGeoCrvs[i], WIN_REF_SURF, 'i') + nTestSurf = EgtCopyGlob( nTrimSurf, nSplitLayerId) end local nTestSurfInverted = EgtCopyGlob( nTestSurf, nSplitLayerId) EgtInvertSurf( nTestSurfInverted) @@ -3621,12 +3735,12 @@ local function CreateStripGuideLines( nOutlineId, nRefOutlineId, nStripId, nProf end --------------------------------------------------------------------- -local function TrimStripSurf( pt1, pt2, nStripSurfId, nSolidLayerId) +local function TrimStripSurfByPoints( pt1, pt2, nStripSurfId, nSolidLayerId) -- creo la superficie di trim local nTrimGuideId = EgtLine( nSolidLayerId, pt1, pt2) - EgtExtendCurveStartByLen( nTrimGuideId, 10) - EgtExtendCurveEndByLen( nTrimGuideId, 10) + EgtExtendCurveStartByLen( nTrimGuideId, 100) + EgtExtendCurveEndByLen( nTrimGuideId, 100) EgtMove( nTrimGuideId, Z_AX()) local dDim = 100 local nTrimSurfId = EgtSurfTmByExtrusion( nSolidLayerId, nTrimGuideId, - Z_AX() * dDim, WIN_SURF_APPROX) @@ -3639,7 +3753,34 @@ local function TrimStripSurf( pt1, pt2, nStripSurfId, nSolidLayerId) end --------------------------------------------------------------------- --- funzione che calcola i fermavetro a partire dal Geo di un'area fill +local function TrimStripSurfByCurve( nCrvId, nStripSurfId, nSolidLayerId, bPrev) + + -- estendo la guida in tangenza + local nTrimGuideId = EgtCopyGlob( nCrvId, nSolidLayerId) + local dExtraLen = 100 + if EgtGetType( nTrimGuideId) == GDB_TY.CRV_LINE then + EgtExtendCurveStartByLen( nTrimGuideId, dExtraLen) + EgtExtendCurveEndByLen( nTrimGuideId, dExtraLen) + else + nTrimGuideId = EgtCurveCompo( nSolidLayerId, nTrimGuideId) + EgtAddCurveCompoLineTg( nTrimGuideId, dExtraLen) + EgtAddCurveCompoLineTg( nTrimGuideId, dExtraLen, false) + end + EgtMove( nTrimGuideId, Z_AX()) + EgtInvertCurve( nTrimGuideId) + + -- creo la superficie di trim + local dDim = 100 + local nTrimSurfId = EgtSurfTmByExtrusion( nSolidLayerId, nTrimGuideId, - Z_AX() * dDim, WIN_SURF_APPROX) + + -- intersezione con strip + EgtSurfTmIntersect( nStripSurfId, nTrimSurfId) + + EgtErase( nTrimGuideId) + EgtErase( nTrimSurfId) +end + +--------------------------------------------------------------------- local function CalcAreaStrip( nGeoFillId) if not s_bCalcSolid then return end @@ -3658,9 +3799,9 @@ local function CalcAreaStrip( nGeoFillId) for i = 1, #vGeoCrvs do local nCrvId = abs( EgtGetInfo( vGeoCrvs[i], WIN_REF_OUTLINE, 'i')) - local nPartId = FindAssociatedPart( nCrvId, true) - local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i') - + local nOutlineId = abs( EgtGetInfo( nCrvId, WIN_REF_OUTLINE, 'i')) + local nPartId = FindAssociatedPart( nOutlineId, true) + -- recupero profilo local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) @@ -3669,8 +3810,28 @@ local function CalcAreaStrip( nGeoFillId) -- recupero layer per solido local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) - -- estrusione del fermavetro - local nGuideId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_MAINGUIDE) + -- estrusione del fermavetro : + -- creazione della giuda + local nGuideId = EgtCurveCompo( nSolidLayerId, nOutlineId, false) + local sProfileType = EgtGetInfo( nProfileId, WIN_PRF_TYPE) + if sProfileType == WIN_FILL_RAIL then + local dOffs = EgtGetInfo( nProfileId, WIN_RAILDELTA, 'd') + EgtOffsetCurve( nGuideId, - dOffs) + end + -- estensione : se in tangenza con le vicine estensione in tangenza altrimenti estensione standard + local nPrev = EgtGetPrev( vGeoCrvs[i]) or EgtGetLastInGroup( nGeoFillId) + local nNext = EgtGetNext( vGeoCrvs[i]) or EgtGetLastInGroup( nGeoFillId) + if AreSameVectorApprox( EgtEV( nPrev), EgtSV( nGuideId)) then + EgtAddCurveCompoLineTg( nGuideId, 100, false) + else + EgtExtendCurveStartByLen( nGuideId, 100) + end + if AreSameVectorApprox( EgtEV( nGuideId), EgtSV( nNext)) then + EgtAddCurveCompoLineTg( nGuideId, 100) + else + EgtExtendCurveEndByLen( nGuideId, 100) + end + -- sistemo il profilo da estrudere local nSectionId = EgtCopyGlob( nStripId, nSolidLayerId) local nFrameProfileId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) local frOrig = EgtFR( nFrameProfileId, GDB_ID.ROOT) @@ -3681,6 +3842,7 @@ local function CalcAreaStrip( nGeoFillId) local nStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nSectionId, nGuideId, false, WIN_SURF_APPROX) EgtSetName( nStripExtrusionId, WIN_SRF_STRIP) EgtErase( nSectionId) + EgtErase( nGuideId) -- curve limite del fermavetro local nOffs1, nOffs2 = CreateStripGuideLines( nOutlineId, nCrvId, nStripId, nProfileId, nGrp) @@ -3730,18 +3892,29 @@ local function CalcAreaStrip( nGeoFillId) local nPrev2 = EgtGetPrev( nCrvOffs2) or EgtGetLastInGroup( nGrp2) local nPrevCrv1 = EgtGetInfo( nPrev1, WIN_REF_GEO, 'i') local nPrevCrv2 = EgtGetInfo( nPrev2, WIN_REF_GEO, 'i') - + if nPrevCrv1 == nPrevCrv2 then - -- se le precedenti coincidono devo tagliare con un solo pezzo - TrimStripSurf( EgtSP( nCrvOffs2), EgtSP( nCrvOffs1), nStripId, nSolidLayerId, true) + -- se le precedenti coincidono taglio basandomi solo sui riferimenti dello strip corrente + TrimStripSurfByPoints( EgtSP( nCrvOffs2), EgtSP( nCrvOffs1), nStripId, nSolidLayerId, true) else - -- se ho due precedenti distinte, devo tagliare con due pezzi : - -- nPrev1 : essendo la precedente per le curve 1, devo ricavare l'intersezione sulle curve 2 - local ptInt = FindIntersectionPoint( tabStrip[nPrevCrv1].OrigOffs2, tabStrip[nGeoCrv].OrigOffs2, EgtSP( nGeoCrv), true) - TrimStripSurf( ptInt, EgtSP( nCrvOffs1), nStripId, nSolidLayerId, true) - -- nPrev2 : essendo la precedente per le curve 2, devo ricavare l'intersezione sulle curve 1 - ptInt = FindIntersectionPoint( tabStrip[nPrevCrv2].OrigOffs1, tabStrip[nGeoCrv].OrigOffs1, EgtSP( nGeoCrv), true) - TrimStripSurf( EgtSP( nCrvOffs2), ptInt, nStripId, nSolidLayerId, true) + -- ci sono dei pezzi che scompaiono quindi vanno effettuati due tagli: uno per ricreare il bordo 2 dei pezzi che scompaiono e uno per + -- separare il pezzo corrente e il pezzo 1 + + -- a) recupero i pezzi che scompaiono + local nStartCrv = tabStrip[nPrevCrv1].Offs2 + nStartCrv = EgtGetNext( nStartCrv) or EgtGetFirstInGroup( EgtGetParent( nStartCrv)) + local vIds = {} + while nStartCrv ~= nCrvOffs2 do + table.insert( vIds, nStartCrv) + nStartCrv = EgtGetNext( nStartCrv) or EgtGetFirstInGroup( EgtGetParent( nStartCrv)) + end + local nCrvRef2 = EgtCurveCompo( nGrp, vIds, false) + -- taglio + TrimStripSurfByCurve( nCrvRef2, nStripId, nSolidLayerId) + + -- b) taglio che separa da pezzo 1 + TrimStripSurfByPoints( EgtCP( nCrvRef2), EgtSP( nCrvOffs1), nStripId, nSolidLayerId, true) + EgtErase( nCrvRef2) end -- b) trim end @@ -3752,32 +3925,25 @@ local function CalcAreaStrip( nGeoFillId) local nNextCrv2 = EgtGetInfo( nNext2, WIN_REF_GEO, 'i') if nNextCrv1 == nNextCrv2 then - -- devo tagliare con un solo pezzo - TrimStripSurf( EgtEP( nCrvOffs1), EgtEP( nCrvOffs2), nStripId, nSolidLayerId) + TrimStripSurfByPoints( EgtEP( nCrvOffs1), EgtEP( nCrvOffs2), nStripId, nSolidLayerId) else - -- devo tagliare con due pezzi - -- nNext1 - local ptInt = FindIntersectionPoint( tabStrip[nGeoCrv].OrigOffs2, tabStrip[nNextCrv1].OrigOffs2, EgtEP( nGeoCrv), true) - TrimStripSurf( EgtEP( nCrvOffs1), ptInt, nStripId, nSolidLayerId) - -- nNext2 - ptInt = FindIntersectionPoint( tabStrip[nGeoCrv].OrigOffs1, tabStrip[nNextCrv2].OrigOffs1, EgtEP( nGeoCrv), true) - TrimStripSurf( ptInt, EgtEP( nCrvOffs2), nStripId, nSolidLayerId) + local nStartCrv = nCrvOffs2 + nStartCrv = EgtGetNext( nStartCrv) or EgtGetFirstInGroup( EgtGetParent( nStartCrv)) + local vIds = {} + while nStartCrv ~= tabStrip[nNextCrv1].Offs2 do + table.insert( vIds, nStartCrv) + nStartCrv = EgtGetNext( nStartCrv) or EgtGetFirstInGroup( EgtGetParent( nStartCrv)) + end + local nCrvRef2 = EgtCurveCompo( nGrp, vIds, false) + TrimStripSurfByCurve( nCrvRef2, nStripId, nSolidLayerId) + + TrimStripSurfByPoints( EgtEP( nCrvOffs1), EgtCP( nCrvRef2), nStripId, nSolidLayerId) + EgtErase( nCrvRef2) end else - if nCrvOffs1 == -1 and nCrvOffs2 ~= -1 then - -- se la curva 1 scompare devo ricavare le intersezioni prev e next su di essa - local nPrevId = EgtGetPrev( nGeoCrv) or EgtGetLastInGroup( nGeoFillId) - local nNextId = EgtGetNext( nGeoCrv) or EgtGetFirstInGroup( nGeoFillId) - local ptIntPrev = FindIntersectionPoint( tabStrip[nPrevId].OrigOffs1, tabStrip[nGeoCrv].OrigOffs1, EgtSP( nGeoCrv), true) - local ptIntNext = FindIntersectionPoint( tabStrip[nGeoCrv].OrigOffs1, tabStrip[nNextId].OrigOffs1, EgtEP( nGeoCrv), true) - -- trim start ed end - TrimStripSurf( EgtSP( nCrvOffs2), ptIntPrev, nStripId, nSolidLayerId) - TrimStripSurf( ptIntNext, EgtEP( nCrvOffs2), nStripId, nSolidLayerId) - else - -- il fermavetro non serve - EgtErase( nStripId) - end + -- il pezzo scompare + EgtErase( nStripId) end end @@ -3786,6 +3952,8 @@ local function CalcAreaStrip( nGeoFillId) EgtErase( nGrp2) end + + ---------------------------------------------------------------------------------- ----------------------------- CALCOLO PEZZI ------------------------------------ ---------------------------------------------------------------------------------- @@ -4485,7 +4653,7 @@ local function CalcLogParts( nOrigPartId, bFinishedLogs) if #vCrvIn == 1 then -- essendo singolo pezzo il solido è quello originale local nOrigSolidId = EgtGetFirstNameInGroup( nOrigSolidLayerId, WIN_SRF_MAIN) - EgtRelocateGlob( nOrigSolidId, nSolidLayerId) + EgtCopyGlob( nOrigSolidId, nSolidLayerId) elseif bFinishedLogs then -- recupero il solido originale e lo taglio opportunamente agli estremi local nOrigSolidId = EgtGetFirstNameInGroup( nOrigSolidLayerId, WIN_SRF_MAIN) @@ -5007,8 +5175,7 @@ local function GetHandleHeight( nAreaId) end end - -- chiedo il file di opzioni dalla ferramenta. Se viene fatto solo il calcolo delle opzioni Hman viene lasciato a 0, per avere valore di default - -- è necessario fargli calcolare anche altro ( e.g. lista ferramenta) + -- chiedo il file di opzioni dalla ferramenta local _, _, tOptions = WinCalculate.AddHardware( nAreaId, false, false, false, true) if #tOptions > 0 then -- lettura della stringa xml delle opzioni @@ -5695,7 +5862,6 @@ function WinCalculate.AddHardware( nAreaId, bMachiningList, bHardwareList, bPosi return OutputKitList, OutputPositionList, OutputOptionList end - --------------------------------------------------------------------- -- funzione che disegna l'hardware local function DrawHardware( nAreaId, nAuxLayerId) @@ -5743,7 +5909,6 @@ local function DrawHardware( nAreaId, nAuxLayerId) end end - ---------------------------------------------------------------------------------- diff --git a/Designing/WinLib/WinCreate.lua b/Designing/WinLib/WinCreate.lua index 5c4d703..b61efcd 100644 --- a/Designing/WinLib/WinCreate.lua +++ b/Designing/WinLib/WinCreate.lua @@ -88,99 +88,120 @@ end ------------------------------------- TELAIO ------------------------------------- ---------------------------------------------------------------------------------- -- funzione che crea le curve che definiscono il telaio in base alla geometria richiesta -local function CreateFrameCurves( nLayerId, nType, dWidth, dHeight, dVal) - +local function CreateFrameCurves( nLayerId, nType, vDim) + -- rettangolo if nType == WIN_FRAME_TYPES.RECT then - -- telaio rettangolare - local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0)) + -- vDim[1] larghezza, vDim[2] altezza dei lati verticali + local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0)) EgtSetName( nBottomId, WIN_BOTTOM) - local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight, 0)) + local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0)) EgtSetName( nRightId, WIN_RIGHT) - local nTopId = EgtLine( nLayerId, Point3d( dWidth, dHeight, 0), Point3d( 0, dHeight, 0)) + local nTopId = EgtLine( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( 0, vDim[2], 0)) EgtSetName( nTopId, WIN_TOP) - local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG()) + local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG()) EgtSetName( nLeftId, WIN_LEFT) -- lato top inclinato elseif nType == WIN_FRAME_TYPES.CHAMFER_SIDE then - -- dHeight è l'altezza del lato sx, dVal è l'altezza del lato dx - local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0)) + -- vDim[1] larghezza, vDim[2] altezza del lato sx, vDim[3] altezza del lato dx + local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0)) EgtSetName( nBottomId, WIN_BOTTOM) - local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dVal, 0)) + local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[3], 0)) EgtSetName( nRightId, WIN_RIGHT) - local nTopId = EgtLine( nLayerId, Point3d( dWidth, dVal, 0), Point3d( 0, dHeight, 0)) + local nTopId = EgtLine( nLayerId, Point3d( vDim[1], vDim[3], 0), Point3d( 0, vDim[2], 0)) EgtSetName( nTopId, WIN_TOP) - local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG()) + local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG()) EgtSetName( nLeftId, WIN_LEFT) -- triangular arch elseif nType == WIN_FRAME_TYPES.CHAMFER then - -- dHeight è l'altezza dei lati verticali, dVal è l'altezza complessiva della finestra - local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0)) + -- vDim[1] larghezza, vDim[2] altezza dei lati verticali, vDim[3] altezza complessiva + local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0)) EgtSetName( nBottomId, WIN_BOTTOM) - local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight, 0)) + local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0)) EgtSetName( nRightId, WIN_RIGHT) - local nTop1Id = EgtLine( nLayerId, Point3d( dWidth, dHeight, 0), Point3d( dWidth / 2, dVal, 0)) - local nTop2Id = EgtLine( nLayerId, Point3d( dWidth / 2, dVal, 0), Point3d( 0, dHeight, 0)) + local nTop1Id = EgtLine( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( vDim[1] / 2, vDim[3], 0)) + local nTop2Id = EgtLine( nLayerId, Point3d( vDim[1] / 2, vDim[3], 0), Point3d( 0, vDim[2], 0)) EgtSetName( nTop1Id, WIN_TOP) EgtSetName( nTop2Id, WIN_TOP) - local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG()) + local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG()) EgtSetName( nLeftId, WIN_LEFT) -- arco a tutto sesto elseif nType == WIN_FRAME_TYPES.ROUND_ARC then - local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0)) + -- vDim[1] larghezza, vDim[2] altezza complessiva + local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0)) EgtSetName( nBottomId, WIN_BOTTOM) - local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight - 0.5 * dWidth, 0)) + local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2] - 0.5 * vDim[1], 0)) EgtSetName( nRightId, WIN_RIGHT) - local nTopId = EgtArcCPA( nLayerId, Point3d( 0.5 * dWidth, dHeight - 0.5 * dWidth, 0), Point3d( dWidth, dHeight - 0.5 * dWidth, 0), 180, 0) + local nTopId = EgtArcCPA( nLayerId, Point3d( 0.5 * vDim[1], vDim[2] - 0.5 * vDim[1], 0), Point3d( vDim[1], vDim[2] - 0.5 * vDim[1], 0), 180, 0) EgtSetName( nTopId, WIN_TOP) - local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight - 0.5 * dWidth, 0), ORIG()) + local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2] - 0.5 * vDim[1], 0), ORIG()) EgtSetName( nLeftId, WIN_LEFT) -- arco ribassato elseif nType == WIN_FRAME_TYPES.SEGMENTAL_ARC then - -- dHeight è l'altezza dei lati verticali, dVal è l'altezza complessiva della finestra - local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0)) + -- vDim[1] larghezza, vDim[2] altezza dei lati verticali, vDim[3] altezza complessiva + local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0)) EgtSetName( nBottomId, WIN_BOTTOM) - local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight, 0)) + local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0)) EgtSetName( nRightId, WIN_RIGHT) - local nTopId = EgtArc3P( nLayerId, Point3d( dWidth, dHeight, 0), Point3d( 0.5 * dWidth, dVal, 0), Point3d( 0, dHeight, 0)) + local nTopId = EgtArc3P( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( 0.5 * vDim[1], vDim[3], 0), Point3d( 0, vDim[2], 0)) EgtSetName( nTopId, WIN_TOP) - local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG()) + local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG()) EgtSetName( nLeftId, WIN_LEFT) - - -- arco a tutto sesto + + -- arco a 3 centri + elseif nType == WIN_FRAME_TYPES.THREE_CENTERED_ARC then + -- vDim[1] larghezza, vDim[2] altezza dei lati verticali, vDim[3] altezza complessiva, vDim[4] raggio di raccordo + local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0)) + EgtSetName( nBottomId, WIN_BOTTOM) + local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0)) + EgtSetName( nRightId, WIN_RIGHT) + local nTopId = EgtArc3P( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( 0.5 * vDim[1], vDim[3], 0), Point3d( 0, vDim[2], 0)) + EgtSetName( nTopId, WIN_TOP) + local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG()) + EgtSetName( nLeftId, WIN_LEFT) + + local nFillet1 = EgtCurveFillet( nLayerId, nRightId, EgtUP( nRightId, 0.9), nTopId, EgtUP( nTopId, 0.1), vDim[4], true) + EgtRelocateGlob( nFillet1, nTopId, GDB_IN.BEFORE) + EgtSetName( nFillet1, WIN_TOP) + local nFillet2 = EgtCurveFillet( nLayerId, nTopId, EgtUP( nTopId, 0.9), nLeftId, EgtUP( nLeftId, 0.1), vDim[4], true) + EgtRelocateGlob( nFillet2, nTopId, GDB_IN.AFTER) + EgtSetName( nFillet2, WIN_TOP) + + -- arco a sesto acuto elseif nType == WIN_FRAME_TYPES.POINTED_ARC then - -- dHeight è l'altezza dei lati verticali, dVal è l'altezza complessiva della finestra + -- vDim[1] larghezza, vDim[2] altezza dei lati verticali, vDim[3] altezza complessiva -- verifico che le due altezze abbiano valori sensati per realizzare i due archi - if dVal - dHeight < 0.5 * dWidth then + if vDim[3] - vDim[2] < 0.5 * vDim[1] then return end - local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0)) + local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0)) EgtSetName( nBottomId, WIN_BOTTOM) - local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight, 0)) + local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0)) EgtSetName( nRightId, WIN_RIGHT) - local nTop1Id = EgtArc2PV( nLayerId, Point3d( dWidth, dHeight, 0), Point3d( 0.5 * dWidth, dVal, 0), Y_AX()) + local nTop1Id = EgtArc2PV( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( 0.5 * vDim[1], vDim[3], 0), Y_AX()) EgtSetName( nTop1Id, WIN_TOP) - local nTop2Id = EgtArc2PV( nLayerId, Point3d( 0, dHeight, 0), Point3d( 0.5 * dWidth, dVal, 0), Y_AX()) + local nTop2Id = EgtArc2PV( nLayerId, Point3d( 0, vDim[2], 0), Point3d( 0.5 * vDim[1], vDim[3], 0), Y_AX()) EgtInvertCurve( nTop2Id) EgtSetName( nTop2Id, WIN_TOP) - local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG()) + local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG()) EgtSetName( nLeftId, WIN_LEFT) -- triangolo elseif nType == WIN_FRAME_TYPES.TRG then - local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0)) + -- vDim[1] larghezza, vDim[2] altezza complessiva, vDim[3] proiezione del lato left sul bottom + local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0)) EgtSetName( nBottomId, WIN_BOTTOM) - local nEdge1Id = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dVal, dHeight, 0)) - local nEdge2Id = EgtLine( nLayerId, Point3d( dVal, dHeight, 0), ORIG()) + local nEdge1Id = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[3], vDim[2], 0)) + local nEdge2Id = EgtLine( nLayerId, Point3d( vDim[3], vDim[2], 0), ORIG()) -- un lato verticale è right/left, un lato inclinato è top - if dVal < GEO.EPS_SMALL then + if vDim[3] < GEO.EPS_SMALL then EgtSetName( nEdge1Id, WIN_TOP) EgtSetName( nEdge2Id, WIN_LEFT) - elseif abs( dVal - dWidth) < GEO.EPS_SMALL then + elseif abs( vDim[3] - vDim[1]) < GEO.EPS_SMALL then EgtSetName( nEdge1Id, WIN_RIGHT) EgtSetName( nEdge2Id, WIN_TOP) else @@ -192,7 +213,7 @@ end ---------------------------------------------------------------------------------- -- funzione che crea il telaio a partire da una specifica geometria ( rettangolo, chamfer...) -function WinCreate.CreateFrame( nType, vJoints, dWidth, dHeight, dHeight2, nAreaNbr) +function WinCreate.CreateFrame( nType, vJoints, vDimensions, nAreaNbr) -- creo gruppo per telaio local nAreaId = EgtGroup( GDB_ID.ROOT) @@ -204,7 +225,7 @@ function WinCreate.CreateFrame( nType, vJoints, dWidth, dHeight, dHeight2, nArea -- costruisco le curve di outline local nOutlineLayerId = EgtGroup( nAreaId) EgtSetName( nOutlineLayerId, WIN_AREAOUTLINE) - CreateFrameCurves( nOutlineLayerId, nType, dWidth, dHeight, dHeight2) + CreateFrameCurves( nOutlineLayerId, nType, vDimensions) EgtSetInfo( nAreaId, WIN_FRAME_TYPE, nType) -- imposto tipo giunzioni EgtSetInfo( nOutlineLayerId, WIN_JOINTS, vJoints) @@ -403,11 +424,11 @@ local function AdjustSplitCurve( nSplitId, nCompo, vOutlineCrvs, nOutlineLayerId -- recupero le curve con cui avviene l'intersezione e le salvo come info -- start local dParCrvS = EgtCurveParamAtPoint( nCompo, ptS) - if abs( dParCrvS - ceil( dParCrvS)) < GEO.EPS_SMALL then + if abs( dParCrvS - ceil( dParCrvS)) < GEO.EPS_ZERO then local nCrv = vOutlineCrvs[ ceil( dParCrvS) + 1] local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId) EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, { nOther, nCrv}) - elseif abs( dParCrvS - floor( dParCrvS)) < GEO.EPS_SMALL then + elseif abs( dParCrvS - floor( dParCrvS)) < GEO.EPS_ZERO then local nCrv = vOutlineCrvs[ floor( dParCrvS) + 1] local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId) EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, { nOther, nCrv}) @@ -419,11 +440,11 @@ local function AdjustSplitCurve( nSplitId, nCompo, vOutlineCrvs, nOutlineLayerId -- end local dParCrvE = EgtCurveParamAtPoint( nCompo, ptE) - if abs( dParCrvE - ceil( dParCrvE)) < GEO.EPS_SMALL then + if abs( dParCrvE - ceil( dParCrvE)) < GEO.EPS_ZERO then local nCrv = vOutlineCrvs[ ceil( dParCrvE) + 1] local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId) EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, { nOther, nCrv}) - elseif abs( dParCrvE - floor( dParCrvE)) < GEO.EPS_SMALL then + elseif abs( dParCrvE - floor( dParCrvE)) < GEO.EPS_ZERO then local nCrv = vOutlineCrvs[ floor( dParCrvE) + 1] local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId) EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, { nOther, nCrv}) diff --git a/Designing/WinLib/WinManageProject.lua b/Designing/WinLib/WinManageProject.lua index a8975c6..6f89aa4 100644 --- a/Designing/WinLib/WinManageProject.lua +++ b/Designing/WinLib/WinManageProject.lua @@ -179,7 +179,7 @@ local function ConvertTableToGeometry( AreaTable, nParentId) end -- creo il telaio - local nAreaId = WinCreate.CreateFrame( nType, vJoints, vDim[1], vDim[2], vDim[3], nAreaNbr) + local nAreaId = WinCreate.CreateFrame( nType, vJoints, vDim, nAreaNbr) -- verifico presenza bottomrail if AreaTable[JWD_BOTTOMRAIL] then diff --git a/Designing/WinProject.lua b/Designing/WinProject.lua index dd14b5e..542bea3 100644 --- a/Designing/WinProject.lua +++ b/Designing/WinProject.lua @@ -158,8 +158,10 @@ _G.GetProfileThresholdsList = GetProfileThresholdsList ---------------------------------------------------------------------------------- local function WinCreate_CreateFrame() local JointList = GetVariableList( 'JOINT') - WDG.AREAID = WinCreate.CreateFrame( WDG.FRAMETYPE, JointList, WDG.WIDTH, WDG.HEIGHT, WDG.HEIGHT2, WDG.AREANBR) + local DimensionList = GetVariableList( 'DIMENSION') + WDG.AREAID = WinCreate.CreateFrame( WDG.FRAMETYPE, JointList, DimensionList, WDG.AREANBR) CleanVariableList('JOINT') + CleanVariableList('DIMENSION') end _G.WinCreate_CreateFrame = WinCreate_CreateFrame