?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix #104036: Copy Attributes does not work on faces
[blender-addons.git] / archimesh / achm_window_panel.py
blob738fbaa55818489ed5b594d2456265d2e2e48266
1 # SPDX-License-Identifier: GPL-2.0-or-later
2
3 # ----------------------------------------------------------
4 # Main panel for windows
5 # Author: Antonio Vazquez (antonioya)
6 #
7 # This code is base on the windows generator add-on created by SayProduction
8 # and has been adapted to continuous editing and cycles materials
9 #
10 # ----------------------------------------------------------
11 # noinspection PyUnresolvedReferences
12 import bpy
13 from math import cos, sin, radians, sqrt, pi
14 from mathutils import Vector
15 from bpy.types import Operator, PropertyGroup, Object, Panel
16 from bpy.props import StringProperty, FloatProperty, BoolProperty, IntProperty, FloatVectorProperty, \
17 CollectionProperty, EnumProperty
18 from .achm_tools import *
19
20
21 def fitil(vr, fc, px, pz, x, y, z, zz, xx):
22 k3 = z * 2
23 vr.extend([[px[x] + xx, -z + zz, pz[y] + xx], [px[x] + xx + k3, -z + zz, pz[y] + xx + k3],
24 [px[x] + xx + k3, z + zz, pz[y] + xx + k3], [px[x] + xx, z + zz, pz[y] + xx]])
25 vr.extend([[px[x] + xx, -z + zz, pz[y + 1] - xx], [px[x] + xx + k3, -z + zz, pz[y + 1] - xx - k3],
26 [px[x] + xx + k3, z + zz, pz[y + 1] - xx - k3], [px[x] + xx, z + zz, pz[y + 1] - xx]])
27 vr.extend([[px[x + 1] - xx, -z + zz, pz[y + 1] - xx], [px[x + 1] - xx - k3, -z + zz, pz[y + 1] - xx - k3],
28 [px[x + 1] - xx - k3, z + zz, pz[y + 1] - xx - k3], [px[x + 1] - xx, z + zz, pz[y + 1] - xx]])
29 vr.extend([[px[x + 1] - xx, -z + zz, pz[y] + xx], [px[x + 1] - xx - k3, -z + zz, pz[y] + xx + k3],
30 [px[x + 1] - xx - k3, z + zz, pz[y] + xx + k3], [px[x + 1] - xx, z + zz, pz[y] + xx]])
31 n = len(vr)
32 fc.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11], [n - 14, n - 13, n - 9, n - 10]])
33 fc.extend([[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5, n - 6]])
34 fc.extend([[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2]])
35 fc.extend([[n - 4, n - 3, n - 15, n - 16], [n - 3, n - 2, n - 14, n - 15], [n - 2, n - 1, n - 13, n - 14]])
36 z = 0.005
37 vr.extend([[px[x] + xx + k3, -z + zz, pz[y] + xx + k3], [px[x] + xx + k3, -z + zz, pz[y + 1] - xx - k3],
38 [px[x + 1] - xx - k3, -z + zz, pz[y + 1] - xx - k3], [px[x + 1] - xx - k3, -z + zz, pz[y] + xx + k3]])
39 vr.extend([[px[x] + xx + k3, z + zz, pz[y] + xx + k3], [px[x] + xx + k3, z + zz, pz[y + 1] - xx - k3],
40 [px[x + 1] - xx - k3, z + zz, pz[y + 1] - xx - k3], [px[x + 1] - xx - k3, z + zz, pz[y] + xx + k3]])
41 fc.extend([[n + 1, n + 0, n + 3, n + 2], [n + 4, n + 5, n + 6, n + 7]])
42
43
44 def kapak(vr, fc, px, pz, x, y, z, zz):
45 k2 = z * 2
46 vr.extend(
47 [[px[x], -z + zz, pz[y]], [px[x] + k2, -z + zz, pz[y] + k2], [px[x] + k2, z + zz, pz[y] + k2],
48 [px[x], z + zz, pz[y]]])
49 vr.extend([[px[x], -z + zz, pz[y + 1]], [px[x] + k2, -z + zz, pz[y + 1] - k2], [px[x] + k2, z + zz, pz[y + 1] - k2],
50 [px[x], z + zz, pz[y + 1]]])
51 vr.extend(
52 [[px[x + 1], -z + zz, pz[y + 1]], [px[x + 1] - k2, -z + zz, pz[y + 1] - k2],
53 [px[x + 1] - k2, z + zz, pz[y + 1] - k2],
54 [px[x + 1], z + zz, pz[y + 1]]])
55 vr.extend([[px[x + 1], -z + zz, pz[y]], [px[x + 1] - k2, -z + zz, pz[y] + k2], [px[x + 1] - k2, z + zz, pz[y] + k2],
56 [px[x + 1], z + zz, pz[y]]])
57 n = len(vr)
58 fc.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11], [n - 14, n - 13, n - 9, n - 10],
59 [n - 13, n - 16, n - 12, n - 9]])
60 fc.extend([[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5, n - 6],
61 [n - 9, n - 12, n - 8, n - 5]])
62 fc.extend([[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2],
63 [n - 5, n - 8, n - 4, n - 1]])
64 fc.extend([[n - 4, n - 3, n - 15, n - 16], [n - 3, n - 2, n - 14, n - 15], [n - 2, n - 1, n - 13, n - 14],
65 [n - 1, n - 4, n - 16, n - 13]])
66
67
68 # -----------------------------------------
69 # Set default values for each window type
70 # -----------------------------------------
71 def set_defaults(s):
72 if s.prs == '1':
73 s.gen = 3
74 s.yuk = 1
75 s.kl1 = 5
76 s.kl2 = 5
77 s.fk = 2
78 s.gny0 = 190
79 s.mr = True
80 s.gnx0 = 60
81 s.gnx1 = 110
82 s.gnx2 = 60
83 s.k00 = True
84 s.k01 = False
85 s.k02 = True
86 if s.prs == '2':
87 s.gen = 3
88 s.yuk = 1
89 s.kl1 = 5
90 s.kl2 = 5
91 s.fk = 2
92 s.gny0 = 190
93 s.mr = True
94 s.gnx0 = 60
95 s.gnx1 = 60
96 s.gnx2 = 60
97 s.k00 = True
98 s.k01 = False
99 s.k02 = True
100 if s.prs == '3':
101 s.gen = 3
102 s.yuk = 1
103 s.kl1 = 5
104 s.kl2 = 5
105 s.fk = 2
106 s.gny0 = 190
107 s.mr = True
108 s.gnx0 = 55
109 s.gnx1 = 50
110 s.gnx2 = 55
111 s.k00 = True
112 s.k01 = False
113 s.k02 = True
114 if s.prs == '4':
115 s.gen = 3
116 s.yuk = 1
117 s.kl1 = 5
118 s.kl2 = 5
119 s.fk = 2
120 s.gny0 = 150
121 s.mr = True
122 s.gnx0 = 55
123 s.gnx1 = 50
124 s.gnx2 = 55
125 s.k00 = True
126 s.k01 = False
127 s.k02 = True
128 if s.prs == '5':
129 s.gen = 3
130 s.yuk = 1
131 s.kl1 = 5
132 s.kl2 = 5
133 s.fk = 2
134 s.gny0 = 150
135 s.mr = True
136 s.gnx0 = 50
137 s.gnx1 = 40
138 s.gnx2 = 50
139 s.k00 = True
140 s.k01 = False
141 s.k02 = True
142 if s.prs == '6':
143 s.gen = 1
144 s.yuk = 1
145 s.kl1 = 5
146 s.kl2 = 5
147 s.fk = 2
148 s.gny0 = 40
149 s.mr = True
150 s.gnx0 = 40
151 s.k00 = False
152 if s.prs == '7':
153 s.gen = 1
154 s.yuk = 2
155 s.kl1 = 5
156 s.kl2 = 5
157 s.fk = 2
158 s.gny0 = 195
159 s.gny1 = 40
160 s.gnx0 = 70
161 s.k00 = True
162 s.k10 = False
163 s.mr = False
164 if s.prs == '8':
165 s.gen = 1
166 s.yuk = 2
167 s.kl1 = 5
168 s.kl2 = 5
169 s.fk = 2
170 s.gny0 = 180
171 s.gny1 = 35
172 s.gnx0 = 70
173 s.k00 = True
174 s.k10 = False
175 s.mr = False
176
177
178 # ------------------------------------------------------------------
179 # Define operator class to create window panels
180 # ------------------------------------------------------------------
181 class ARCHIMESH_PT_Win(Operator):
182 bl_idname = "mesh.archimesh_winpanel"
183 bl_label = "Panel Window"
184 bl_description = "Generate editable flat windows"
185 bl_category = 'View'
186 bl_options = {'REGISTER', 'UNDO'}
187
188 # -----------------------------------------------------
189 # Draw (create UI interface)
190 # -----------------------------------------------------
191 # noinspection PyUnusedLocal
192 def draw(self, context):
193 layout = self.layout
194 row = layout.row()
195 row.label(text="Use Properties panel (N) to define parms", icon='INFO')
196
197 # -----------------------------------------------------
198 # Execute
199 # -----------------------------------------------------
200 # noinspection PyUnusedLocal
201 def execute(self, context):
202 if bpy.context.mode == "OBJECT":
203 create_window()
204 return {'FINISHED'}
205 else:
206 self.report({'WARNING'}, "Archimesh: Option only valid in Object mode")
207 return {'CANCELLED'}
208
209
210 # ------------------------------------------------------------------------------
211 # Create the window
212 # ------------------------------------------------------------------------------
213 def create_window():
214 # deselect all objects
215 for o in bpy.data.objects:
216 o.select_set(False)
217 # Create main object
218 window_mesh = bpy.data.meshes.new("Window")
219 window_object = bpy.data.objects.new("Window", window_mesh)
220
221 # Link object to scene
222 bpy.context.collection.objects.link(window_object)
223 window_object.WindowPanelGenerator.add()
224 window_object.location = bpy.context.scene.cursor.location
225
226 # Shape the mesh.
227 do_mesh(window_object, window_mesh)
228
229 # deactivate others
230 for o in bpy.data.objects:
231 if o.select_get() is True and o.name != window_object.name:
232 o.select_set(False)
233
234 # Select, and activate object
235 window_object.select_set(True)
236 bpy.context.view_layer.objects.active = window_object
237
238 do_ctrl_box(window_object)
239 # Reselect
240 window_object.select_set(True)
241 bpy.context.view_layer.objects.active = window_object
242
243
244 # ------------------------------------------------------------------------------
245 # Update mesh of the window
246 # ------------------------------------------------------------------------------
247 # noinspection PyUnusedLocal
248 def update_window(self, context):
249 # When update, the active object is the main object.
250 o = bpy.context.active_object
251 oldmesh = o.data
252 oldname = o.data.name
253 # Now deselect that object to not delete it.
254 o.select_set(False)
255 # # and create a new mesh for the object:
256 # tmp_mesh = bpy.data.meshes.new("temp")
257 # deselect all objects
258 for obj in bpy.data.objects:
259 obj.select_set(False)
260 # ---------------------------------
261 # Clear Parent objects (autohole)
262 # ---------------------------------
263 myparent = o.parent
264 if myparent is not None:
265 ploc = myparent.location
266 else:
267 ploc = o.location
268 if myparent is not None:
269 o.parent = None
270 o.location = ploc
271 # remove_children(parent)
272 for child in myparent.children:
273 # noinspection PyBroadException
274 try:
275 # clear child data
276 child.hide_viewport = False # must be visible to avoid bug
277 child.hide_render = False # must be visible to avoid bug
278 old = child.data
279 child.select_set(True)
280 bpy.ops.object.delete()
281 bpy.data.meshes.remove(old)
282 except:
283 pass
284
285 myparent.select_set(True)
286 bpy.ops.object.delete()
287
288 # Finally create all that again
289 tmp_mesh = bpy.data.meshes.new("temp")
290 do_mesh(o, tmp_mesh, True)
291 o.data = tmp_mesh
292 # Remove data (mesh of active object),
293 if oldmesh.users == 0:
294 bpy.data.meshes.remove(oldmesh)
295 else:
296 oldmesh.name = "invalid"
297
298 tmp_mesh.name = oldname
299 # deactivate others
300 for ob in bpy.data.objects:
301 if ob.select_get() is True and ob.name != o.name:
302 ob.select_set(False)
303 # and select, and activate, the object.
304 o.select_set(True)
305 bpy.context.view_layer.objects.active = o
306
307 do_ctrl_box(o)
308
309 # Reselect
310 o.select_set(True)
311 bpy.context.view_layer.objects.active = o
312
313
314 # ------------------------------------------------------------------------------
315 # Generate object
316 # For object, it only shapes mesh
317 # ------------------------------------------------------------------------------
318 # noinspection PyUnusedLocal
319 def do_mesh(myobject, tmp_mesh, update=False):
320 # noinspection PyBroadException
321 try:
322 op = myobject.WindowPanelGenerator[0]
323 # Create only mesh, because the object was created before.
324 r = generate_window_object(op, tmp_mesh)
325 if r is False:
326 return False
327
328 # refine unit
329 remove_doubles(myobject)
330 set_normals(myobject)
331
332 # saves OpenGL data
333 # sum width
334 totx = myobject.dimensions.x
335 op.glpoint_a = (-totx / 2, 0, 0)
336 top_a, top_b, top_c = get_high_points(myobject, totx, op.UST)
337 op.glpoint_b = (-totx / 2, 0, top_a)
338 op.glpoint_c = (totx / 2, 0, top_b)
339 op.glpoint_d = (0, 0, top_c)
340
341 # Lock
342 myobject.lock_location = (True, True, True)
343 myobject.lock_rotation = (True, True, True)
344 return True
345 except:
346 return False
347
348
349 # ------------------------------------------------------------------------------
350 # Generate ctrl box
351 #
352 # ------------------------------------------------------------------------------
353 # noinspection PyUnusedLocal
354 def do_ctrl_box(myobject):
355 op = myobject.WindowPanelGenerator[0]
356 # -------------------------
357 # Create empty and parent
358 # -------------------------
359 bpy.ops.object.empty_add(type='PLAIN_AXES')
360 myempty = bpy.data.objects[bpy.context.active_object.name]
361 myempty.location = myobject.location
362
363 myempty.name = "Window_Group"
364 parentobject(myempty, myobject)
365 myobject["archimesh.hole_enable"] = True
366 # Rotate Empty
367 myempty.rotation_euler.z = radians(op.r)
368 # Create control box to open wall holes
369 myctrl = create_ctrl_box(myobject, "CTRL_Hole")
370
371 # Add custom property to detect Controller
372 myctrl["archimesh.ctrl_hole"] = True
373
374 set_normals(myctrl)
375 myctrl.parent = myempty
376 myctrl.location.x = 0
377 myctrl.location.y = 0
378 myctrl.location.z = 0
379 myctrl.display_type = 'WIRE'
380 myctrl.hide_viewport = False
381 myctrl.hide_render = True
382 if bpy.context.scene.render.engine in {'CYCLES', 'BLENDER_EEVEE'}:
383 myctrl.visible_camera = False
384 myctrl.visible_diffuse = False
385 myctrl.visible_glossy = False
386 myctrl.visible_transmission = False
387 myctrl.visible_shadow = False
388
389 mat = create_transparent_material("hidden_material", False)
390 set_material(myctrl, mat)
391
392
393 # ------------------------------------------------------------------------------
394 # Update the parameters using a default value
395 # ------------------------------------------------------------------------------
396 # noinspection PyUnusedLocal
397 def update_using_default(self, context):
398 o = context.object
399 myobject = o.WindowPanelGenerator[0]
400 if myobject.son != myobject.prs:
401 set_defaults(myobject)
402 myobject.son = myobject.prs
403
404
405 # ------------------------------------------------------------------------------
406 # Generate window object
407 # ------------------------------------------------------------------------------
408 def generate_window_object(op, mymesh):
409 myvertex = []
410 mfaces = []
411 # noinspection PyBroadException
412 try:
413 rst, ft1, cam, mer, sm = generate_vertex_data(op, myvertex, mfaces)
414 if rst is not True:
415 return False
416
417 mymesh.from_pydata(myvertex, [], mfaces)
418 # Uncomment for debug
419 # mymesh.validate(verbose=True)
420 # Assign materials
421 if op.mt1 == '1':
422 mymesh.materials.append(create_diffuse_material("PVC", False, 1, 1, 1, 1, 1, 1))
423 elif op.mt1 == '2':
424 mymesh.materials.append(create_diffuse_material("Wood", False, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1))
425 elif op.mt1 == '3':
426 mymesh.materials.append(create_diffuse_material("Plastic", False, 0, 0, 0, 0, 0, 0))
427 if op.mt2 == '1':
428 mymesh.materials.append(create_diffuse_material("PVC", False, 1, 1, 1, 1, 1, 1))
429 elif op.mt2 == '2':
430 mymesh.materials.append(create_diffuse_material("Wood", False, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1))
431 elif op.mt2 == '3':
432 mymesh.materials.append(create_diffuse_material("Plastic", False, 0, 0, 0, 0, 0, 0))
433
434 mymesh.materials.append(create_glass_material("Glass", False))
435 if op.mr is True:
436 mymesh.materials.append(create_diffuse_material("Marble", False, 0.9, 0.8, 0.7, 0.9, 0.8, 0.7))
437
438 p = len(mymesh.polygons)
439 for i in ft1:
440 if -1 < i < p:
441 mymesh.polygons[i].material_index = 1
442 for i in cam:
443 if -1 < i < p:
444 mymesh.polygons[i].material_index = 2
445 for i in mer:
446 if -1 < i < p:
447 mymesh.polygons[i].material_index = 3
448 for i in sm:
449 if -1 < i < p:
450 mymesh.polygons[i].use_smooth = 1
451
452 mymesh.update(calc_edges=True)
453
454 return True
455 except:
456 return False
457
458
459 # -----------------------------------------
460 # Generate vertex and faces data
461 # -----------------------------------------
462 def generate_vertex_data(op, myvertex, myfaces):
463 # noinspection PyBroadException
464 try:
465 h1 = 0
466 c = 0
467 t1 = 0
468
469 mx = op.gen
470 my = op.yuk
471 k1 = op.kl1 / 100
472 k2 = op.kl2 / 100
473 k3 = op.fk / 200
474 res = op.res
475
476 u = op.kl1 / 100
477 xlist = [0, round(u, 2)]
478 if mx > 0:
479 u += op.gnx0 / 100
480 xlist.append(round(u, 2))
481 u += k2
482 xlist.append(round(u, 2))
483 if mx > 1:
484 u += op.gnx1 / 100
485 xlist.append(round(u, 2))
486 u += k2
487 xlist.append(round(u, 2))
488 if mx > 2:
489 u += op.gnx2 / 100
490 xlist.append(round(u, 2))
491 u += k2
492 xlist.append(round(u, 2))
493 if mx > 3:
494 u += op.gnx3 / 100
495 xlist.append(round(u, 2))
496 u += k2
497 xlist.append(round(u, 2))
498 if mx > 4:
499 u += op.gnx4 / 100
500 xlist.append(round(u, 2))
501 u += k2
502 xlist.append(round(u, 2))
503 if mx > 5:
504 u += op.gnx5 / 100
505 xlist.append(round(u, 2))
506 u += k2
507 xlist.append(round(u, 2))
508 if mx > 6:
509 u += op.gnx6 / 100
510 xlist.append(round(u, 2))
511 u += k2
512 xlist.append(round(u, 2))
513 if mx > 7:
514 u += op.gnx7 / 100
515 xlist.append(round(u, 2))
516 u += k2
517 xlist.append(round(u, 2))
518
519 xlist[-1] = xlist[-2] + k1
520
521 u = op.kl1 / 100
522 zlist = [0, round(u, 2)]
523 if my > 0:
524 u += op.gny0 / 100
525 zlist.append(round(u, 2))
526 u += k2
527 zlist.append(round(u, 2))
528 if my > 1:
529 u += op.gny1 / 100
530 zlist.append(round(u, 2))
531 u += k2
532 zlist.append(round(u, 2))
533 if my > 2:
534 u += op.gny2 / 100
535 zlist.append(round(u, 2))
536 u += k2
537 zlist.append(round(u, 2))
538 if my > 3:
539 u += op.gny3 / 100
540 zlist.append(round(u, 2))
541 u += k2
542 zlist.append(round(u, 2))
543 if my > 4:
544 u += op.gny4 / 100
545 zlist.append(round(u, 2))
546 u += k2
547 zlist.append(round(u, 2))
548 zlist[-1] = zlist[-2] + k1
549
550 u = xlist[-1] / 2
551 for i in range(0, len(xlist)):
552 xlist[i] -= u
553 kx = [[op.k00, op.k10, op.k20, op.k30, op.k40],
554 [op.k01, op.k11, op.k21, op.k31, op.k41],
555 [op.k02, op.k12, op.k22, op.k32, op.k42],
556 [op.k03, op.k13, op.k23, op.k33, op.k43],
557 [op.k04, op.k14, op.k24, op.k34, op.k44],
558 [op.k05, op.k15, op.k25, op.k35, op.k45],
559 [op.k06, op.k16, op.k26, op.k36, op.k46],
560 [op.k07, op.k17, op.k27, op.k37, op.k47]]
561 cam = []
562 mer = []
563 ftl = []
564 sm = []
565 # -------------------------
566 # VERTICES
567 # -------------------------
568 myvertex.extend([[xlist[0], -k1 / 2, zlist[0]], [xlist[0], k1 / 2, zlist[0]]])
569 for x in range(1, len(xlist) - 1):
570 myvertex.extend([[xlist[x], -k1 / 2, zlist[1]], [xlist[x], k1 / 2, zlist[1]]])
571 myvertex.extend([[xlist[-1], -k1 / 2, zlist[0]], [xlist[-1], k1 / 2, zlist[0]]])
572 for z in range(2, len(zlist) - 2, 2):
573 for x in range(0, len(xlist)):
574 myvertex.extend([[xlist[x], -k1 / 2, zlist[z]], [xlist[x], k1 / 2, zlist[z]]])
575 for x in range(0, len(xlist)):
576 myvertex.extend([[xlist[x], -k1 / 2, zlist[z + 1]], [xlist[x], k1 / 2, zlist[z + 1]]])
577 z = len(zlist) - 2
578 myvertex.extend([[xlist[0], -k1 / 2, zlist[z + 1]], [xlist[0], k1 / 2, zlist[z + 1]]])
579 alt = []
580 ust = [len(myvertex) - 2, len(myvertex) - 1]
581 for x in range(1, len(xlist) - 1):
582 myvertex.extend([[xlist[x], -k1 / 2, zlist[z]], [xlist[x], k1 / 2, zlist[z]]])
583 alt.extend([len(myvertex) - 2, len(myvertex) - 1])
584 myvertex.extend([[xlist[-1], -k1 / 2, zlist[z + 1]], [xlist[-1], k1 / 2, zlist[z + 1]]])
585 son = [len(myvertex) - 2, len(myvertex) - 1]
586 # -------------------------
587 # FACES
588 # -------------------------
589 myfaces.append([0, 1, 3 + mx * 4, 2 + mx * 4])
590 fb = [0]
591 fr = [1]
592 for i in range(0, mx * 4, 4):
593 myfaces.append([i + 3, i + 2, i + 4, i + 5])
594 fb.extend([i + 2, i + 4])
595 fr.extend([i + 3, i + 5])
596 fr.append(3 + mx * 4)
597 fb.append(2 + mx * 4)
598 fb.reverse()
599 myfaces.extend([fb, fr])
600 # Yatay
601 y = (mx * 4 + 4)
602 v = mx * 4 + 2
603 for z in range(0, (my - 1) * y * 2, y * 2):
604 myfaces.extend([[z + y + 1, z + y, z + y + 4 + mx * 4, z + y + 5 + mx * 4],
605 [z + y + v, z + y + v + 1, z + y + v + 5 + mx * 4, z + y + v + 4 + mx * 4]])
606 for i in range(0, mx * 4 + 2, 2):
607 myfaces.extend([[z + i + y + 0, z + i + y + 2, z + i + y + v + 4, z + i + y + v + 2],
608 [z + i + y + 3, z + i + y + 1, z + i + y + v + 3, z + i + y + v + 5]])
609 for i in range(0, mx * 4 - 3, 4):
610 myfaces.extend([[z + i + y + 2, z + i + y + 3, z + i + y + 5, z + i + y + 4],
611 [z + i + y + v + 5, z + i + y + v + 4, z + i + y + v + 6,
612 z + i + y + v + 7]])
613 # Dikey
614 for y in range(0, my):
615 z = y * (mx * 4 + 4) * 2
616 for i in range(0, mx * 4 + 2, 4):
617 myfaces.extend([[z + i + 1, z + i + 0, z + i + v + 2, z + i + v + 3],
618 [z + i + 3, z + i + 1, z + i + v + 3, z + i + v + 5],
619 [z + i + 2, z + i + 3, z + i + v + 5, z + i + v + 4],
620 [z + i + 0, z + i + 2, z + i + v + 4, z + i + v + 2]])
621 # Fitil
622 if op.UST == '1':
623 y1 = my
624 else:
625 y1 = my - 1
626 for y in range(0, y1):
627 for x in range(0, mx):
628 if kx[x][y] is True:
629 kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
630 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
631 else:
632 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
633 m = len(myfaces)
634 cam.extend([m - 1, m - 2])
635 ftl.extend([m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10, m - 11, m - 12, m - 13, m - 14])
636 # -----------------------------------------------------
637 if op.UST == '1': # Duz
638 myfaces.append([ust[1], ust[0], son[0], son[1]])
639 for i in range(0, mx * 4, 4):
640 myfaces.append([alt[i], alt[i + 1], alt[i + 3], alt[i + 2]])
641 on = [ust[0]]
642 ar = [ust[1]]
643 for i in range(0, len(alt) - 1, 2):
644 on.append(alt[i])
645 ar.append(alt[i + 1])
646 on.append(son[0])
647 myfaces.append(on)
648 ar.append(son[1])
649 ar.reverse()
650 myfaces.append(ar)
651 elif op.UST == '2': # Arch
652 if op.DT2 == '1':
653 h1 = op.VL1 / 100
654 if op.VL1 < 6:
655 h1 = 6 / 100
656
657 if h1 < 0.01:
658 h1 = 0.01
659 # op.VL1 = 1
660 elif h1 >= u:
661 h1 = u - 0.01
662 # op.VL1 = h1 * 100
663 if h1 < 0.07:
664 h1 = 0.07
665
666 h = sqrt(u ** 2 + h1 ** 2) / 2
667 e = h * (u / h1)
668 c = sqrt(h ** 2 + e ** 2)
669 t1 = zlist[-1] - h1
670 elif op.DT2 == '2':
671 c = op.VL2 / 100
672 if c < u + 0.01:
673 c = u + 0.01
674 # op.VL2 = c * 100
675 t1 = sqrt(c ** 2 - u ** 2) + zlist[-1] - c
676 r = c - k1
677 z = zlist[-1] - c
678
679 myvertex[ust[0]][2] = t1
680 myvertex[ust[1]][2] = t1
681 myvertex[son[0]][2] = t1
682 myvertex[son[1]][2] = t1
683 for i in alt:
684 myvertex[i][2] = sqrt(r ** 2 - myvertex[i][0] ** 2) + z
685
686 on = [son[0]]
687 u1 = []
688 for i in range(0, res):
689 a = i * pi / res
690 x = cos(a) * c
691 if -u < x < u:
692 myvertex.append([x, -k1 / 2, sin(a) * c + z])
693 on.append(len(myvertex) - 1)
694 u1.extend(on)
695 u1.append(ust[0])
696 on.extend([ust[0], alt[0]])
697 ar = []
698 d1 = []
699 d2 = []
700 for i in range(0, len(alt) - 2, 4):
701 x1 = myvertex[alt[i + 0]][0]
702 x2 = myvertex[alt[i + 2]][0]
703 on.append(alt[i + 0])
704 ar.append(alt[i + 1])
705 t1 = [alt[i + 0]]
706 t2 = [alt[i + 1]]
707 for j in range(0, res):
708 a = j * pi / res
709 x = -cos(a) * r
710 if x1 < x < x2:
711 myvertex.extend([[x, -k1 / 2, sin(a) * r + z], [x, k1 / 2, sin(a) * r + z]])
712 on.append(len(myvertex) - 2)
713 ar.append(len(myvertex) - 1)
714 t1.append(len(myvertex) - 2)
715 t2.append(len(myvertex) - 1)
716 on.append(alt[i + 2])
717 ar.append(alt[i + 3])
718 t1.append(alt[i + 2])
719 t2.append(alt[i + 3])
720 d1.append(t1)
721 d2.append(t2)
722 ar.append(son[1])
723 u2 = [son[1]]
724 for i in range(0, res):
725 a = i * pi / res
726 x = cos(a) * c
727 if -u < x < u:
728 myvertex.append([x, k1 / 2, sin(a) * c + z])
729 ar.append(len(myvertex) - 1)
730 u2.append(len(myvertex) - 1)
731 ar.append(ust[1])
732 u2.append(ust[1])
733 ar.reverse()
734 myfaces.extend([on, ar])
735 for i in range(0, len(u1) - 1):
736 myfaces.append([u1[i + 1], u1[i], u2[i], u2[i + 1]])
737 sm.append(len(myfaces) - 1)
738 for a in range(0, mx):
739 for i in range(0, len(d1[a]) - 1):
740 myfaces.append([d1[a][i + 1], d1[a][i], d2[a][i], d2[a][i + 1]])
741 sm.append(len(myfaces) - 1)
742 y = my - 1
743 for x in range(0, mx):
744 if kx[x][y] is True:
745 fr = (k1 + k2) * 0.5 - 0.01
746 ek = k2
747 r = c - k1
748 k = r - k2
749
750 x1 = xlist[x * 2 + 1]
751 x2 = xlist[x * 2 + 2]
752 myvertex.extend([[x2, fr - k2 / 2, z + 1], [x2 - k2, fr - k2 / 2, z + 1],
753 [x2 - k2, fr + k2 / 2, z + 1],
754 [x2, fr + k2 / 2, z + 1]])
755 myvertex.extend([[x2, fr - k2 / 2, zlist[-3]], [x2 - k2, fr - k2 / 2, zlist[-3] + k2],
756 [x2 - k2, fr + k2 / 2,
757 zlist[-3] + k2],
758 [x2, fr + k2 / 2, zlist[-3]]])
759 myvertex.extend([[x1, fr - k2 / 2, zlist[-3]], [x1 + k2, fr - k2 / 2, zlist[-3] + k2],
760 [x1 + k2, fr + k2 / 2,
761 zlist[-3] + k2],
762 [x1, fr + k2 / 2, zlist[-3]]])
763 myvertex.extend([[x1, fr - k2 / 2, z + 1], [x1 + k2, fr - k2 / 2, z + 1],
764 [x1 + k2, fr + k2 / 2, z + 1],
765 [x1, fr + k2 / 2, z + 1]])
766
767 n = len(myvertex)
768 myfaces.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11],
769 [n - 14, n - 13, n - 9, n - 10], [n - 13, n - 16, n - 12, n - 9]])
770 myfaces.extend(
771 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5, n - 6],
772 [n - 9, n - 12, n - 8, n - 5]])
773 myfaces.extend(
774 [[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2],
775 [n - 5, n - 8, n - 4, n - 1]])
776 alt = [n - 16, n - 15, n - 14, n - 13, n - 4, n - 3, n - 2, n - 1]
777 myvertex[alt[0]][2] = sqrt(r ** 2 - myvertex[alt[0]][0] ** 2) + z
778 myvertex[alt[1]][2] = sqrt(k ** 2 - myvertex[alt[1]][0] ** 2) + z
779 myvertex[alt[2]][2] = sqrt(k ** 2 - myvertex[alt[2]][0] ** 2) + z
780 myvertex[alt[3]][2] = sqrt(r ** 2 - myvertex[alt[3]][0] ** 2) + z
781 myvertex[alt[4]][2] = sqrt(r ** 2 - myvertex[alt[4]][0] ** 2) + z
782 myvertex[alt[5]][2] = sqrt(k ** 2 - myvertex[alt[5]][0] ** 2) + z
783 myvertex[alt[6]][2] = sqrt(k ** 2 - myvertex[alt[6]][0] ** 2) + z
784 myvertex[alt[7]][2] = sqrt(r ** 2 - myvertex[alt[7]][0] ** 2) + z
785
786 d1 = []
787 d2 = []
788 t1 = []
789 t2 = []
790 for i in range(0, res):
791 a = i * pi / res
792 y1 = cos(a) * r
793 y2 = -cos(a) * k
794 if x1 < y1 < x2:
795 myvertex.extend([[y1, fr - k2 / 2, sin(a) * r + z], [y1, fr + k2 / 2,
796 sin(a) * r + z]])
797 t1.append(len(myvertex) - 2)
798 t2.append(len(myvertex) - 1)
799 if x1 + k2 < y2 < x2 - k2:
800 myvertex.extend([[y2, fr - k2 / 2, sin(a) * k + z], [y2, fr + k2 / 2,
801 sin(a) * k + z]])
802 d1.append(len(myvertex) - 2)
803 d2.append(len(myvertex) - 1)
804 on = [alt[1], alt[0]]
805 on.extend(t1)
806 on.extend([alt[4], alt[5]])
807 on.extend(d1)
808 ar = [alt[2], alt[3]]
809 ar.extend(t2)
810 ar.extend([alt[7], alt[6]])
811 ar.extend(d2)
812 ar.reverse()
813
814 if d1 == [] and t1 == []:
815 myfaces.extend([on, ar, [alt[5], alt[6], alt[2], alt[1]], [alt[7], alt[4], alt[0], alt[
816 3]]])
817 m = len(myfaces)
818 sm.extend(
819 [m - 1, m - 2])
820 elif d1 == [] and t1 != []:
821 myfaces.extend([on, ar, [alt[5], alt[6], alt[2], alt[1]], [alt[7], alt[4], t1[-1], t2[-1]],
822 [alt[0], alt[3], t2[0], t1[0]]])
823 m = len(myfaces)
824 sm.extend(
825 [m - 1, m - 2, m - 3])
826 elif d1 != [] and t1 == []:
827 myfaces.extend([on, ar, [alt[5], alt[6], d2[0], d1[0]], [alt[2], alt[1], d1[-1], d2[-1]],
828 [alt[7], alt[4], alt[0], alt[3]]])
829 m = len(myfaces)
830 sm.extend(
831 [m - 1, m - 2, m - 3])
832 else:
833 myfaces.extend([on, ar, [alt[5], alt[6], d2[0], d1[0]], [alt[2], alt[1], d1[-1], d2[-1]],
834 [alt[7], alt[4], t1[-1], t2[-1]], [alt[0], alt[3], t2[0], t1[0]]])
835 m = len(myfaces)
836 sm.extend(
837 [m - 1, m - 2, m - 3, m - 4])
838
839 for i in range(0, len(d1) - 1):
840 myfaces.append([d1[i + 1], d1[i], d2[i], d2[i + 1]])
841 sm.append(len(myfaces) - 1)
842 for i in range(0, len(t1) - 1):
843 myfaces.append([t1[i + 1], t1[i], t2[i], t2[i + 1]])
844 sm.append(len(myfaces) - 1)
845 r = c - k1 - k2
846 k = r - k3 * 2
847 else:
848 fr = 0
849 ek = 0
850 r = c - k1
851 k = r - k3 * 2
852 # Fitil
853 x1 = xlist[x * 2 + 1] + ek
854 x2 = xlist[x * 2 + 2] - ek
855 myvertex.extend([[x2, fr - k3, z + 1], [x2 - k3 * 2, fr - k3, z + 1], [x2 - k3 * 2, fr + k3, z + 1],
856 [x2, fr + k3, z + 1]])
857 myvertex.extend([[x2, fr - k3, zlist[-3] + ek], [x2 - k3 * 2, fr - k3, zlist[-3] + ek + k3 * 2],
858 [x2 - k3 * 2, fr + k3, zlist[-3] + ek + k3 * 2], [x2, fr + k3, zlist[-3] + ek]])
859 myvertex.extend([[x1, fr - k3, zlist[-3] + ek], [x1 + k3 * 2, fr - k3, zlist[-3] + ek + k3 * 2],
860 [x1 + k3 * 2, fr + k3, zlist[-3] + ek + k3 * 2], [x1, fr + k3, zlist[-3] + ek]])
861 myvertex.extend([[x1, fr - k3, z + 1], [x1 + k3 * 2, fr - k3, z + 1], [x1 + k3 * 2, fr + k3, z + 1],
862 [x1, fr + k3, z + 1]])
863 n = len(myvertex)
864 myfaces.extend(
865 [[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11], [n - 14, n - 13, n - 9,
866 n - 10]])
867 myfaces.extend(
868 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5, n - 6]])
869 myfaces.extend([[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1,
870 n - 2]])
871 m = len(myfaces)
872 ftl.extend([m - 1, m - 2, m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9])
873 alt = [n - 16, n - 15, n - 14, n - 13, n - 4, n - 3, n - 2, n - 1]
874 myvertex[alt[0]][2] = sqrt(r ** 2 - myvertex[alt[0]][0] ** 2) + z
875 myvertex[alt[1]][2] = sqrt(k ** 2 - myvertex[alt[1]][0] ** 2) + z
876 myvertex[alt[2]][2] = sqrt(k ** 2 - myvertex[alt[2]][0] ** 2) + z
877 myvertex[alt[3]][2] = sqrt(r ** 2 - myvertex[alt[3]][0] ** 2) + z
878 myvertex[alt[4]][2] = sqrt(r ** 2 - myvertex[alt[4]][0] ** 2) + z
879 myvertex[alt[5]][2] = sqrt(k ** 2 - myvertex[alt[5]][0] ** 2) + z
880 myvertex[alt[6]][2] = sqrt(k ** 2 - myvertex[alt[6]][0] ** 2) + z
881 myvertex[alt[7]][2] = sqrt(r ** 2 - myvertex[alt[7]][0] ** 2) + z
882 d1 = []
883 d2 = []
884 t1 = []
885 t2 = []
886 for i in range(0, res):
887 a = i * pi / res
888 y1 = cos(a) * r
889 y2 = -cos(a) * k
890 if x1 < y1 < x2:
891 myvertex.extend([[y1, fr - k3, sin(a) * r + z], [y1, fr + k3, sin(a) * r + z]])
892 t1.append(len(myvertex) - 2)
893 t2.append(len(myvertex) - 1)
894 ftl.extend([len(myfaces) - 1, len(myfaces) - 2])
895 if x1 + k3 * 2 < y2 < x2 - k3 * 2:
896 myvertex.extend([[y2, fr - k3, sin(a) * k + z], [y2, fr + k3, sin(a) * k + z]])
897 d1.append(len(myvertex) - 2)
898 d2.append(len(myvertex) - 1)
899 ftl.extend([len(myfaces) - 1, len(myfaces) - 2])
900 on = [alt[1], alt[0]]
901 on.extend(t1)
902 on.extend([alt[4], alt[5]])
903 on.extend(d1)
904 ar = [alt[2], alt[3]]
905 ar.extend(t2)
906 ar.extend([alt[7], alt[6]])
907 ar.extend(d2)
908 ar.reverse()
909
910 if not d1:
911 myfaces.extend([on, ar, [alt[5], alt[6], alt[2], alt[1]]])
912 m = len(myfaces)
913 ftl.extend([m - 1, m - 2, m - 3])
914 sm.extend([m - 1])
915 else:
916 myfaces.extend([on, ar, [alt[5], alt[6], d2[0], d1[0]], [alt[2], alt[1], d1[-1], d2[-1]]])
917 m = len(myfaces)
918 ftl.extend([m - 1, m - 2, m - 3, m - 4])
919 sm.extend([m - 1, m - 2])
920
921 for i in range(0, len(d1) - 1):
922 myfaces.append([d1[i + 1], d1[i], d2[i], d2[i + 1]])
923 ftl.append(len(myfaces) - 1)
924 sm.append(len(myfaces) - 1)
925 # Cam
926 x1 = xlist[x * 2 + 1] + ek + k3 * 2
927 x2 = xlist[x * 2 + 2] - ek - k3 * 2
928 on = []
929 ar = []
930 for i in range(0, res):
931 a = i * pi / res
932 y1 = -cos(a) * k
933 if x1 < y1 < x2:
934 myvertex.extend([[y1, fr - 0.005, sin(a) * k + z], [y1, fr + 0.005, sin(a) * k + z]])
935 n = len(myvertex)
936 on.append(n - 1)
937 ar.append(n - 2)
938 myvertex.extend(
939 [[x1, fr - 0.005, sqrt(k ** 2 - x1 ** 2) + z], [x1, fr + 0.005,
940 sqrt(k ** 2 - x1 ** 2) + z]])
941 myvertex.extend([[x1, fr - 0.005, zlist[-3] + ek + k3 * 2], [x1, fr + 0.005, zlist[-3] + ek + k3 * 2]])
942 myvertex.extend([[x2, fr - 0.005, zlist[-3] + ek + k3 * 2], [x2, fr + 0.005, zlist[-3] + ek + k3 * 2]])
943 myvertex.extend(
944 [[x2, fr - 0.005, sqrt(k ** 2 - x2 ** 2) + z], [x2, fr + 0.005,
945 sqrt(k ** 2 - x2 ** 2) + z]])
946 n = len(myvertex)
947 on.extend([n - 1, n - 3, n - 5, n - 7])
948 ar.extend([n - 2, n - 4, n - 6, n - 8])
949 myfaces.append(on)
950 ar.reverse()
951 myfaces.append(ar)
952 m = len(myfaces)
953 cam.extend([m - 1, m - 2])
954
955 elif op.UST == '3': # Egri
956 if op.DT3 == '1':
957 h1 = (op.VL1 / 200) / u
958 elif op.DT3 == '2':
959 h1 = op.VL3 / 100
960 elif op.DT3 == '3':
961 h1 = sin(op.VL4 * pi / 180) / cos(op.VL4 * pi / 180)
962 z = sqrt(k1 ** 2 + (k1 * h1) ** 2)
963 k = sqrt(k2 ** 2 + (k2 * h1) ** 2)
964 f = sqrt(k3 ** 2 + (k3 * h1) ** 2) * 2
965 myvertex[ust[0]][2] = zlist[-1] + myvertex[ust[0]][0] * h1
966 myvertex[ust[1]][2] = zlist[-1] + myvertex[ust[1]][0] * h1
967 for i in alt:
968 myvertex[i][2] = zlist[-1] + myvertex[i][0] * h1 - z
969 myvertex[son[0]][2] = zlist[-1] + myvertex[son[0]][0] * h1
970 myvertex[son[1]][2] = zlist[-1] + myvertex[son[1]][0] * h1
971 myfaces.append([ust[1], ust[0], son[0], son[1]])
972 for i in range(0, mx * 4, 4):
973 myfaces.append([alt[i], alt[i + 1], alt[i + 3], alt[i + 2]])
974 on = [ust[0]]
975 ar = [ust[1]]
976 for i in range(0, len(alt) - 1, 2):
977 on.append(alt[i])
978 ar.append(alt[i + 1])
979 on.append(son[0])
980 myfaces.append(on)
981 ar.append(son[1])
982 ar.reverse()
983 myfaces.append(ar)
984 y = my - 1
985 for x in range(0, mx):
986 if kx[x][y] is True:
987 kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
988 n = len(myvertex)
989 myvertex[n - 5][2] = zlist[-1] + myvertex[n - 5][0] * h1 - z
990 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k
991 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k
992 myvertex[n - 8][2] = zlist[-1] + myvertex[n - 8][0] * h1 - z
993 myvertex[n - 9][2] = zlist[-1] + myvertex[n - 9][0] * h1 - z
994 myvertex[n - 10][2] = zlist[-1] + myvertex[n - 10][0] * h1 - z - k
995 myvertex[n - 11][2] = zlist[-1] + myvertex[n - 11][0] * h1 - z - k
996 myvertex[n - 12][2] = zlist[-1] + myvertex[n - 12][0] * h1 - z
997 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
998 n = len(myvertex)
999 myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - k - f
1000 myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - k - f
1001 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k - f
1002 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k - f
1003 myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z - k
1004 myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - k - f
1005 myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - k - f
1006 myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z - k
1007 myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z - k
1008 myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - k - f
1009 myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - k - f
1010 myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z - k
1011 else:
1012 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
1013 n = len(myvertex)
1014 myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - f
1015 myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - f
1016 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - f
1017 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - f
1018 myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z
1019 myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - f
1020 myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - f
1021 myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z
1022 myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z
1023 myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - f
1024 myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - f
1025 myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z
1026 m = len(myfaces)
1027 cam.extend([m - 1, m - 2])
1028 ftl.extend([m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10, m - 11, m - 12, m - 13, m - 14])
1029 elif op.UST == '4': # Ucgen
1030 if op.DT3 == '1':
1031 h1 = (op.VL1 / 100) / u
1032 elif op.DT3 == '2':
1033 h1 = op.VL3 / 100
1034 elif op.DT3 == '3':
1035 h1 = sin(op.VL4 * pi / 180) / cos(op.VL4 * pi / 180)
1036 z = sqrt(k1 ** 2 + (k1 * h1) ** 2)
1037 k = sqrt(k2 ** 2 + (k2 * h1) ** 2)
1038 f = sqrt(k3 ** 2 + (k3 * h1) ** 2) * 2
1039 myvertex[ust[0]][2] = zlist[-1] + myvertex[ust[0]][0] * h1
1040 myvertex[ust[1]][2] = zlist[-1] + myvertex[ust[1]][0] * h1
1041 for i in alt:
1042 myvertex[i][2] = zlist[-1] - abs(myvertex[i][0]) * h1 - z
1043 myvertex[son[0]][2] = zlist[-1] - myvertex[son[0]][0] * h1
1044 myvertex[son[1]][2] = zlist[-1] - myvertex[son[1]][0] * h1
1045 myvertex.extend([[0, -k1 / 2, zlist[-1]], [0, k1 / 2, zlist[-1]]])
1046
1047 x = 0
1048 for j in range(2, len(alt) - 2, 4):
1049 if myvertex[alt[j]][0] < 0 < myvertex[alt[j + 2]][0]:
1050 x = 1
1051
1052 n = len(myvertex)
1053 myfaces.extend([[ust[1], ust[0], n - 2, n - 1], [n - 1, n - 2, son[0], son[1]]])
1054 on = [son[0], n - 2, ust[0]]
1055 ar = [son[1], n - 1, ust[1]]
1056
1057 if x == 0:
1058 myvertex.extend([[0, -k1 / 2, zlist[-1] - z], [0, k1 / 2, zlist[-1] - z]])
1059 for j in range(0, len(alt) - 2, 4):
1060 if myvertex[alt[j]][0] < 0 and myvertex[alt[j + 2]][0] < 0:
1061 myfaces.append([alt[j], alt[j + 1], alt[j + 3], alt[j + 2]])
1062 on.extend([alt[j], alt[j + 2]])
1063 ar.extend([alt[j + 1], alt[j + 3]])
1064 elif myvertex[alt[j]][0] > 0 and myvertex[alt[j + 2]][0] > 0:
1065 myfaces.append([alt[j], alt[j + 1], alt[j + 3], alt[j + 2]])
1066 on.extend([alt[j], alt[j + 2]])
1067 ar.extend([alt[j + 1], alt[j + 3]])
1068 else:
1069 n = len(myvertex)
1070 myfaces.extend([[alt[j], alt[j + 1], n - 1, n - 2], [n - 2, n - 1, alt[j + 3], alt[j + 2]]])
1071 on.extend([alt[j + 0], n - 2, alt[j + 2]])
1072 ar.extend([alt[j + 1], n - 1, alt[j + 3]])
1073 myfaces.append(on)
1074 ar.reverse()
1075 myfaces.append(ar)
1076 y = my - 1
1077 for x in range(0, mx):
1078 if myvertex[alt[x * 4]][0] < 0 and myvertex[alt[x * 4 + 2]][0] < 0:
1079 if kx[x][y] is True:
1080 kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
1081 n = len(myvertex)
1082 myvertex[n - 5][2] = zlist[-1] + myvertex[n - 5][0] * h1 - z
1083 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k
1084 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k
1085 myvertex[n - 8][2] = zlist[-1] + myvertex[n - 8][0] * h1 - z
1086 myvertex[n - 9][2] = zlist[-1] + myvertex[n - 9][0] * h1 - z
1087 myvertex[n - 10][2] = zlist[-1] + myvertex[n - 10][0] * h1 - z - k
1088 myvertex[n - 11][2] = zlist[-1] + myvertex[n - 11][0] * h1 - z - k
1089 myvertex[n - 12][2] = zlist[-1] + myvertex[n - 12][0] * h1 - z
1090 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
1091 n = len(myvertex)
1092 myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - k - f
1093 myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - k - f
1094 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k - f
1095 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k - f
1096 myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z - k
1097 myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - k - f
1098 myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - k - f
1099 myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z - k
1100 myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z - k
1101 myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - k - f
1102 myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - k - f
1103 myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z - k
1104 else:
1105 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
1106 n = len(myvertex)
1107 myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - f
1108 myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - f
1109 myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - f
1110 myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - f
1111 myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z
1112 myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - f
1113 myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - f
1114 myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z
1115 myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z
1116 myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - f
1117 myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - f
1118 myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z
1119 m = len(myfaces)
1120 cam.extend([m - 1, m - 2])
1121 ftl.extend([m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10, m - 11,
1122 m - 12, m - 13, m - 14])
1123 elif myvertex[alt[x * 4]][0] > 0 and myvertex[alt[x * 4 + 2]][0] > 0:
1124 if kx[x][y] is True:
1125 kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
1126 n = len(myvertex)
1127 myvertex[n - 5][2] = zlist[-1] - myvertex[n - 5][0] * h1 - z
1128 myvertex[n - 6][2] = zlist[-1] - myvertex[n - 6][0] * h1 - z - k
1129 myvertex[n - 7][2] = zlist[-1] - myvertex[n - 7][0] * h1 - z - k
1130 myvertex[n - 8][2] = zlist[-1] - myvertex[n - 8][0] * h1 - z
1131 myvertex[n - 9][2] = zlist[-1] - myvertex[n - 9][0] * h1 - z
1132 myvertex[n - 10][2] = zlist[-1] - myvertex[n - 10][0] * h1 - z - k
1133 myvertex[n - 11][2] = zlist[-1] - myvertex[n - 11][0] * h1 - z - k
1134 myvertex[n - 12][2] = zlist[-1] - myvertex[n - 12][0] * h1 - z
1135 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
1136 n = len(myvertex)
1137 myvertex[n - 2][2] = zlist[-1] - myvertex[n - 2][0] * h1 - z - k - f
1138 myvertex[n - 3][2] = zlist[-1] - myvertex[n - 3][0] * h1 - z - k - f
1139 myvertex[n - 6][2] = zlist[-1] - myvertex[n - 6][0] * h1 - z - k - f
1140 myvertex[n - 7][2] = zlist[-1] - myvertex[n - 7][0] * h1 - z - k - f
1141 myvertex[n - 13][2] = zlist[-1] - myvertex[n - 13][0] * h1 - z - k
1142 myvertex[n - 14][2] = zlist[-1] - myvertex[n - 14][0] * h1 - z - k - f
1143 myvertex[n - 15][2] = zlist[-1] - myvertex[n - 15][0] * h1 - z - k - f
1144 myvertex[n - 16][2] = zlist[-1] - myvertex[n - 16][0] * h1 - z - k
1145 myvertex[n - 17][2] = zlist[-1] - myvertex[n - 17][0] * h1 - z - k
1146 myvertex[n - 18][2] = zlist[-1] - myvertex[n - 18][0] * h1 - z - k - f
1147 myvertex[n - 19][2] = zlist[-1] - myvertex[n - 19][0] * h1 - z - k - f
1148 myvertex[n - 20][2] = zlist[-1] - myvertex[n - 20][0] * h1 - z - k
1149 else:
1150 fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
1151 n = len(myvertex)
1152 myvertex[n - 2][2] = zlist[-1] - myvertex[n - 2][0] * h1 - z - f
1153 myvertex[n - 3][2] = zlist[-1] - myvertex[n - 3][0] * h1 - z - f
1154 myvertex[n - 6][2] = zlist[-1] - myvertex[n - 6][0] * h1 - z - f
1155 myvertex[n - 7][2] = zlist[-1] - myvertex[n - 7][0] * h1 - z - f
1156 myvertex[n - 13][2] = zlist[-1] - myvertex[n - 13][0] * h1 - z
1157 myvertex[n - 14][2] = zlist[-1] - myvertex[n - 14][0] * h1 - z - f
1158 myvertex[n - 15][2] = zlist[-1] - myvertex[n - 15][0] * h1 - z - f
1159 myvertex[n - 16][2] = zlist[-1] - myvertex[n - 16][0] * h1 - z
1160 myvertex[n - 17][2] = zlist[-1] - myvertex[n - 17][0] * h1 - z
1161 myvertex[n - 18][2] = zlist[-1] - myvertex[n - 18][0] * h1 - z - f
1162 myvertex[n - 19][2] = zlist[-1] - myvertex[n - 19][0] * h1 - z - f
1163 myvertex[n - 20][2] = zlist[-1] - myvertex[n - 20][0] * h1 - z
1164 m = len(myfaces)
1165 cam.extend([m - 1, m - 2])
1166 ftl.extend([m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10,
1167 m - 11, m - 12, m - 13, m - 14])
1168 else:
1169 k4 = k3 * 2
1170 if kx[x][y] is True:
1171 zz = (k1 + k2) * 0.5 - 0.01
1172 xx = xlist[x * 2 + 1]
1173 myvertex.extend([[xx, -k2 / 2 + zz, zlist[-3]], [xx + k2, -k2 / 2 + zz, zlist[-3] + k2],
1174 [xx + k2, k2 / 2 + zz, zlist[-3] + k2], [xx, k2 / 2 + zz, zlist[-3]]])
1175 myvertex.extend(
1176 [[xx, -k2 / 2 + zz, zlist[-1] + xx * h1 - z], [xx + k2, -k2 / 2 + zz,
1177 zlist[-1] + (xx + k2) * h1 - z - k],
1178 [xx + k2, k2 / 2 + zz, zlist[-1] + (xx + k2) * h1 - z - k],
1179 [xx, k2 / 2 + zz, zlist[-1] + xx * h1 - z]])
1180 myvertex.extend([[0, -k2 / 2 + zz, zlist[-1] - z], [0, -k2 / 2 + zz, zlist[-1] - z - k],
1181 [0, k2 / 2 + zz, zlist[-1] - z - k], [0, k2 / 2 + zz, zlist[-1] - z]])
1182 xx = xlist[x * 2 + 2]
1183 myvertex.extend(
1184 [[xx, -k2 / 2 + zz, zlist[-1] - xx * h1 - z], [xx - k2, -k2 / 2 + zz,
1185 zlist[-1] - (xx - k2) * h1 - z - k],
1186 [xx - k2, k2 / 2 + zz, zlist[-1] - (xx - k2) * h1 - z - k],
1187 [xx, k2 / 2 + zz, zlist[-1] - xx * h1 - z]])
1188 myvertex.extend([[xx, -k2 / 2 + zz, zlist[-3]], [xx - k2, -k2 / 2 + zz, zlist[-3] + k2],
1189 [xx - k2, k2 / 2 + zz, zlist[-3] + k2], [xx, k2 / 2 + zz, zlist[-3]]])
1190 n = len(myvertex)
1191 myfaces.extend([[n - 20, n - 19, n - 15, n - 16], [n - 19, n - 18, n - 14, n - 15],
1192 [n - 18, n - 17, n - 13, n - 14], [n - 17, n - 20, n - 16, n - 13]])
1193 myfaces.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11],
1194 [n - 14, n - 13, n - 9, n - 10], [n - 13, n - 16, n - 12, n - 9]])
1195 myfaces.extend(
1196 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9,
1197 n - 5, n - 6],
1198 [n - 9, n - 12, n - 8, n - 5]])
1199 myfaces.extend(
1200 [[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2],
1201 [n - 5, n - 8, n - 4, n - 1]])
1202 myfaces.extend(
1203 [[n - 4, n - 3, n - 19, n - 20], [n - 3, n - 2, n - 18, n - 19],
1204 [n - 2, n - 1, n - 17, n - 18],
1205 [n - 1, n - 4, n - 20, n - 17]])
1206 xx = xlist[x * 2 + 1]
1207 myvertex.extend([[xx + k2, -k3 + zz, zlist[-3] + k2], [xx + k4 + k2, -k3 + zz,
1208 zlist[-3] + k2 + k4],
1209 [xx + k4 + k2, k3 + zz, zlist[-3] + k2 + k4], [xx + k2, k3 + zz,
1210 zlist[-3] + k2]])
1211 myvertex.extend([[xx + k2, -k3 + zz, zlist[-1] + (xx + k2) * h1 - z - k],
1212 [xx + k4 + k2, -k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f],
1213 [xx + k4 + k2, k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f],
1214 [xx + k2, k3 + zz, zlist[-1] + (xx + k2) * h1 - z - k]])
1215 myvertex.extend([[0, -k3 + zz, zlist[-1] - k - z], [0, -k3 + zz, zlist[-1] - k - z - f],
1216 [0, k3 + zz, zlist[-1] - k - z - f], [0, k3 + zz, zlist[-1] - k - z]])
1217 xx = xlist[x * 2 + 2]
1218 myvertex.extend([[xx - k2, -k3 + zz, zlist[-1] - (xx - k2) * h1 - z - k],
1219 [xx - k4 - k2, -k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f],
1220 [xx - k4 - k2, k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f],
1221 [xx - k2, k3 + zz, zlist[-1] - (xx - k2) * h1 - z - k]])
1222 myvertex.extend([[xx - k2, -k3 + zz, zlist[-3] + k2],
1223 [xx - k4 - k2, -k3 + zz, zlist[-3] + k2 + k4],
1224 [xx - k4 - k2, k3 + zz, zlist[-3] + k2 + k4],
1225 [xx - k2, k3 + zz, zlist[-3] + k2]])
1226 n = len(myvertex)
1227 myfaces.extend([[n - 20, n - 19, n - 15, n - 16], [n - 19, n - 18, n - 14, n - 15],
1228 [n - 18, n - 17, n - 13, n - 14]])
1229 myfaces.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11],
1230 [n - 14, n - 13, n - 9, n - 10]])
1231 myfaces.extend(
1232 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10,
1233 n - 9, n - 5, n - 6]])
1234 myfaces.extend(
1235 [[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2]])
1236 myfaces.extend([[n - 4, n - 3, n - 19, n - 20], [n - 3, n - 2, n - 18, n - 19],
1237 [n - 2, n - 1, n - 17, n - 18]])
1238 xx = xlist[x * 2 + 1]
1239 myvertex.extend(
1240 [[xx + k4 + k2, -k3 + zz, zlist[-3] + k2 + k4], [xx + k4 + k2, k3 + zz, zlist[-3] +
1241 k2 + k4]])
1242 myvertex.extend([[xx + k4 + k2, -k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f],
1243 [xx + k4 + k2, k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f]])
1244 myvertex.extend([[0, -k3 + zz, zlist[-1] - k - z - f], [0, k3 + zz, zlist[-1] - k - z - f]])
1245 xx = xlist[x * 2 + 2]
1246 myvertex.extend([[xx - k4 - k2, -k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f],
1247 [xx - k4 - k2, k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f]])
1248 myvertex.extend(
1249 [[xx - k4 - k2, -k3 + zz, zlist[-3] + k2 + k4], [xx - k4 - k2, k3 + zz, zlist[-3] +
1250 k2 + k4]])
1251 myfaces.extend([[n + 8, n + 6, n + 4, n + 2, n + 0], [n + 1, n + 3, n + 5, n + 7, n + 9]])
1252 else:
1253 xx = xlist[x * 2 + 1]
1254 myvertex.extend(
1255 [[xx, -k3, zlist[-3]], [xx + k4, -k3, zlist[-3] + k4], [xx + k4, k3, zlist[-3] + k4],
1256 [xx, k3, zlist[-3]]])
1257 myvertex.extend(
1258 [[xx, -k3, zlist[-1] + xx * h1 - z], [xx + k4, -k3, zlist[-1] + (xx + k4) * h1 - z - f],
1259 [xx + k4, k3, zlist[-1] + (xx + k4) * h1 - z - f], [xx, k3, zlist[-1] + xx * h1 - z]])
1260 myvertex.extend(
1261 [[0, -k3, zlist[-1] - z], [0, -k3, zlist[-1] - z - f], [0, k3, zlist[-1] - z - f],
1262 [0, k3, zlist[-1] - z]])
1263 xx = xlist[x * 2 + 2]
1264 myvertex.extend(
1265 [[xx, -k3, zlist[-1] - xx * h1 - z], [xx - k4, -k3, zlist[-1] - (xx - k4) * h1 - z - f],
1266 [xx - k4, k3, zlist[-1] - (xx - k4) * h1 - z - f], [xx, k3, zlist[-1] - xx * h1 - z]])
1267 myvertex.extend(
1268 [[xx, -k3, zlist[-3]], [xx - k4, -k3, zlist[-3] + k4], [xx - k4, k3, zlist[-3] + k4],
1269 [xx, k3, zlist[-3]]])
1270 n = len(myvertex)
1271 myfaces.extend([[n - 20, n - 19, n - 15, n - 16], [n - 19, n - 18, n - 14, n - 15],
1272 [n - 18, n - 17, n - 13, n - 14]])
1273 myfaces.extend([[n - 16, n - 15, n - 11, n - 12], [n - 15, n - 14, n - 10, n - 11],
1274 [n - 14, n - 13, n - 9, n - 10]])
1275 myfaces.extend(
1276 [[n - 12, n - 11, n - 7, n - 8], [n - 11, n - 10, n - 6, n - 7], [n - 10, n - 9, n - 5,
1277 n - 6]])
1278 myfaces.extend(
1279 [[n - 8, n - 7, n - 3, n - 4], [n - 7, n - 6, n - 2, n - 3], [n - 6, n - 5, n - 1, n - 2]])
1280 myfaces.extend([[n - 4, n - 3, n - 19, n - 20], [n - 3, n - 2, n - 18, n - 19],
1281 [n - 2, n - 1, n - 17, n - 18]])
1282 xx = xlist[x * 2 + 1]
1283 myvertex.extend([[xx + k4, -0.005, zlist[-3] + k4], [xx + k4, 0.005, zlist[-3] + k4]])
1284 myvertex.extend([[xx + k4, -0.005, zlist[-1] + (xx + k4) * h1 - z - f],
1285 [xx + k4, 0.005, zlist[-1] + (xx + k4) * h1 - z - f]])
1286 myvertex.extend([[0, -0.005, zlist[-1] - z - f], [0, 0.005, zlist[-1] - z - f]])
1287 xx = xlist[x * 2 + 2]
1288 myvertex.extend([[xx - k4, -0.005, zlist[-1] - (xx - k4) * h1 - z - f],
1289 [xx - k4, 0.005, zlist[-1] - (xx - k4) * h1 - z - f]])
1290 myvertex.extend([[xx - k4, -0.005, zlist[-3] + k4], [xx - k4, 0.005, zlist[-3] + k4]])
1291 myfaces.extend([[n + 8, n + 6, n + 4, n + 2, n + 0], [n + 1, n + 3, n + 5, n + 7, n + 9]])
1292 m = len(myfaces)
1293 cam.extend([m - 1, m - 2])
1294 ftl.extend(
1295 [m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9, m - 10, m - 11, m - 12, m - 13,
1296 m - 14, m - 15,
1297 m - 16, m - 17])
1298 # Mermer
1299 if op.mr is True:
1300 mrh = -op.mr1 / 100
1301 mrg = op.mr2 / 100
1302 mdv = (op.mr3 / 200) + mrg
1303 msv = -(mdv + (op.mr4 / 100))
1304 myvertex.extend([[-u, mdv, 0], [u, mdv, 0], [-u, msv, 0], [u, msv, 0], [-u, mdv, mrh], [u, mdv, mrh],
1305 [-u, msv, mrh],
1306 [u, msv, mrh]])
1307 n = len(myvertex)
1308 myfaces.extend([[n - 1, n - 2, n - 4, n - 3], [n - 3, n - 4, n - 8, n - 7], [n - 6, n - 5, n - 7, n - 8],
1309 [n - 2, n - 1, n - 5, n - 6], [n - 4, n - 2, n - 6, n - 8], [n - 5, n - 1, n - 3, n - 7]])
1310 n = len(myfaces)
1311 mer.extend([n - 1, n - 2, n - 3, n - 4, n - 5, n - 6])
1312
1313 return True, ftl, cam, mer, sm
1314 except:
1315 return False, None, None, None, None
1316
1317
1318 # ------------------------------------
1319 # Get highest points of the panel
1320 # ------------------------------------
1321 def get_high_points(selobject, width, tip):
1322 obverts = selobject.data.vertices
1323
1324 top_a = 0
1325 top_b = 0
1326 top_c = 0
1327 # --------------------------
1328 # Recover all vertex
1329 # --------------------------
1330 for vertex in obverts:
1331 if vertex.co[0] == -width / 2:
1332 if vertex.co[2] >= top_a:
1333 top_a = vertex.co[2]
1334 if vertex.co[0] == width / 2:
1335 if vertex.co[2] >= top_b:
1336 top_b = vertex.co[2]
1337 # top center
1338 if tip == "2":
1339 if vertex.co[2] >= top_c:
1340 top_c = vertex.co[2]
1341 else:
1342 if vertex.co[0] == 0 and vertex.co[2] >= top_c:
1343 top_c = vertex.co[2]
1344
1345 return top_a, top_b, top_c
1346
1347
1348 # ---------------------------------------------------------
1349 # Defines a point
1350 # ---------------------------------------------------------
1351 class Cpoint:
1352
1353 def __init__(self, x, y):
1354 self.x = float(x)
1355 self.y = float(y)
1356
1357
1358 # ---------------------------------------------------------
1359 # Get angle between two vectors
1360 # ---------------------------------------------------------
1361 def get_angle(p1, p2):
1362 v1 = Vector((p1[0], 0.0, p1[1]))
1363 v2 = Vector((p2[0], 0.0, p2[1]))
1364
1365 a = v1.angle(v2)
1366 return a
1367
1368
1369 # ---------------------------------------------------------
1370 # Get center of circle base on 3 points
1371 #
1372 # Point a: (x,z)
1373 # Point b: (x,z)
1374 # Point c: (x,z)
1375 # Return:
1376 # x, y: center position
1377 # r: radio
1378 # ang: angle
1379 # ---------------------------------------------------------
1380 def get_circle_center(a, b, c):
1381 try:
1382 # line between a and b: s1 + k * d1
1383 s1 = Cpoint((a.x + b.x) / 2.0, (a.y + b.y) / 2.0)
1384 d1 = Cpoint(b.y - a.y, a.x - b.x)
1385 # line between a and c: s2 + k * d2
1386 s2 = Cpoint((a.x + c.x) / 2.0, (a.y + c.y) / 2.0)
1387 d2 = Cpoint(c.y - a.y, a.x - c.x)
1388 # intersection of both lines:
1389 l = d1.x * (s2.y - s1.y) - d1.y * (s2.x - s1.x)
1390 l /= d2.x * d1.y - d2.y * d1.x
1391 center = Cpoint(s2.x + l * d2.x, s2.y + l * d2.y)
1392 dx = center.x - a.x
1393 dy = center.y - a.y
1394 radio = sqrt(dx * dx + dy * dy)
1395
1396 # angle
1397 v1 = (a.x - center.x, a.y - center.y)
1398 v2 = (b.x - center.x, b.y - center.y)
1399 ang = get_angle(v1, v2)
1400 return center, radio, ang
1401 except ZeroDivisionError:
1402 return Cpoint(0, 0), 1, 1
1403
1404
1405 # -----------------------------------------
1406 # Get limits
1407 # lb, rb: limits x
1408 # lt, rt: limits z
1409 # mp: limit z in med point
1410 # lo: Z low limit
1411 # my: max y
1412 # top: top vertex
1413 # -----------------------------------------
1414 def get_limits(myobject):
1415 verts = myobject.data.vertices
1416
1417 lb = 0
1418 lt = 0
1419 rb = 0
1420 rt = 0
1421 mp = 0
1422 lo = 0
1423 my = 0
1424 top = 0
1425 for v in verts:
1426 if v.co[2] > top:
1427 top = v.co[2]
1428
1429 if v.co[2] < lo:
1430 lo = v.co[2]
1431
1432 if v.co[1] > my:
1433 my = v.co[1]
1434 if v.co[0] > rb:
1435 rb = v.co[0]
1436 if v.co[0] < lb:
1437 lb = v.co[0]
1438 if v.co[0] == 0:
1439 if v.co[2] > mp:
1440 mp = v.co[2]
1441 # max sides
1442 for v in verts:
1443 if v.co[2] > lt and v.co[0] == lb:
1444 lt = v.co[2]
1445 if v.co[2] > rt and v.co[0] == rb:
1446 rt = v.co[2]
1447
1448 return lb, lt, rb, rt, mp, lo, my, top
1449
1450
1451 # ------------------------------------------
1452 # Create control box for panels
1453 #
1454 # ------------------------------------------
1455 def create_ctrl_box(parentobj, objname):
1456 myvertex = []
1457 myfaces = []
1458
1459 o = parentobj
1460 op = o.WindowPanelGenerator[0]
1461
1462 lb, lt, rb, rt, mp, lo, my, top = get_limits(o)
1463 ypos = my * 1.8
1464 # -----------------------------
1465 # Flat, Triangle and inclined
1466 # -----------------------------
1467 if op.UST == "1" or op.UST == "3" or op.UST == "4":
1468 if mp == 0:
1469 myvertex.extend([(lb, ypos, lo), (lb, ypos, lt), (rb, ypos, rt), (rb, ypos, lo)])
1470 myvertex.extend([(lb, -ypos, lo), (lb, -ypos, lt), (rb, -ypos, rt), (rb, -ypos, lo)])
1471 myfaces.extend([(0, 4, 5, 1), (3, 2, 6, 7), (0, 1, 2, 3), (4, 7, 6, 5), (1, 5, 6, 2), (0, 3, 7, 4)])
1472 else:
1473 myvertex.extend([(lb, ypos, lo), (lb, ypos, lt), (0, ypos, mp), (rb, ypos, rt), (rb, ypos, lo)])
1474 myvertex.extend([(lb, -ypos, lo), (lb, -ypos, lt), (0, -ypos, mp), (rb, -ypos, rt), (rb, -ypos, lo)])
1475 myfaces.extend([(0, 5, 6, 1), (4, 3, 8, 9), (0, 1, 2, 3, 4), (9, 8, 7, 6, 5), (1, 6, 7, 2), (2, 7, 8, 3),
1476 (0, 4, 9, 5)])
1477 # -----------------------------
1478 # Arch
1479 # -----------------------------
1480 if op.UST == "2":
1481 center, r, ang = get_circle_center(Cpoint(lb, lt), Cpoint(0, top), Cpoint(rb, rt))
1482
1483 # cx = center.x
1484 cz = center.y
1485
1486 sg = op.res
1487 arc = ((pi / 2) + ang) - ((pi / 2) - ang)
1488 step = arc / sg
1489 a = (pi / 2) + ang
1490
1491 myvertex.extend([(lb, ypos, lt), (lb, -ypos, lt)])
1492 for x in range(0, sg):
1493 myvertex.extend([(r * cos(a), ypos, r * sin(a) + cz),
1494 (r * cos(a), -ypos, r * sin(a) + cz)])
1495 a -= step
1496
1497 # close sides
1498 myvertex.extend([(rb, ypos, rt), (rb, -ypos, rt)])
1499
1500 v = 0
1501 nf = len(myvertex)
1502 for x in range(0, nf - 2, 2):
1503 myfaces.extend([(v, v + 1, v + 3, v + 2)])
1504 v += 2
1505
1506 nf = len(myvertex)
1507 myvertex.extend([(lb, ypos, lo), (lb, -ypos, lo)])
1508 myvertex.extend([(rb, ypos, lo), (rb, -ypos, lo)])
1509
1510 nf2 = len(myvertex)
1511 myfaces.extend([(0, nf2 - 4, nf2 - 3, 1)])
1512 myfaces.extend([(nf - 2, nf - 1, nf2 - 1, nf2 - 2)])
1513
1514 nf2 = len(myvertex)
1515 myfaces.extend([(nf2 - 4, nf2 - 2, nf2 - 1, nf2 - 3)])
1516
1517 # --------------------------
1518 # Create mesh
1519 # --------------------------
1520 myfaces = check_mesh_errors(myvertex, myfaces)
1521 mymesh = bpy.data.meshes.new(objname)
1522 myobj = bpy.data.objects.new(objname, mymesh)
1523
1524 myobj.location = bpy.context.scene.cursor.location
1525 bpy.context.collection.objects.link(myobj)
1526
1527 mymesh.from_pydata(myvertex, [], myfaces)
1528 mymesh.update(calc_edges=True)
1529
1530 return myobj
1531
1532
1533 # ------------------------------------------------------------------
1534 # Define property group class to create or modify
1535 # ------------------------------------------------------------------
1536 class GeneralPanelProperties(PropertyGroup):
1537 prs: EnumProperty(
1538 items=(
1539 ('1', "WINDOW 250X200", ""),
1540 ('2', "WINDOW 200X200", ""),
1541 ('3', "WINDOW 180X200", ""),
1542 ('4', "WINDOW 180X160", ""),
1543 ('5', "WINDOW 160X160", ""),
1544 ('6', "WINDOW 50X50", ""),
1545 ('7', "DOOR 80X250", ""),
1546 ('8', "DOOR 80X230", ""),
1547 ),
1548 name="",
1549 description='Predefined types',
1550 update=update_using_default,
1551 )
1552 son: EnumProperty(
1553 items=(
1554 ('1', "WINDOW 250X200", ""),
1555 ('2', "WINDOW 200X200", ""),
1556 ('3', "WINDOW 180X200", ""),
1557 ('4', "WINDOW 180X160", ""),
1558 ('5', "WINDOW 160X160", ""),
1559 ('6', "WINDOW 50X50", ""),
1560 ('7', "DOOR 80X250", ""),
1561 ('8', "DOOR 80X230", ""),
1562 ),
1563 name="",
1564 description='Predefined types',
1565 update=update_using_default,
1566 )
1567 gen: IntProperty(
1568 name='H Count', min=1, max=8, default=3,
1569 description='Horizontal Panes',
1570 update=update_window,
1571 )
1572 yuk: IntProperty(
1573 name='V Count', min=1, max=5, default=1,
1574 description='Vertical Panes',
1575 update=update_window,
1576 )
1577 kl1: IntProperty(
1578 name='Outer Frame', min=2, max=50, default=5,
1579 description='Outside Frame Thickness',
1580 update=update_window,
1581 )
1582 kl2: IntProperty(
1583 name='Risers', min=2, max=50, default=5,
1584 description='Risers Width',
1585 update=update_window,
1586 )
1587 fk: IntProperty(
1588 name='Inner Frame', min=1, max=20, default=2,
1589 description='Inside Frame Thickness',
1590 update=update_window,
1591 )
1592
1593 mr: BoolProperty(name='Sill', default=True, description='Window Sill', update=update_window)
1594 mr1: IntProperty(name='', min=1, max=20, default=4, description='Height', update=update_window)
1595 mr2: IntProperty(name='', min=0, max=20, default=4, description='First Depth', update=update_window)
1596 mr3: IntProperty(name='', min=1, max=50, default=20, description='Second Depth', update=update_window)
1597 mr4: IntProperty(name='', min=0, max=50, default=0, description='Extrusion for Jamb',
1598 update=update_window)
1599
1600 mt1: EnumProperty(
1601 items=(
1602 ('1', "PVC", ""),
1603 ('2', "WOOD", ""),
1604 ('3', "Plastic", ""),
1605 ),
1606 name="",
1607 default='1',
1608 description='Material to use',
1609 update=update_window,
1610 )
1611 mt2: EnumProperty(
1612 items=(
1613 ('1', "PVC", ""),
1614 ('2', "WOOD", ""),
1615 ('3', "Plastic", ""),
1616 ),
1617 name="",
1618 default='3',
1619 description='Material to use',
1620 update=update_window,
1621 )
1622
1623 r: FloatProperty(
1624 name='Rotation',
1625 min=0, max=360, default=0, precision=1,
1626 description='Panel rotation',
1627 update=update_window,
1628 )
1629
1630 UST: EnumProperty(
1631 items=(
1632 ('1', "Flat", ""),
1633 ('2', "Arch", ""),
1634 ('3', "Inclined", ""),
1635 ('4', "Triangle", ""),
1636 ),
1637 name="Top", default='1',
1638 description='Type of window upper section',
1639 update=update_window,
1640 )
1641 DT2: EnumProperty(
1642 items=(
1643 ('1', "Difference", ""),
1644 ('2', "Radius", ""),
1645 ),
1646 name="",
1647 default='1',
1648 update=update_window,
1649 )
1650 DT3: EnumProperty(
1651 items=(
1652 ('1', "Difference", ""),
1653 ('2', "Incline %", ""),
1654 ('3', "Incline Angle", ""),
1655 ),
1656 name="",
1657 default='1', update=update_window,
1658 )
1659
1660 VL1: IntProperty(name='', min=-10000, max=10000, default=30, update=update_window) # Fark
1661 VL2: IntProperty(name='', min=1, max=10000, default=30, update=update_window) # Cap
1662 VL3: IntProperty(name='', min=-100, max=100, default=30, update=update_window) # Egim %
1663 VL4: IntProperty(name='', min=-45, max=45, default=30, update=update_window) # Egim Aci
1664
1665 res: IntProperty(name='Resolution', min=2, max=360, default=36, update=update_window) # Res
1666
1667 gnx0: IntProperty(name='', min=1, max=300, default=60, description='1st Window Width',
1668 update=update_window)
1669 gnx1: IntProperty(name='', min=1, max=300, default=110, description='2nd Window Width',
1670 update=update_window)
1671 gnx2: IntProperty(name='', min=1, max=300, default=60, description='3rd Window Width',
1672 update=update_window)
1673 gnx3: IntProperty(name='', min=1, max=300, default=60, description='4th Window Width',
1674 update=update_window)
1675 gnx4: IntProperty(name='', min=1, max=300, default=60, description='5th Window Width',
1676 update=update_window)
1677 gnx5: IntProperty(name='', min=1, max=300, default=60, description='6th Window Width',
1678 update=update_window)
1679 gnx6: IntProperty(name='', min=1, max=300, default=60, description='7th Window Width',
1680 update=update_window)
1681 gnx7: IntProperty(name='', min=1, max=300, default=60, description='8th Window Width',
1682 update=update_window)
1683
1684 gny0: IntProperty(name='', min=1, max=300, default=190, description='1st Row Height',
1685 update=update_window)
1686 gny1: IntProperty(name='', min=1, max=300, default=45, description='2nd Row Height',
1687 update=update_window)
1688 gny2: IntProperty(name='', min=1, max=300, default=45, description='3rd Row Height',
1689 update=update_window)
1690 gny3: IntProperty(name='', min=1, max=300, default=45, description='4th Row Height',
1691 update=update_window)
1692 gny4: IntProperty(name='', min=1, max=300, default=45, description='5th Row Height',
1693 update=update_window)
1694
1695 k00: BoolProperty(name='', default=True, update=update_window)
1696 k01: BoolProperty(name='', default=False, update=update_window)
1697 k02: BoolProperty(name='', default=True, update=update_window)
1698 k03: BoolProperty(name='', default=False, update=update_window)
1699 k04: BoolProperty(name='', default=False, update=update_window)
1700 k05: BoolProperty(name='', default=False, update=update_window)
1701 k06: BoolProperty(name='', default=False, update=update_window)
1702 k07: BoolProperty(name='', default=False, update=update_window)
1703
1704 k10: BoolProperty(name='', default=False, update=update_window)
1705 k11: BoolProperty(name='', default=False, update=update_window)
1706 k12: BoolProperty(name='', default=False, update=update_window)
1707 k13: BoolProperty(name='', default=False, update=update_window)
1708 k14: BoolProperty(name='', default=False, update=update_window)
1709 k15: BoolProperty(name='', default=False, update=update_window)
1710 k16: BoolProperty(name='', default=False, update=update_window)
1711 k17: BoolProperty(name='', default=False, update=update_window)
1712
1713 k20: BoolProperty(name='', default=False, update=update_window)
1714 k21: BoolProperty(name='', default=False, update=update_window)
1715 k22: BoolProperty(name='', default=False, update=update_window)
1716 k23: BoolProperty(name='', default=False, update=update_window)
1717 k24: BoolProperty(name='', default=False, update=update_window)
1718 k25: BoolProperty(name='', default=False, update=update_window)
1719 k26: BoolProperty(name='', default=False, update=update_window)
1720 k27: BoolProperty(name='', default=False, update=update_window)
1721
1722 k30: BoolProperty(name='', default=False, update=update_window)
1723 k31: BoolProperty(name='', default=False, update=update_window)
1724 k32: BoolProperty(name='', default=False, update=update_window)
1725 k33: BoolProperty(name='', default=False, update=update_window)
1726 k34: BoolProperty(name='', default=False, update=update_window)
1727 k35: BoolProperty(name='', default=False, update=update_window)
1728 k36: BoolProperty(name='', default=False, update=update_window)
1729 k37: BoolProperty(name='', default=False, update=update_window)
1730
1731 k40: BoolProperty(name='', default=False, update=update_window)
1732 k41: BoolProperty(name='', default=False, update=update_window)
1733 k42: BoolProperty(name='', default=False, update=update_window)
1734 k43: BoolProperty(name='', default=False, update=update_window)
1735 k44: BoolProperty(name='', default=False, update=update_window)
1736 k45: BoolProperty(name='', default=False, update=update_window)
1737 k46: BoolProperty(name='', default=False, update=update_window)
1738 k47: BoolProperty(name='', default=False, update=update_window)
1739 # opengl internal data
1740 glpoint_a: FloatVectorProperty(
1741 name="glpointa",
1742 description="Hidden property for opengl",
1743 default=(0, 0, 0),
1744 )
1745 glpoint_b: FloatVectorProperty(
1746 name="glpointb",
1747 description="Hidden property for opengl",
1748 default=(0, 0, 0),
1749 )
1750 glpoint_c: FloatVectorProperty(
1751 name="glpointc",
1752 description="Hidden property for opengl",
1753 default=(0, 0, 0),
1754 )
1755 glpoint_d: FloatVectorProperty(
1756 name="glpointc",
1757 description="Hidden property for opengl",
1758 default=(0, 0, 0),
1759 )
1760
1761
1762 bpy.utils.register_class(GeneralPanelProperties)
1763 Object.WindowPanelGenerator = CollectionProperty(type=GeneralPanelProperties)
1764
1765
1766 # ------------------------------------------------------------------
1767 # Define panel class to modify myobjects.
1768 # ------------------------------------------------------------------
1769 class ARCHIMESH_PT_WindowEdit(Panel):
1770 bl_idname = "ARCHIMESH_PT_window_edit"
1771 bl_label = "Window Panel"
1772 bl_space_type = 'VIEW_3D'
1773 bl_region_type = 'UI'
1774 bl_category = 'Create'
1775
1776 # -----------------------------------------------------
1777 # Verify if visible
1778 # -----------------------------------------------------
1779 @classmethod
1780 def poll(cls, context):
1781 o = context.object
1782 if o is None:
1783 return False
1784 if 'WindowPanelGenerator' not in o:
1785 return False
1786 else:
1787 return True
1788
1789 # -----------------------------------------------------
1790 # Draw (create UI interface)
1791 # -----------------------------------------------------
1792 def draw(self, context):
1793 o = context.object
1794 # If the selected object didn't be created with the group 'WindowPanelGenerator', this panel is not created.
1795 # noinspection PyBroadException
1796 try:
1797 if 'WindowPanelGenerator' not in o:
1798 return
1799 except:
1800 return
1801
1802 layout = self.layout
1803 if bpy.context.mode == 'EDIT_MESH':
1804 layout.label(text='Warning: Operator does not work in edit mode.', icon='ERROR')
1805 else:
1806 myobject = o.WindowPanelGenerator[0]
1807 layout.prop(myobject, 'prs')
1808 box = layout.box()
1809 box.prop(myobject, 'gen')
1810 box.prop(myobject, 'yuk')
1811 box.prop(myobject, 'kl1')
1812 box.prop(myobject, 'kl2')
1813 box.prop(myobject, 'fk')
1814 box.prop(myobject, 'r') # rotation
1815
1816 box.prop(myobject, 'mr')
1817 if myobject.mr is True:
1818 row = box.row()
1819 row.prop(myobject, 'mr1')
1820 row.prop(myobject, 'mr2')
1821 row = box.row()
1822 row.prop(myobject, 'mr3')
1823 row.prop(myobject, 'mr4')
1824 row = layout.row()
1825 row.label(text='Frame')
1826 row.label(text='Inner Frame')
1827 row = layout.row()
1828 row.prop(myobject, 'mt1')
1829 row.prop(myobject, 'mt2')
1830
1831 box.prop(myobject, 'UST')
1832 if myobject.UST == '2':
1833 row = box.row()
1834 row.prop(myobject, 'DT2')
1835 if myobject.DT2 == '1':
1836 row.prop(myobject, 'VL1')
1837 elif myobject.DT2 == '2':
1838 row.prop(myobject, 'VL2')
1839 box.prop(myobject, 'res')
1840 elif myobject.UST == '3':
1841 row = box.row()
1842 row.prop(myobject, 'DT3')
1843 if myobject.DT3 == '1':
1844 row.prop(myobject, 'VL1')
1845 elif myobject.DT3 == '2':
1846 row.prop(myobject, 'VL3')
1847 elif myobject.DT3 == '3':
1848 row.prop(myobject, 'VL4')
1849 elif myobject.UST == '4':
1850 row = box.row()
1851 row.prop(myobject, 'DT3')
1852 if myobject.DT3 == '1':
1853 row.prop(myobject, 'VL1')
1854 elif myobject.DT3 == '2':
1855 row.prop(myobject, 'VL3')
1856 elif myobject.DT3 == '3':
1857 row.prop(myobject, 'VL4')
1858 row = layout.row()
1859 for i in range(0, myobject.gen):
1860 row.prop(myobject, 'gnx' + str(i))
1861 for j in range(0, myobject.yuk):
1862 row = layout.row()
1863 row.prop(myobject, 'gny' + str(myobject.yuk - j - 1))
1864 for i in range(0, myobject.gen):
1865 row.prop(myobject, 'k' + str(myobject.yuk - j - 1) + str(i))
Central repository of Blender addons