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