# ##### BEGIN GPL LICENSE BLOCK #####
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####

# <pep8 compliant>

# ----------------------------------------------------------
# Main panel for windows
# Author: Antonio Vazquez (antonioya)
#
# This code is base on the windows generator add-on created by SayProduction
# and has been adapted to continuous editing and cycles materials
#
# ----------------------------------------------------------
# noinspection PyUnresolvedReferences
import bpy
from math import cos, sin, radians, sqrt, pi
from mathutils import Vector
from bpy.types import Operator, PropertyGroup, Object, Panel
from bpy.props import StringProperty, FloatProperty, BoolProperty, IntProperty, FloatVectorProperty, \
    CollectionProperty, EnumProperty
from .achm_tools import *


def fitil(vr, fc, px, pz, x, y, z, zz, xx):
    k3 = z * 2
    vr.extend([[px[x] + xx, -z + zz, pz[y] + xx], [px[x] + xx + k3, -z + zz, pz[y] + xx + k3],
               [px[x] + xx + k3, z + zz, pz[y] + xx + k3], [px[x] + xx, z + zz, pz[y] + xx]])
    vr.extend([[px[x] + xx, -z + zz, pz[y + 1] - xx], [px[x] + xx + k3, -z + zz, pz[y + 1] - xx - k3],
               [px[x] + xx + k3, z + zz, pz[y + 1] - xx - k3], [px[x] + xx, z + zz, pz[y + 1] - xx]])
    vr.extend([[px[x + 1] - xx, -z + zz, pz[y + 1] - xx], [px[x + 1] - xx - k3, -z + zz, pz[y + 1] - xx - k3],
               [px[x + 1] - xx - k3, z + zz, pz[y + 1] - xx - k3], [px[x + 1] - xx, z + zz, pz[y + 1] - xx]])
    vr.extend([[px[x + 1] - xx, -z + zz, pz[y] + xx], [px[x + 1] - xx - k3, -z + zz, pz[y] + xx + k3],
               [px[x + 1] - xx - k3, z + zz, pz[y] + xx + k3], [px[x + 1] - xx, z + zz, pz[y] + xx]])
    n = len(vr)
    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]])
    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]])
    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]])
    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]])
    z = 0.005
    vr.extend([[px[x] + xx + k3, -z + zz, pz[y] + xx + k3], [px[x] + xx + k3, -z + zz, pz[y + 1] - xx - k3],
               [px[x + 1] - xx - k3, -z + zz, pz[y + 1] - xx - k3], [px[x + 1] - xx - k3, -z + zz, pz[y] + xx + k3]])
    vr.extend([[px[x] + xx + k3, z + zz, pz[y] + xx + k3], [px[x] + xx + k3, z + zz, pz[y + 1] - xx - k3],
               [px[x + 1] - xx - k3, z + zz, pz[y + 1] - xx - k3], [px[x + 1] - xx - k3, z + zz, pz[y] + xx + k3]])
    fc.extend([[n + 1, n + 0, n + 3, n + 2], [n + 4, n + 5, n + 6, n + 7]])


def kapak(vr, fc, px, pz, x, y, z, zz):
    k2 = z * 2
    vr.extend(
        [[px[x], -z + zz, pz[y]], [px[x] + k2, -z + zz, pz[y] + k2], [px[x] + k2, z + zz, pz[y] + k2],
         [px[x], z + zz, pz[y]]])
    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],
               [px[x], z + zz, pz[y + 1]]])
    vr.extend(
        [[px[x + 1], -z + zz, pz[y + 1]], [px[x + 1] - k2, -z + zz, pz[y + 1] - k2],
         [px[x + 1] - k2, z + zz, pz[y + 1] - k2],
         [px[x + 1], z + zz, pz[y + 1]]])
    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],
               [px[x + 1], z + zz, pz[y]]])
    n = len(vr)
    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],
               [n - 13, n - 16, n - 12, n - 9]])
    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],
               [n - 9, n - 12, n - 8, n - 5]])
    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],
               [n - 5, n - 8, n - 4, n - 1]])
    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],
               [n - 1, n - 4, n - 16, n - 13]])


# -----------------------------------------
# Set default values for each window type
# -----------------------------------------
def set_defaults(s):
    if s.prs == '1':
        s.gen = 3
        s.yuk = 1
        s.kl1 = 5
        s.kl2 = 5
        s.fk = 2
        s.gny0 = 190
        s.mr = True
        s.gnx0 = 60
        s.gnx1 = 110
        s.gnx2 = 60
        s.k00 = True
        s.k01 = False
        s.k02 = True
    if s.prs == '2':
        s.gen = 3
        s.yuk = 1
        s.kl1 = 5
        s.kl2 = 5
        s.fk = 2
        s.gny0 = 190
        s.mr = True
        s.gnx0 = 60
        s.gnx1 = 60
        s.gnx2 = 60
        s.k00 = True
        s.k01 = False
        s.k02 = True
    if s.prs == '3':
        s.gen = 3
        s.yuk = 1
        s.kl1 = 5
        s.kl2 = 5
        s.fk = 2
        s.gny0 = 190
        s.mr = True
        s.gnx0 = 55
        s.gnx1 = 50
        s.gnx2 = 55
        s.k00 = True
        s.k01 = False
        s.k02 = True
    if s.prs == '4':
        s.gen = 3
        s.yuk = 1
        s.kl1 = 5
        s.kl2 = 5
        s.fk = 2
        s.gny0 = 150
        s.mr = True
        s.gnx0 = 55
        s.gnx1 = 50
        s.gnx2 = 55
        s.k00 = True
        s.k01 = False
        s.k02 = True
    if s.prs == '5':
        s.gen = 3
        s.yuk = 1
        s.kl1 = 5
        s.kl2 = 5
        s.fk = 2
        s.gny0 = 150
        s.mr = True
        s.gnx0 = 50
        s.gnx1 = 40
        s.gnx2 = 50
        s.k00 = True
        s.k01 = False
        s.k02 = True
    if s.prs == '6':
        s.gen = 1
        s.yuk = 1
        s.kl1 = 5
        s.kl2 = 5
        s.fk = 2
        s.gny0 = 40
        s.mr = True
        s.gnx0 = 40
        s.k00 = False
    if s.prs == '7':
        s.gen = 1
        s.yuk = 2
        s.kl1 = 5
        s.kl2 = 5
        s.fk = 2
        s.gny0 = 195
        s.gny1 = 40
        s.gnx0 = 70
        s.k00 = True
        s.k10 = False
        s.mr = False
    if s.prs == '8':
        s.gen = 1
        s.yuk = 2
        s.kl1 = 5
        s.kl2 = 5
        s.fk = 2
        s.gny0 = 180
        s.gny1 = 35
        s.gnx0 = 70
        s.k00 = True
        s.k10 = False
        s.mr = False


# ------------------------------------------------------------------
# Define operator class to create window panels
# ------------------------------------------------------------------
class ARCHIMESH_PT_Win(Operator):
    bl_idname = "mesh.archimesh_winpanel"
    bl_label = "Panel Window"
    bl_description = "Generate editable flat windows"
    bl_category = 'View'
    bl_options = {'REGISTER', 'UNDO'}

    # -----------------------------------------------------
    # Draw (create UI interface)
    # -----------------------------------------------------
    # noinspection PyUnusedLocal
    def draw(self, context):
        layout = self.layout
        row = layout.row()
        row.label(text="Use Properties panel (N) to define parms", icon='INFO')

    # -----------------------------------------------------
    # Execute
    # -----------------------------------------------------
    # noinspection PyUnusedLocal
    def execute(self, context):
        if bpy.context.mode == "OBJECT":
            create_window()
            return {'FINISHED'}
        else:
            self.report({'WARNING'}, "Archimesh: Option only valid in Object mode")
            return {'CANCELLED'}


# ------------------------------------------------------------------------------
# Create the window
# ------------------------------------------------------------------------------
def create_window():
    # deselect all objects
    for o in bpy.data.objects:
        o.select_set(False)
    # Create main object
    window_mesh = bpy.data.meshes.new("Window")
    window_object = bpy.data.objects.new("Window", window_mesh)

    # Link object to scene
    bpy.context.collection.objects.link(window_object)
    window_object.WindowPanelGenerator.add()
    window_object.location = bpy.context.scene.cursor.location

    # Shape the mesh.
    do_mesh(window_object, window_mesh)

    # deactivate others
    for o in bpy.data.objects:
        if o.select_get() is True and o.name != window_object.name:
            o.select_set(False)

    # Select, and activate object
    window_object.select_set(True)
    bpy.context.view_layer.objects.active = window_object

    do_ctrl_box(window_object)
    # Reselect
    window_object.select_set(True)
    bpy.context.view_layer.objects.active = window_object


# ------------------------------------------------------------------------------
# Update mesh of the window
# ------------------------------------------------------------------------------
# noinspection PyUnusedLocal
def update_window(self, context):
    # When update, the active object is the main object.
    o = bpy.context.active_object
    oldmesh = o.data
    oldname = o.data.name
    # Now deselect that object to not delete it.
    o.select_set(False)
    # # and create a new mesh for the object:
    # tmp_mesh = bpy.data.meshes.new("temp")
    # deselect all objects
    for obj in bpy.data.objects:
        obj.select_set(False)
    # ---------------------------------
    #  Clear Parent objects (autohole)
    # ---------------------------------
    myparent = o.parent
    if myparent is not None:
        ploc = myparent.location
    else:
        ploc = o.location
    if myparent is not None:
        o.parent = None
        o.location = ploc
        # remove_children(parent)
        for child in myparent.children:
            # noinspection PyBroadException
            try:
                # clear child data
                child.hide_viewport = False  # must be visible to avoid bug
                child.hide_render = False  # must be visible to avoid bug
                old = child.data
                child.select_set(True)
                bpy.ops.object.delete()
                bpy.data.meshes.remove(old)
            except:
                pass

        myparent.select_set(True)
        bpy.ops.object.delete()

    # Finally create all that again
    tmp_mesh = bpy.data.meshes.new("temp")
    do_mesh(o, tmp_mesh, True)
    o.data = tmp_mesh
    # Remove data (mesh of active object),
    if oldmesh.users == 0:
        bpy.data.meshes.remove(oldmesh)
    else:
        oldmesh.name = "invalid"

    tmp_mesh.name = oldname
    # deactivate others
    for ob in bpy.data.objects:
        if ob.select_get() is True and ob.name != o.name:
            ob.select_set(False)
    # and select, and activate, the object.
    o.select_set(True)
    bpy.context.view_layer.objects.active = o

    do_ctrl_box(o)

    # Reselect
    o.select_set(True)
    bpy.context.view_layer.objects.active = o


# ------------------------------------------------------------------------------
# Generate object
# For object, it only shapes mesh
# ------------------------------------------------------------------------------
# noinspection PyUnusedLocal
def do_mesh(myobject, tmp_mesh, update=False):
    # noinspection PyBroadException
    try:
        op = myobject.WindowPanelGenerator[0]
        # Create only mesh, because the object was created before.
        r = generate_window_object(op, tmp_mesh)
        if r is False:
            return False

        # refine unit
        remove_doubles(myobject)
        set_normals(myobject)

        # saves OpenGL data
        # sum width
        totx = myobject.dimensions.x
        op.glpoint_a = (-totx / 2, 0, 0)
        top_a, top_b, top_c = get_high_points(myobject, totx, op.UST)
        op.glpoint_b = (-totx / 2, 0, top_a)
        op.glpoint_c = (totx / 2, 0, top_b)
        op.glpoint_d = (0, 0, top_c)

        # Lock
        myobject.lock_location = (True, True, True)
        myobject.lock_rotation = (True, True, True)
        return True
    except:
        return False


# ------------------------------------------------------------------------------
# Generate ctrl box
#
# ------------------------------------------------------------------------------
# noinspection PyUnusedLocal
def do_ctrl_box(myobject):
    op = myobject.WindowPanelGenerator[0]
    # -------------------------
    # Create empty and parent
    # -------------------------
    bpy.ops.object.empty_add(type='PLAIN_AXES')
    myempty = bpy.data.objects[bpy.context.active_object.name]
    myempty.location = myobject.location

    myempty.name = "Window_Group"
    parentobject(myempty, myobject)
    myobject["archimesh.hole_enable"] = True
    # Rotate Empty
    myempty.rotation_euler.z = radians(op.r)
    # Create control box to open wall holes
    myctrl = create_ctrl_box(myobject, "CTRL_Hole")

    # Add custom property to detect Controller
    myctrl["archimesh.ctrl_hole"] = True

    set_normals(myctrl)
    myctrl.parent = myempty
    myctrl.location.x = 0
    myctrl.location.y = 0
    myctrl.location.z = 0
    myctrl.display_type = 'WIRE'
    myctrl.hide_viewport = False
    myctrl.hide_render = True
    if bpy.context.scene.render.engine in {'CYCLES', 'BLENDER_EEVEE'}:
        myctrl.visible_camera = False
        myctrl.visible_diffuse = False
        myctrl.visible_glossy = False
        myctrl.visible_transmission = False
        myctrl.visible_shadow = False

        mat = create_transparent_material("hidden_material", False)
        set_material(myctrl, mat)


# ------------------------------------------------------------------------------
# Update the parameters using a default value
# ------------------------------------------------------------------------------
# noinspection PyUnusedLocal
def update_using_default(self, context):
    o = context.object
    myobject = o.WindowPanelGenerator[0]
    if myobject.son != myobject.prs:
        set_defaults(myobject)
        myobject.son = myobject.prs


# ------------------------------------------------------------------------------
# Generate window object
# ------------------------------------------------------------------------------
def generate_window_object(op, mymesh):
    myvertex = []
    mfaces = []
    # noinspection PyBroadException
    try:
        rst, ft1, cam, mer, sm = generate_vertex_data(op, myvertex, mfaces)
        if rst is not True:
            return False

        mymesh.from_pydata(myvertex, [], mfaces)
        # Uncomment for debug
        # mymesh.validate(verbose=True)
        # Assign materials
        if op.mt1 == '1':
            mymesh.materials.append(create_diffuse_material("PVC", False, 1, 1, 1, 1, 1, 1))
        elif op.mt1 == '2':
            mymesh.materials.append(create_diffuse_material("Wood", False, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1))
        elif op.mt1 == '3':
            mymesh.materials.append(create_diffuse_material("Plastic", False, 0, 0, 0, 0, 0, 0))
        if op.mt2 == '1':
            mymesh.materials.append(create_diffuse_material("PVC", False, 1, 1, 1, 1, 1, 1))
        elif op.mt2 == '2':
            mymesh.materials.append(create_diffuse_material("Wood", False, 0.3, 0.2, 0.1, 0.3, 0.2, 0.1))
        elif op.mt2 == '3':
            mymesh.materials.append(create_diffuse_material("Plastic", False, 0, 0, 0, 0, 0, 0))

        mymesh.materials.append(create_glass_material("Glass", False))
        if op.mr is True:
            mymesh.materials.append(create_diffuse_material("Marble", False, 0.9, 0.8, 0.7, 0.9, 0.8, 0.7))

        p = len(mymesh.polygons)
        for i in ft1:
            if -1 < i < p:
                mymesh.polygons[i].material_index = 1
        for i in cam:
            if -1 < i < p:
                mymesh.polygons[i].material_index = 2
        for i in mer:
            if -1 < i < p:
                mymesh.polygons[i].material_index = 3
        for i in sm:
            if -1 < i < p:
                mymesh.polygons[i].use_smooth = 1

        mymesh.update(calc_edges=True)

        return True
    except:
        return False


# -----------------------------------------
# Generate vertex and faces data
# -----------------------------------------
def generate_vertex_data(op, myvertex, myfaces):
    # noinspection PyBroadException
    try:
        h1 = 0
        c = 0
        t1 = 0

        mx = op.gen
        my = op.yuk
        k1 = op.kl1 / 100
        k2 = op.kl2 / 100
        k3 = op.fk / 200
        res = op.res

        u = op.kl1 / 100
        xlist = [0, round(u, 2)]
        if mx > 0:
            u += op.gnx0 / 100
            xlist.append(round(u, 2))
            u += k2
            xlist.append(round(u, 2))
        if mx > 1:
            u += op.gnx1 / 100
            xlist.append(round(u, 2))
            u += k2
            xlist.append(round(u, 2))
        if mx > 2:
            u += op.gnx2 / 100
            xlist.append(round(u, 2))
            u += k2
            xlist.append(round(u, 2))
        if mx > 3:
            u += op.gnx3 / 100
            xlist.append(round(u, 2))
            u += k2
            xlist.append(round(u, 2))
        if mx > 4:
            u += op.gnx4 / 100
            xlist.append(round(u, 2))
            u += k2
            xlist.append(round(u, 2))
        if mx > 5:
            u += op.gnx5 / 100
            xlist.append(round(u, 2))
            u += k2
            xlist.append(round(u, 2))
        if mx > 6:
            u += op.gnx6 / 100
            xlist.append(round(u, 2))
            u += k2
            xlist.append(round(u, 2))
        if mx > 7:
            u += op.gnx7 / 100
            xlist.append(round(u, 2))
            u += k2
            xlist.append(round(u, 2))

        xlist[-1] = xlist[-2] + k1

        u = op.kl1 / 100
        zlist = [0, round(u, 2)]
        if my > 0:
            u += op.gny0 / 100
            zlist.append(round(u, 2))
            u += k2
            zlist.append(round(u, 2))
        if my > 1:
            u += op.gny1 / 100
            zlist.append(round(u, 2))
            u += k2
            zlist.append(round(u, 2))
        if my > 2:
            u += op.gny2 / 100
            zlist.append(round(u, 2))
            u += k2
            zlist.append(round(u, 2))
        if my > 3:
            u += op.gny3 / 100
            zlist.append(round(u, 2))
            u += k2
            zlist.append(round(u, 2))
        if my > 4:
            u += op.gny4 / 100
            zlist.append(round(u, 2))
            u += k2
            zlist.append(round(u, 2))
        zlist[-1] = zlist[-2] + k1

        u = xlist[-1] / 2
        for i in range(0, len(xlist)):
            xlist[i] -= u
        kx = [[op.k00, op.k10, op.k20, op.k30, op.k40],
              [op.k01, op.k11, op.k21, op.k31, op.k41],
              [op.k02, op.k12, op.k22, op.k32, op.k42],
              [op.k03, op.k13, op.k23, op.k33, op.k43],
              [op.k04, op.k14, op.k24, op.k34, op.k44],
              [op.k05, op.k15, op.k25, op.k35, op.k45],
              [op.k06, op.k16, op.k26, op.k36, op.k46],
              [op.k07, op.k17, op.k27, op.k37, op.k47]]
        cam = []
        mer = []
        ftl = []
        sm = []
        # -------------------------
        # VERTICES
        # -------------------------
        myvertex.extend([[xlist[0], -k1 / 2, zlist[0]], [xlist[0], k1 / 2, zlist[0]]])
        for x in range(1, len(xlist) - 1):
            myvertex.extend([[xlist[x], -k1 / 2, zlist[1]], [xlist[x], k1 / 2, zlist[1]]])
        myvertex.extend([[xlist[-1], -k1 / 2, zlist[0]], [xlist[-1], k1 / 2, zlist[0]]])
        for z in range(2, len(zlist) - 2, 2):
            for x in range(0, len(xlist)):
                myvertex.extend([[xlist[x], -k1 / 2, zlist[z]], [xlist[x], k1 / 2, zlist[z]]])
            for x in range(0, len(xlist)):
                myvertex.extend([[xlist[x], -k1 / 2, zlist[z + 1]], [xlist[x], k1 / 2, zlist[z + 1]]])
        z = len(zlist) - 2
        myvertex.extend([[xlist[0], -k1 / 2, zlist[z + 1]], [xlist[0], k1 / 2, zlist[z + 1]]])
        alt = []
        ust = [len(myvertex) - 2, len(myvertex) - 1]
        for x in range(1, len(xlist) - 1):
            myvertex.extend([[xlist[x], -k1 / 2, zlist[z]], [xlist[x], k1 / 2, zlist[z]]])
            alt.extend([len(myvertex) - 2, len(myvertex) - 1])
        myvertex.extend([[xlist[-1], -k1 / 2, zlist[z + 1]], [xlist[-1], k1 / 2, zlist[z + 1]]])
        son = [len(myvertex) - 2, len(myvertex) - 1]
        # -------------------------
        # FACES
        # -------------------------
        myfaces.append([0, 1, 3 + mx * 4, 2 + mx * 4])
        fb = [0]
        fr = [1]
        for i in range(0, mx * 4, 4):
            myfaces.append([i + 3, i + 2, i + 4, i + 5])
            fb.extend([i + 2, i + 4])
            fr.extend([i + 3, i + 5])
        fr.append(3 + mx * 4)
        fb.append(2 + mx * 4)
        fb.reverse()
        myfaces.extend([fb, fr])
        # Yatay
        y = (mx * 4 + 4)
        v = mx * 4 + 2
        for z in range(0, (my - 1) * y * 2, y * 2):
            myfaces.extend([[z + y + 1, z + y, z + y + 4 + mx * 4, z + y + 5 + mx * 4],
                            [z + y + v, z + y + v + 1, z + y + v + 5 + mx * 4, z + y + v + 4 + mx * 4]])
            for i in range(0, mx * 4 + 2, 2):
                myfaces.extend([[z + i + y + 0, z + i + y + 2, z + i + y + v + 4, z + i + y + v + 2],
                                [z + i + y + 3, z + i + y + 1, z + i + y + v + 3, z + i + y + v + 5]])
            for i in range(0, mx * 4 - 3, 4):
                myfaces.extend([[z + i + y + 2, z + i + y + 3, z + i + y + 5, z + i + y + 4],
                                [z + i + y + v + 5, z + i + y + v + 4, z + i + y + v + 6,
                                 z + i + y + v + 7]])
        # Dikey
        for y in range(0, my):
            z = y * (mx * 4 + 4) * 2
            for i in range(0, mx * 4 + 2, 4):
                myfaces.extend([[z + i + 1, z + i + 0, z + i + v + 2, z + i + v + 3],
                                [z + i + 3, z + i + 1, z + i + v + 3, z + i + v + 5],
                                [z + i + 2, z + i + 3, z + i + v + 5, z + i + v + 4],
                                [z + i + 0, z + i + 2, z + i + v + 4, z + i + v + 2]])
        # Fitil
        if op.UST == '1':
            y1 = my
        else:
            y1 = my - 1
        for y in range(0, y1):
            for x in range(0, mx):
                if kx[x][y] is True:
                    kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
                    fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
                else:
                    fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
                m = len(myfaces)
                cam.extend([m - 1, m - 2])
                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])
        # -----------------------------------------------------
        if op.UST == '1':  # Duz
            myfaces.append([ust[1], ust[0], son[0], son[1]])
            for i in range(0, mx * 4, 4):
                myfaces.append([alt[i], alt[i + 1], alt[i + 3], alt[i + 2]])
            on = [ust[0]]
            ar = [ust[1]]
            for i in range(0, len(alt) - 1, 2):
                on.append(alt[i])
                ar.append(alt[i + 1])
            on.append(son[0])
            myfaces.append(on)
            ar.append(son[1])
            ar.reverse()
            myfaces.append(ar)
        elif op.UST == '2':  # Arch
            if op.DT2 == '1':
                h1 = op.VL1 / 100
                if op.VL1 < 6:
                    h1 = 6 / 100

                if h1 < 0.01:
                    h1 = 0.01
                    # op.VL1 = 1
                elif h1 >= u:
                    h1 = u - 0.01
                    # op.VL1 = h1 * 100
                if h1 < 0.07:
                    h1 = 0.07

                h = sqrt(u ** 2 + h1 ** 2) / 2
                e = h * (u / h1)
                c = sqrt(h ** 2 + e ** 2)
                t1 = zlist[-1] - h1
            elif op.DT2 == '2':
                c = op.VL2 / 100
                if c < u + 0.01:
                    c = u + 0.01
                    # op.VL2 = c * 100
                t1 = sqrt(c ** 2 - u ** 2) + zlist[-1] - c
            r = c - k1
            z = zlist[-1] - c

            myvertex[ust[0]][2] = t1
            myvertex[ust[1]][2] = t1
            myvertex[son[0]][2] = t1
            myvertex[son[1]][2] = t1
            for i in alt:
                myvertex[i][2] = sqrt(r ** 2 - myvertex[i][0] ** 2) + z

            on = [son[0]]
            u1 = []
            for i in range(0, res):
                a = i * pi / res
                x = cos(a) * c
                if -u < x < u:
                    myvertex.append([x, -k1 / 2, sin(a) * c + z])
                    on.append(len(myvertex) - 1)
            u1.extend(on)
            u1.append(ust[0])
            on.extend([ust[0], alt[0]])
            ar = []
            d1 = []
            d2 = []
            for i in range(0, len(alt) - 2, 4):
                x1 = myvertex[alt[i + 0]][0]
                x2 = myvertex[alt[i + 2]][0]
                on.append(alt[i + 0])
                ar.append(alt[i + 1])
                t1 = [alt[i + 0]]
                t2 = [alt[i + 1]]
                for j in range(0, res):
                    a = j * pi / res
                    x = -cos(a) * r
                    if x1 < x < x2:
                        myvertex.extend([[x, -k1 / 2, sin(a) * r + z], [x, k1 / 2, sin(a) * r + z]])
                        on.append(len(myvertex) - 2)
                        ar.append(len(myvertex) - 1)
                        t1.append(len(myvertex) - 2)
                        t2.append(len(myvertex) - 1)
                on.append(alt[i + 2])
                ar.append(alt[i + 3])
                t1.append(alt[i + 2])
                t2.append(alt[i + 3])
                d1.append(t1)
                d2.append(t2)
            ar.append(son[1])
            u2 = [son[1]]
            for i in range(0, res):
                a = i * pi / res
                x = cos(a) * c
                if -u < x < u:
                    myvertex.append([x, k1 / 2, sin(a) * c + z])
                    ar.append(len(myvertex) - 1)
                    u2.append(len(myvertex) - 1)
            ar.append(ust[1])
            u2.append(ust[1])
            ar.reverse()
            myfaces.extend([on, ar])
            for i in range(0, len(u1) - 1):
                myfaces.append([u1[i + 1], u1[i], u2[i], u2[i + 1]])
                sm.append(len(myfaces) - 1)
            for a in range(0, mx):
                for i in range(0, len(d1[a]) - 1):
                    myfaces.append([d1[a][i + 1], d1[a][i], d2[a][i], d2[a][i + 1]])
                    sm.append(len(myfaces) - 1)
            y = my - 1
            for x in range(0, mx):
                if kx[x][y] is True:
                    fr = (k1 + k2) * 0.5 - 0.01
                    ek = k2
                    r = c - k1
                    k = r - k2

                    x1 = xlist[x * 2 + 1]
                    x2 = xlist[x * 2 + 2]
                    myvertex.extend([[x2, fr - k2 / 2, z + 1], [x2 - k2, fr - k2 / 2, z + 1],
                                     [x2 - k2, fr + k2 / 2, z + 1],
                                     [x2, fr + k2 / 2, z + 1]])
                    myvertex.extend([[x2, fr - k2 / 2, zlist[-3]], [x2 - k2, fr - k2 / 2, zlist[-3] + k2],
                                     [x2 - k2, fr + k2 / 2,
                                      zlist[-3] + k2],
                                     [x2, fr + k2 / 2, zlist[-3]]])
                    myvertex.extend([[x1, fr - k2 / 2, zlist[-3]], [x1 + k2, fr - k2 / 2, zlist[-3] + k2],
                                     [x1 + k2, fr + k2 / 2,
                                      zlist[-3] + k2],
                                     [x1, fr + k2 / 2, zlist[-3]]])
                    myvertex.extend([[x1, fr - k2 / 2, z + 1], [x1 + k2, fr - k2 / 2, z + 1],
                                     [x1 + k2, fr + k2 / 2, z + 1],
                                     [x1, fr + k2 / 2, z + 1]])

                    n = len(myvertex)
                    myfaces.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], [n - 13, n - 16, n - 12, n - 9]])
                    myfaces.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],
                         [n - 9, n - 12, n - 8, n - 5]])
                    myfaces.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],
                         [n - 5, n - 8, n - 4, n - 1]])
                    alt = [n - 16, n - 15, n - 14, n - 13, n - 4, n - 3, n - 2, n - 1]
                    myvertex[alt[0]][2] = sqrt(r ** 2 - myvertex[alt[0]][0] ** 2) + z
                    myvertex[alt[1]][2] = sqrt(k ** 2 - myvertex[alt[1]][0] ** 2) + z
                    myvertex[alt[2]][2] = sqrt(k ** 2 - myvertex[alt[2]][0] ** 2) + z
                    myvertex[alt[3]][2] = sqrt(r ** 2 - myvertex[alt[3]][0] ** 2) + z
                    myvertex[alt[4]][2] = sqrt(r ** 2 - myvertex[alt[4]][0] ** 2) + z
                    myvertex[alt[5]][2] = sqrt(k ** 2 - myvertex[alt[5]][0] ** 2) + z
                    myvertex[alt[6]][2] = sqrt(k ** 2 - myvertex[alt[6]][0] ** 2) + z
                    myvertex[alt[7]][2] = sqrt(r ** 2 - myvertex[alt[7]][0] ** 2) + z

                    d1 = []
                    d2 = []
                    t1 = []
                    t2 = []
                    for i in range(0, res):
                        a = i * pi / res
                        y1 = cos(a) * r
                        y2 = -cos(a) * k
                        if x1 < y1 < x2:
                            myvertex.extend([[y1, fr - k2 / 2, sin(a) * r + z], [y1, fr + k2 / 2,
                                                                                      sin(a) * r + z]])
                            t1.append(len(myvertex) - 2)
                            t2.append(len(myvertex) - 1)
                        if x1 + k2 < y2 < x2 - k2:
                            myvertex.extend([[y2, fr - k2 / 2, sin(a) * k + z], [y2, fr + k2 / 2,
                                                                                      sin(a) * k + z]])
                            d1.append(len(myvertex) - 2)
                            d2.append(len(myvertex) - 1)
                    on = [alt[1], alt[0]]
                    on.extend(t1)
                    on.extend([alt[4], alt[5]])
                    on.extend(d1)
                    ar = [alt[2], alt[3]]
                    ar.extend(t2)
                    ar.extend([alt[7], alt[6]])
                    ar.extend(d2)
                    ar.reverse()

                    if d1 == [] and t1 == []:
                        myfaces.extend([on, ar, [alt[5], alt[6], alt[2], alt[1]], [alt[7], alt[4], alt[0], alt[
                            3]]])
                        m = len(myfaces)
                        sm.extend(
                            [m - 1, m - 2])
                    elif d1 == [] and t1 != []:
                        myfaces.extend([on, ar, [alt[5], alt[6], alt[2], alt[1]], [alt[7], alt[4], t1[-1], t2[-1]],
                                        [alt[0], alt[3], t2[0], t1[0]]])
                        m = len(myfaces)
                        sm.extend(
                            [m - 1, m - 2, m - 3])
                    elif d1 != [] and t1 == []:
                        myfaces.extend([on, ar, [alt[5], alt[6], d2[0], d1[0]], [alt[2], alt[1], d1[-1], d2[-1]],
                                        [alt[7], alt[4], alt[0], alt[3]]])
                        m = len(myfaces)
                        sm.extend(
                            [m - 1, m - 2, m - 3])
                    else:
                        myfaces.extend([on, ar, [alt[5], alt[6], d2[0], d1[0]], [alt[2], alt[1], d1[-1], d2[-1]],
                                        [alt[7], alt[4], t1[-1], t2[-1]], [alt[0], alt[3], t2[0], t1[0]]])
                        m = len(myfaces)
                        sm.extend(
                            [m - 1, m - 2, m - 3, m - 4])

                    for i in range(0, len(d1) - 1):
                        myfaces.append([d1[i + 1], d1[i], d2[i], d2[i + 1]])
                        sm.append(len(myfaces) - 1)
                    for i in range(0, len(t1) - 1):
                        myfaces.append([t1[i + 1], t1[i], t2[i], t2[i + 1]])
                        sm.append(len(myfaces) - 1)
                    r = c - k1 - k2
                    k = r - k3 * 2
                else:
                    fr = 0
                    ek = 0
                    r = c - k1
                    k = r - k3 * 2
                # Fitil
                x1 = xlist[x * 2 + 1] + ek
                x2 = xlist[x * 2 + 2] - ek
                myvertex.extend([[x2, fr - k3, z + 1], [x2 - k3 * 2, fr - k3, z + 1], [x2 - k3 * 2, fr + k3, z + 1],
                                 [x2, fr + k3, z + 1]])
                myvertex.extend([[x2, fr - k3, zlist[-3] + ek], [x2 - k3 * 2, fr - k3, zlist[-3] + ek + k3 * 2],
                                 [x2 - k3 * 2, fr + k3, zlist[-3] + ek + k3 * 2], [x2, fr + k3, zlist[-3] + ek]])
                myvertex.extend([[x1, fr - k3, zlist[-3] + ek], [x1 + k3 * 2, fr - k3, zlist[-3] + ek + k3 * 2],
                                 [x1 + k3 * 2, fr + k3, zlist[-3] + ek + k3 * 2], [x1, fr + k3, zlist[-3] + ek]])
                myvertex.extend([[x1, fr - k3, z + 1], [x1 + k3 * 2, fr - k3, z + 1], [x1 + k3 * 2, fr + k3, z + 1],
                                 [x1, fr + k3, z + 1]])
                n = len(myvertex)
                myfaces.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]])
                myfaces.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]])
                myfaces.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]])
                m = len(myfaces)
                ftl.extend([m - 1, m - 2, m - 3, m - 4, m - 5, m - 6, m - 7, m - 8, m - 9])
                alt = [n - 16, n - 15, n - 14, n - 13, n - 4, n - 3, n - 2, n - 1]
                myvertex[alt[0]][2] = sqrt(r ** 2 - myvertex[alt[0]][0] ** 2) + z
                myvertex[alt[1]][2] = sqrt(k ** 2 - myvertex[alt[1]][0] ** 2) + z
                myvertex[alt[2]][2] = sqrt(k ** 2 - myvertex[alt[2]][0] ** 2) + z
                myvertex[alt[3]][2] = sqrt(r ** 2 - myvertex[alt[3]][0] ** 2) + z
                myvertex[alt[4]][2] = sqrt(r ** 2 - myvertex[alt[4]][0] ** 2) + z
                myvertex[alt[5]][2] = sqrt(k ** 2 - myvertex[alt[5]][0] ** 2) + z
                myvertex[alt[6]][2] = sqrt(k ** 2 - myvertex[alt[6]][0] ** 2) + z
                myvertex[alt[7]][2] = sqrt(r ** 2 - myvertex[alt[7]][0] ** 2) + z
                d1 = []
                d2 = []
                t1 = []
                t2 = []
                for i in range(0, res):
                    a = i * pi / res
                    y1 = cos(a) * r
                    y2 = -cos(a) * k
                    if x1 < y1 < x2:
                        myvertex.extend([[y1, fr - k3, sin(a) * r + z], [y1, fr + k3, sin(a) * r + z]])
                        t1.append(len(myvertex) - 2)
                        t2.append(len(myvertex) - 1)
                        ftl.extend([len(myfaces) - 1, len(myfaces) - 2])
                    if x1 + k3 * 2 < y2 < x2 - k3 * 2:
                        myvertex.extend([[y2, fr - k3, sin(a) * k + z], [y2, fr + k3, sin(a) * k + z]])
                        d1.append(len(myvertex) - 2)
                        d2.append(len(myvertex) - 1)
                        ftl.extend([len(myfaces) - 1, len(myfaces) - 2])
                on = [alt[1], alt[0]]
                on.extend(t1)
                on.extend([alt[4], alt[5]])
                on.extend(d1)
                ar = [alt[2], alt[3]]
                ar.extend(t2)
                ar.extend([alt[7], alt[6]])
                ar.extend(d2)
                ar.reverse()

                if not d1:
                    myfaces.extend([on, ar, [alt[5], alt[6], alt[2], alt[1]]])
                    m = len(myfaces)
                    ftl.extend([m - 1, m - 2, m - 3])
                    sm.extend([m - 1])
                else:
                    myfaces.extend([on, ar, [alt[5], alt[6], d2[0], d1[0]], [alt[2], alt[1], d1[-1], d2[-1]]])
                    m = len(myfaces)
                    ftl.extend([m - 1, m - 2, m - 3, m - 4])
                    sm.extend([m - 1, m - 2])

                for i in range(0, len(d1) - 1):
                    myfaces.append([d1[i + 1], d1[i], d2[i], d2[i + 1]])
                    ftl.append(len(myfaces) - 1)
                    sm.append(len(myfaces) - 1)
                # Cam
                x1 = xlist[x * 2 + 1] + ek + k3 * 2
                x2 = xlist[x * 2 + 2] - ek - k3 * 2
                on = []
                ar = []
                for i in range(0, res):
                    a = i * pi / res
                    y1 = -cos(a) * k
                    if x1 < y1 < x2:
                        myvertex.extend([[y1, fr - 0.005, sin(a) * k + z], [y1, fr + 0.005, sin(a) * k + z]])
                        n = len(myvertex)
                        on.append(n - 1)
                        ar.append(n - 2)
                myvertex.extend(
                    [[x1, fr - 0.005, sqrt(k ** 2 - x1 ** 2) + z], [x1, fr + 0.005,
                                                                         sqrt(k ** 2 - x1 ** 2) + z]])
                myvertex.extend([[x1, fr - 0.005, zlist[-3] + ek + k3 * 2], [x1, fr + 0.005, zlist[-3] + ek + k3 * 2]])
                myvertex.extend([[x2, fr - 0.005, zlist[-3] + ek + k3 * 2], [x2, fr + 0.005, zlist[-3] + ek + k3 * 2]])
                myvertex.extend(
                    [[x2, fr - 0.005, sqrt(k ** 2 - x2 ** 2) + z], [x2, fr + 0.005,
                                                                         sqrt(k ** 2 - x2 ** 2) + z]])
                n = len(myvertex)
                on.extend([n - 1, n - 3, n - 5, n - 7])
                ar.extend([n - 2, n - 4, n - 6, n - 8])
                myfaces.append(on)
                ar.reverse()
                myfaces.append(ar)
                m = len(myfaces)
                cam.extend([m - 1, m - 2])

        elif op.UST == '3':  # Egri
            if op.DT3 == '1':
                h1 = (op.VL1 / 200) / u
            elif op.DT3 == '2':
                h1 = op.VL3 / 100
            elif op.DT3 == '3':
                h1 = sin(op.VL4 * pi / 180) / cos(op.VL4 * pi / 180)
            z = sqrt(k1 ** 2 + (k1 * h1) ** 2)
            k = sqrt(k2 ** 2 + (k2 * h1) ** 2)
            f = sqrt(k3 ** 2 + (k3 * h1) ** 2) * 2
            myvertex[ust[0]][2] = zlist[-1] + myvertex[ust[0]][0] * h1
            myvertex[ust[1]][2] = zlist[-1] + myvertex[ust[1]][0] * h1
            for i in alt:
                myvertex[i][2] = zlist[-1] + myvertex[i][0] * h1 - z
            myvertex[son[0]][2] = zlist[-1] + myvertex[son[0]][0] * h1
            myvertex[son[1]][2] = zlist[-1] + myvertex[son[1]][0] * h1
            myfaces.append([ust[1], ust[0], son[0], son[1]])
            for i in range(0, mx * 4, 4):
                myfaces.append([alt[i], alt[i + 1], alt[i + 3], alt[i + 2]])
            on = [ust[0]]
            ar = [ust[1]]
            for i in range(0, len(alt) - 1, 2):
                on.append(alt[i])
                ar.append(alt[i + 1])
            on.append(son[0])
            myfaces.append(on)
            ar.append(son[1])
            ar.reverse()
            myfaces.append(ar)
            y = my - 1
            for x in range(0, mx):
                if kx[x][y] is True:
                    kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
                    n = len(myvertex)
                    myvertex[n - 5][2] = zlist[-1] + myvertex[n - 5][0] * h1 - z
                    myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k
                    myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k
                    myvertex[n - 8][2] = zlist[-1] + myvertex[n - 8][0] * h1 - z
                    myvertex[n - 9][2] = zlist[-1] + myvertex[n - 9][0] * h1 - z
                    myvertex[n - 10][2] = zlist[-1] + myvertex[n - 10][0] * h1 - z - k
                    myvertex[n - 11][2] = zlist[-1] + myvertex[n - 11][0] * h1 - z - k
                    myvertex[n - 12][2] = zlist[-1] + myvertex[n - 12][0] * h1 - z
                    fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
                    n = len(myvertex)
                    myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - k - f
                    myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - k - f
                    myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k - f
                    myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k - f
                    myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z - k
                    myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - k - f
                    myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - k - f
                    myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z - k
                    myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z - k
                    myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - k - f
                    myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - k - f
                    myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z - k
                else:
                    fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
                    n = len(myvertex)
                    myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - f
                    myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - f
                    myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - f
                    myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - f
                    myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z
                    myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - f
                    myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - f
                    myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z
                    myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z
                    myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - f
                    myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - f
                    myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z
                m = len(myfaces)
                cam.extend([m - 1, m - 2])
                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])
        elif op.UST == '4':  # Ucgen
            if op.DT3 == '1':
                h1 = (op.VL1 / 100) / u
            elif op.DT3 == '2':
                h1 = op.VL3 / 100
            elif op.DT3 == '3':
                h1 = sin(op.VL4 * pi / 180) / cos(op.VL4 * pi / 180)
            z = sqrt(k1 ** 2 + (k1 * h1) ** 2)
            k = sqrt(k2 ** 2 + (k2 * h1) ** 2)
            f = sqrt(k3 ** 2 + (k3 * h1) ** 2) * 2
            myvertex[ust[0]][2] = zlist[-1] + myvertex[ust[0]][0] * h1
            myvertex[ust[1]][2] = zlist[-1] + myvertex[ust[1]][0] * h1
            for i in alt:
                myvertex[i][2] = zlist[-1] - abs(myvertex[i][0]) * h1 - z
            myvertex[son[0]][2] = zlist[-1] - myvertex[son[0]][0] * h1
            myvertex[son[1]][2] = zlist[-1] - myvertex[son[1]][0] * h1
            myvertex.extend([[0, -k1 / 2, zlist[-1]], [0, k1 / 2, zlist[-1]]])

            x = 0
            for j in range(2, len(alt) - 2, 4):
                if myvertex[alt[j]][0] < 0 < myvertex[alt[j + 2]][0]:
                    x = 1

            n = len(myvertex)
            myfaces.extend([[ust[1], ust[0], n - 2, n - 1], [n - 1, n - 2, son[0], son[1]]])
            on = [son[0], n - 2, ust[0]]
            ar = [son[1], n - 1, ust[1]]

            if x == 0:
                myvertex.extend([[0, -k1 / 2, zlist[-1] - z], [0, k1 / 2, zlist[-1] - z]])
            for j in range(0, len(alt) - 2, 4):
                if myvertex[alt[j]][0] < 0 and myvertex[alt[j + 2]][0] < 0:
                    myfaces.append([alt[j], alt[j + 1], alt[j + 3], alt[j + 2]])
                    on.extend([alt[j], alt[j + 2]])
                    ar.extend([alt[j + 1], alt[j + 3]])
                elif myvertex[alt[j]][0] > 0 and myvertex[alt[j + 2]][0] > 0:
                    myfaces.append([alt[j], alt[j + 1], alt[j + 3], alt[j + 2]])
                    on.extend([alt[j], alt[j + 2]])
                    ar.extend([alt[j + 1], alt[j + 3]])
                else:
                    n = len(myvertex)
                    myfaces.extend([[alt[j], alt[j + 1], n - 1, n - 2], [n - 2, n - 1, alt[j + 3], alt[j + 2]]])
                    on.extend([alt[j + 0], n - 2, alt[j + 2]])
                    ar.extend([alt[j + 1], n - 1, alt[j + 3]])
            myfaces.append(on)
            ar.reverse()
            myfaces.append(ar)
            y = my - 1
            for x in range(0, mx):
                if myvertex[alt[x * 4]][0] < 0 and myvertex[alt[x * 4 + 2]][0] < 0:
                    if kx[x][y] is True:
                        kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
                        n = len(myvertex)
                        myvertex[n - 5][2] = zlist[-1] + myvertex[n - 5][0] * h1 - z
                        myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k
                        myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k
                        myvertex[n - 8][2] = zlist[-1] + myvertex[n - 8][0] * h1 - z
                        myvertex[n - 9][2] = zlist[-1] + myvertex[n - 9][0] * h1 - z
                        myvertex[n - 10][2] = zlist[-1] + myvertex[n - 10][0] * h1 - z - k
                        myvertex[n - 11][2] = zlist[-1] + myvertex[n - 11][0] * h1 - z - k
                        myvertex[n - 12][2] = zlist[-1] + myvertex[n - 12][0] * h1 - z
                        fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
                        n = len(myvertex)
                        myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - k - f
                        myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - k - f
                        myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - k - f
                        myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - k - f
                        myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z - k
                        myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - k - f
                        myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - k - f
                        myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z - k
                        myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z - k
                        myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - k - f
                        myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - k - f
                        myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z - k
                    else:
                        fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
                        n = len(myvertex)
                        myvertex[n - 2][2] = zlist[-1] + myvertex[n - 2][0] * h1 - z - f
                        myvertex[n - 3][2] = zlist[-1] + myvertex[n - 3][0] * h1 - z - f
                        myvertex[n - 6][2] = zlist[-1] + myvertex[n - 6][0] * h1 - z - f
                        myvertex[n - 7][2] = zlist[-1] + myvertex[n - 7][0] * h1 - z - f
                        myvertex[n - 13][2] = zlist[-1] + myvertex[n - 13][0] * h1 - z
                        myvertex[n - 14][2] = zlist[-1] + myvertex[n - 14][0] * h1 - z - f
                        myvertex[n - 15][2] = zlist[-1] + myvertex[n - 15][0] * h1 - z - f
                        myvertex[n - 16][2] = zlist[-1] + myvertex[n - 16][0] * h1 - z
                        myvertex[n - 17][2] = zlist[-1] + myvertex[n - 17][0] * h1 - z
                        myvertex[n - 18][2] = zlist[-1] + myvertex[n - 18][0] * h1 - z - f
                        myvertex[n - 19][2] = zlist[-1] + myvertex[n - 19][0] * h1 - z - f
                        myvertex[n - 20][2] = zlist[-1] + myvertex[n - 20][0] * h1 - z
                    m = len(myfaces)
                    cam.extend([m - 1, m - 2])
                    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])
                elif myvertex[alt[x * 4]][0] > 0 and myvertex[alt[x * 4 + 2]][0] > 0:
                    if kx[x][y] is True:
                        kapak(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k2 / 2, (k1 + k2) * 0.5 - 0.01)
                        n = len(myvertex)
                        myvertex[n - 5][2] = zlist[-1] - myvertex[n - 5][0] * h1 - z
                        myvertex[n - 6][2] = zlist[-1] - myvertex[n - 6][0] * h1 - z - k
                        myvertex[n - 7][2] = zlist[-1] - myvertex[n - 7][0] * h1 - z - k
                        myvertex[n - 8][2] = zlist[-1] - myvertex[n - 8][0] * h1 - z
                        myvertex[n - 9][2] = zlist[-1] - myvertex[n - 9][0] * h1 - z
                        myvertex[n - 10][2] = zlist[-1] - myvertex[n - 10][0] * h1 - z - k
                        myvertex[n - 11][2] = zlist[-1] - myvertex[n - 11][0] * h1 - z - k
                        myvertex[n - 12][2] = zlist[-1] - myvertex[n - 12][0] * h1 - z
                        fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, (k1 + k2) * 0.5 - 0.01, k2)
                        n = len(myvertex)
                        myvertex[n - 2][2] = zlist[-1] - myvertex[n - 2][0] * h1 - z - k - f
                        myvertex[n - 3][2] = zlist[-1] - myvertex[n - 3][0] * h1 - z - k - f
                        myvertex[n - 6][2] = zlist[-1] - myvertex[n - 6][0] * h1 - z - k - f
                        myvertex[n - 7][2] = zlist[-1] - myvertex[n - 7][0] * h1 - z - k - f
                        myvertex[n - 13][2] = zlist[-1] - myvertex[n - 13][0] * h1 - z - k
                        myvertex[n - 14][2] = zlist[-1] - myvertex[n - 14][0] * h1 - z - k - f
                        myvertex[n - 15][2] = zlist[-1] - myvertex[n - 15][0] * h1 - z - k - f
                        myvertex[n - 16][2] = zlist[-1] - myvertex[n - 16][0] * h1 - z - k
                        myvertex[n - 17][2] = zlist[-1] - myvertex[n - 17][0] * h1 - z - k
                        myvertex[n - 18][2] = zlist[-1] - myvertex[n - 18][0] * h1 - z - k - f
                        myvertex[n - 19][2] = zlist[-1] - myvertex[n - 19][0] * h1 - z - k - f
                        myvertex[n - 20][2] = zlist[-1] - myvertex[n - 20][0] * h1 - z - k
                    else:
                        fitil(myvertex, myfaces, xlist, zlist, x * 2 + 1, y * 2 + 1, k3, 0, 0)
                        n = len(myvertex)
                        myvertex[n - 2][2] = zlist[-1] - myvertex[n - 2][0] * h1 - z - f
                        myvertex[n - 3][2] = zlist[-1] - myvertex[n - 3][0] * h1 - z - f
                        myvertex[n - 6][2] = zlist[-1] - myvertex[n - 6][0] * h1 - z - f
                        myvertex[n - 7][2] = zlist[-1] - myvertex[n - 7][0] * h1 - z - f
                        myvertex[n - 13][2] = zlist[-1] - myvertex[n - 13][0] * h1 - z
                        myvertex[n - 14][2] = zlist[-1] - myvertex[n - 14][0] * h1 - z - f
                        myvertex[n - 15][2] = zlist[-1] - myvertex[n - 15][0] * h1 - z - f
                        myvertex[n - 16][2] = zlist[-1] - myvertex[n - 16][0] * h1 - z
                        myvertex[n - 17][2] = zlist[-1] - myvertex[n - 17][0] * h1 - z
                        myvertex[n - 18][2] = zlist[-1] - myvertex[n - 18][0] * h1 - z - f
                        myvertex[n - 19][2] = zlist[-1] - myvertex[n - 19][0] * h1 - z - f
                        myvertex[n - 20][2] = zlist[-1] - myvertex[n - 20][0] * h1 - z
                    m = len(myfaces)
                    cam.extend([m - 1, m - 2])
                    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])
                else:
                    k4 = k3 * 2
                    if kx[x][y] is True:
                        zz = (k1 + k2) * 0.5 - 0.01
                        xx = xlist[x * 2 + 1]
                        myvertex.extend([[xx, -k2 / 2 + zz, zlist[-3]], [xx + k2, -k2 / 2 + zz, zlist[-3] + k2],
                                         [xx + k2, k2 / 2 + zz, zlist[-3] + k2], [xx, k2 / 2 + zz, zlist[-3]]])
                        myvertex.extend(
                            [[xx, -k2 / 2 + zz, zlist[-1] + xx * h1 - z], [xx + k2, -k2 / 2 + zz,
                                                                           zlist[-1] + (xx + k2) * h1 - z - k],
                             [xx + k2, k2 / 2 + zz, zlist[-1] + (xx + k2) * h1 - z - k],
                             [xx, k2 / 2 + zz, zlist[-1] + xx * h1 - z]])
                        myvertex.extend([[0, -k2 / 2 + zz, zlist[-1] - z], [0, -k2 / 2 + zz, zlist[-1] - z - k],
                                         [0, k2 / 2 + zz, zlist[-1] - z - k], [0, k2 / 2 + zz, zlist[-1] - z]])
                        xx = xlist[x * 2 + 2]
                        myvertex.extend(
                            [[xx, -k2 / 2 + zz, zlist[-1] - xx * h1 - z], [xx - k2, -k2 / 2 + zz,
                                                                           zlist[-1] - (xx - k2) * h1 - z - k],
                             [xx - k2, k2 / 2 + zz, zlist[-1] - (xx - k2) * h1 - z - k],
                             [xx, k2 / 2 + zz, zlist[-1] - xx * h1 - z]])
                        myvertex.extend([[xx, -k2 / 2 + zz, zlist[-3]], [xx - k2, -k2 / 2 + zz, zlist[-3] + k2],
                                         [xx - k2, k2 / 2 + zz, zlist[-3] + k2], [xx, k2 / 2 + zz, zlist[-3]]])
                        n = len(myvertex)
                        myfaces.extend([[n - 20, n - 19, n - 15, n - 16], [n - 19, n - 18, n - 14, n - 15],
                                        [n - 18, n - 17, n - 13, n - 14], [n - 17, n - 20, n - 16, n - 13]])
                        myfaces.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], [n - 13, n - 16, n - 12, n - 9]])
                        myfaces.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],
                             [n - 9, n - 12, n - 8, n - 5]])
                        myfaces.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],
                             [n - 5, n - 8, n - 4, n - 1]])
                        myfaces.extend(
                            [[n - 4, n - 3, n - 19, n - 20], [n - 3, n - 2, n - 18, n - 19],
                             [n - 2, n - 1, n - 17, n - 18],
                             [n - 1, n - 4, n - 20, n - 17]])
                        xx = xlist[x * 2 + 1]
                        myvertex.extend([[xx + k2, -k3 + zz, zlist[-3] + k2], [xx + k4 + k2, -k3 + zz,
                                                                               zlist[-3] + k2 + k4],
                                         [xx + k4 + k2, k3 + zz, zlist[-3] + k2 + k4], [xx + k2, k3 + zz,
                                                                                        zlist[-3] + k2]])
                        myvertex.extend([[xx + k2, -k3 + zz, zlist[-1] + (xx + k2) * h1 - z - k],
                                         [xx + k4 + k2, -k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f],
                                         [xx + k4 + k2, k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f],
                                         [xx + k2, k3 + zz, zlist[-1] + (xx + k2) * h1 - z - k]])
                        myvertex.extend([[0, -k3 + zz, zlist[-1] - k - z], [0, -k3 + zz, zlist[-1] - k - z - f],
                                         [0, k3 + zz, zlist[-1] - k - z - f], [0, k3 + zz, zlist[-1] - k - z]])
                        xx = xlist[x * 2 + 2]
                        myvertex.extend([[xx - k2, -k3 + zz, zlist[-1] - (xx - k2) * h1 - z - k],
                                         [xx - k4 - k2, -k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f],
                                         [xx - k4 - k2, k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f],
                                         [xx - k2, k3 + zz, zlist[-1] - (xx - k2) * h1 - z - k]])
                        myvertex.extend([[xx - k2, -k3 + zz, zlist[-3] + k2],
                                         [xx - k4 - k2, -k3 + zz, zlist[-3] + k2 + k4],
                                         [xx - k4 - k2, k3 + zz, zlist[-3] + k2 + k4],
                                         [xx - k2, k3 + zz, zlist[-3] + k2]])
                        n = len(myvertex)
                        myfaces.extend([[n - 20, n - 19, n - 15, n - 16], [n - 19, n - 18, n - 14, n - 15],
                                        [n - 18, n - 17, n - 13, n - 14]])
                        myfaces.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]])
                        myfaces.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]])
                        myfaces.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]])
                        myfaces.extend([[n - 4, n - 3, n - 19, n - 20], [n - 3, n - 2, n - 18, n - 19],
                                        [n - 2, n - 1, n - 17, n - 18]])
                        xx = xlist[x * 2 + 1]
                        myvertex.extend(
                            [[xx + k4 + k2, -k3 + zz, zlist[-3] + k2 + k4], [xx + k4 + k2, k3 + zz, zlist[-3] +
                                                                             k2 + k4]])
                        myvertex.extend([[xx + k4 + k2, -k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f],
                                         [xx + k4 + k2, k3 + zz, zlist[-1] + (xx + k2 + k4) * h1 - z - k - f]])
                        myvertex.extend([[0, -k3 + zz, zlist[-1] - k - z - f], [0, k3 + zz, zlist[-1] - k - z - f]])
                        xx = xlist[x * 2 + 2]
                        myvertex.extend([[xx - k4 - k2, -k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f],
                                         [xx - k4 - k2, k3 + zz, zlist[-1] - (xx - k2 - k4) * h1 - z - k - f]])
                        myvertex.extend(
                            [[xx - k4 - k2, -k3 + zz, zlist[-3] + k2 + k4], [xx - k4 - k2, k3 + zz, zlist[-3] +
                                                                             k2 + k4]])
                        myfaces.extend([[n + 8, n + 6, n + 4, n + 2, n + 0], [n + 1, n + 3, n + 5, n + 7, n + 9]])
                    else:
                        xx = xlist[x * 2 + 1]
                        myvertex.extend(
                            [[xx, -k3, zlist[-3]], [xx + k4, -k3, zlist[-3] + k4], [xx + k4, k3, zlist[-3] + k4],
                             [xx, k3, zlist[-3]]])
                        myvertex.extend(
                            [[xx, -k3, zlist[-1] + xx * h1 - z], [xx + k4, -k3, zlist[-1] + (xx + k4) * h1 - z - f],
                             [xx + k4, k3, zlist[-1] + (xx + k4) * h1 - z - f], [xx, k3, zlist[-1] + xx * h1 - z]])
                        myvertex.extend(
                            [[0, -k3, zlist[-1] - z], [0, -k3, zlist[-1] - z - f], [0, k3, zlist[-1] - z - f],
                             [0, k3, zlist[-1] - z]])
                        xx = xlist[x * 2 + 2]
                        myvertex.extend(
                            [[xx, -k3, zlist[-1] - xx * h1 - z], [xx - k4, -k3, zlist[-1] - (xx - k4) * h1 - z - f],
                             [xx - k4, k3, zlist[-1] - (xx - k4) * h1 - z - f], [xx, k3, zlist[-1] - xx * h1 - z]])
                        myvertex.extend(
                            [[xx, -k3, zlist[-3]], [xx - k4, -k3, zlist[-3] + k4], [xx - k4, k3, zlist[-3] + k4],
                             [xx, k3, zlist[-3]]])
                        n = len(myvertex)
                        myfaces.extend([[n - 20, n - 19, n - 15, n - 16], [n - 19, n - 18, n - 14, n - 15],
                                        [n - 18, n - 17, n - 13, n - 14]])
                        myfaces.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]])
                        myfaces.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]])
                        myfaces.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]])
                        myfaces.extend([[n - 4, n - 3, n - 19, n - 20], [n - 3, n - 2, n - 18, n - 19],
                                        [n - 2, n - 1, n - 17, n - 18]])
                        xx = xlist[x * 2 + 1]
                        myvertex.extend([[xx + k4, -0.005, zlist[-3] + k4], [xx + k4, 0.005, zlist[-3] + k4]])
                        myvertex.extend([[xx + k4, -0.005, zlist[-1] + (xx + k4) * h1 - z - f],
                                         [xx + k4, 0.005, zlist[-1] + (xx + k4) * h1 - z - f]])
                        myvertex.extend([[0, -0.005, zlist[-1] - z - f], [0, 0.005, zlist[-1] - z - f]])
                        xx = xlist[x * 2 + 2]
                        myvertex.extend([[xx - k4, -0.005, zlist[-1] - (xx - k4) * h1 - z - f],
                                         [xx - k4, 0.005, zlist[-1] - (xx - k4) * h1 - z - f]])
                        myvertex.extend([[xx - k4, -0.005, zlist[-3] + k4], [xx - k4, 0.005, zlist[-3] + k4]])
                        myfaces.extend([[n + 8, n + 6, n + 4, n + 2, n + 0], [n + 1, n + 3, n + 5, n + 7, n + 9]])
                    m = len(myfaces)
                    cam.extend([m - 1, m - 2])
                    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, m - 15,
                         m - 16, m - 17])
        # Mermer
        if op.mr is True:
            mrh = -op.mr1 / 100
            mrg = op.mr2 / 100
            mdv = (op.mr3 / 200) + mrg
            msv = -(mdv + (op.mr4 / 100))
            myvertex.extend([[-u, mdv, 0], [u, mdv, 0], [-u, msv, 0], [u, msv, 0], [-u, mdv, mrh], [u, mdv, mrh],
                             [-u, msv, mrh],
                             [u, msv, mrh]])
            n = len(myvertex)
            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],
                            [n - 2, n - 1, n - 5, n - 6], [n - 4, n - 2, n - 6, n - 8], [n - 5, n - 1, n - 3, n - 7]])
            n = len(myfaces)
            mer.extend([n - 1, n - 2, n - 3, n - 4, n - 5, n - 6])

        return True, ftl, cam, mer, sm
    except:
        return False, None, None, None, None


# ------------------------------------
# Get highest points of the panel
# ------------------------------------
def get_high_points(selobject, width, tip):
    obverts = selobject.data.vertices

    top_a = 0
    top_b = 0
    top_c = 0
    # --------------------------
    # Recover all vertex
    # --------------------------
    for vertex in obverts:
        if vertex.co[0] == -width / 2:
            if vertex.co[2] >= top_a:
                top_a = vertex.co[2]
        if vertex.co[0] == width / 2:
            if vertex.co[2] >= top_b:
                top_b = vertex.co[2]
        # top center
        if tip == "2":
            if vertex.co[2] >= top_c:
                top_c = vertex.co[2]
        else:
            if vertex.co[0] == 0 and vertex.co[2] >= top_c:
                top_c = vertex.co[2]

    return top_a, top_b, top_c


# ---------------------------------------------------------
# Defines a point
# ---------------------------------------------------------
class Cpoint:

    def __init__(self, x, y):
        self.x = float(x)
        self.y = float(y)


# ---------------------------------------------------------
# Get angle between two vectors
# ---------------------------------------------------------
def get_angle(p1, p2):
    v1 = Vector((p1[0], 0.0, p1[1]))
    v2 = Vector((p2[0], 0.0, p2[1]))

    a = v1.angle(v2)
    return a


# ---------------------------------------------------------
# Get center of circle base on 3 points
#
# Point a: (x,z)
# Point b: (x,z)
# Point c: (x,z)
# Return:
# x, y: center position
#  r: radio
# ang: angle
# ---------------------------------------------------------
def get_circle_center(a, b, c):
    try:
        # line between a and b: s1 + k * d1
        s1 = Cpoint((a.x + b.x) / 2.0, (a.y + b.y) / 2.0)
        d1 = Cpoint(b.y - a.y, a.x - b.x)
        # line between a and c: s2 + k * d2
        s2 = Cpoint((a.x + c.x) / 2.0, (a.y + c.y) / 2.0)
        d2 = Cpoint(c.y - a.y, a.x - c.x)
        # intersection of both lines:
        l = d1.x * (s2.y - s1.y) - d1.y * (s2.x - s1.x)
        l /= d2.x * d1.y - d2.y * d1.x
        center = Cpoint(s2.x + l * d2.x, s2.y + l * d2.y)
        dx = center.x - a.x
        dy = center.y - a.y
        radio = sqrt(dx * dx + dy * dy)

        # angle
        v1 = (a.x - center.x, a.y - center.y)
        v2 = (b.x - center.x, b.y - center.y)
        ang = get_angle(v1, v2)
        return center, radio, ang
    except ZeroDivisionError:
        return Cpoint(0, 0), 1, 1


# -----------------------------------------
# Get limits
# lb, rb: limits x
# lt, rt: limits z
# mp: limit z in med point
# lo: Z low limit
# my: max y
# top: top vertex
# -----------------------------------------
def get_limits(myobject):
    verts = myobject.data.vertices

    lb = 0
    lt = 0
    rb = 0
    rt = 0
    mp = 0
    lo = 0
    my = 0
    top = 0
    for v in verts:
        if v.co[2] > top:
            top = v.co[2]

        if v.co[2] < lo:
            lo = v.co[2]

        if v.co[1] > my:
            my = v.co[1]
        if v.co[0] > rb:
            rb = v.co[0]
        if v.co[0] < lb:
            lb = v.co[0]
        if v.co[0] == 0:
            if v.co[2] > mp:
                mp = v.co[2]
    # max sides
    for v in verts:
        if v.co[2] > lt and v.co[0] == lb:
            lt = v.co[2]
        if v.co[2] > rt and v.co[0] == rb:
            rt = v.co[2]

    return lb, lt, rb, rt, mp, lo, my, top


# ------------------------------------------
# Create control box for panels
#
# ------------------------------------------
def create_ctrl_box(parentobj, objname):
    myvertex = []
    myfaces = []

    o = parentobj
    op = o.WindowPanelGenerator[0]

    lb, lt, rb, rt, mp, lo, my, top = get_limits(o)
    ypos = my * 1.8
    # -----------------------------
    # Flat, Triangle and inclined
    # -----------------------------
    if op.UST == "1" or op.UST == "3" or op.UST == "4":
        if mp == 0:
            myvertex.extend([(lb, ypos, lo), (lb, ypos, lt), (rb, ypos, rt), (rb, ypos, lo)])
            myvertex.extend([(lb, -ypos, lo), (lb, -ypos, lt), (rb, -ypos, rt), (rb, -ypos, lo)])
            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)])
        else:
            myvertex.extend([(lb, ypos, lo), (lb, ypos, lt), (0, ypos, mp), (rb, ypos, rt), (rb, ypos, lo)])
            myvertex.extend([(lb, -ypos, lo), (lb, -ypos, lt), (0, -ypos, mp), (rb, -ypos, rt), (rb, -ypos, lo)])
            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),
                            (0, 4, 9, 5)])
    # -----------------------------
    # Arch
    # -----------------------------
    if op.UST == "2":
        center, r, ang = get_circle_center(Cpoint(lb, lt), Cpoint(0, top), Cpoint(rb, rt))

        # cx = center.x
        cz = center.y

        sg = op.res
        arc = ((pi / 2) + ang) - ((pi / 2) - ang)
        step = arc / sg
        a = (pi / 2) + ang

        myvertex.extend([(lb, ypos, lt), (lb, -ypos, lt)])
        for x in range(0, sg):
            myvertex.extend([(r * cos(a), ypos, r * sin(a) + cz),
                             (r * cos(a), -ypos, r * sin(a) + cz)])
            a -= step

        # close sides
        myvertex.extend([(rb, ypos, rt), (rb, -ypos, rt)])

        v = 0
        nf = len(myvertex)
        for x in range(0, nf - 2, 2):
            myfaces.extend([(v, v + 1, v + 3, v + 2)])
            v += 2

        nf = len(myvertex)
        myvertex.extend([(lb, ypos, lo), (lb, -ypos, lo)])
        myvertex.extend([(rb, ypos, lo), (rb, -ypos, lo)])

        nf2 = len(myvertex)
        myfaces.extend([(0, nf2 - 4, nf2 - 3, 1)])
        myfaces.extend([(nf - 2, nf - 1, nf2 - 1, nf2 - 2)])

        nf2 = len(myvertex)
        myfaces.extend([(nf2 - 4, nf2 - 2, nf2 - 1, nf2 - 3)])

    # --------------------------
    # Create mesh
    # --------------------------
    myfaces = check_mesh_errors(myvertex, myfaces)
    mymesh = bpy.data.meshes.new(objname)
    myobj = bpy.data.objects.new(objname, mymesh)

    myobj.location = bpy.context.scene.cursor.location
    bpy.context.collection.objects.link(myobj)

    mymesh.from_pydata(myvertex, [], myfaces)
    mymesh.update(calc_edges=True)

    return myobj


# ------------------------------------------------------------------
# Define property group class to create or modify
# ------------------------------------------------------------------
class GeneralPanelProperties(PropertyGroup):
    prs: EnumProperty(
            items=(
                ('1', "WINDOW 250X200", ""),
                ('2', "WINDOW 200X200", ""),
                ('3', "WINDOW 180X200", ""),
                ('4', "WINDOW 180X160", ""),
                ('5', "WINDOW 160X160", ""),
                ('6', "WINDOW 50X50", ""),
                ('7', "DOOR 80X250", ""),
                ('8', "DOOR 80X230", ""),
                ),
            name="",
            description='Predefined types',
            update=update_using_default,
            )
    son: EnumProperty(
            items=(
                ('1', "WINDOW 250X200", ""),
                ('2', "WINDOW 200X200", ""),
                ('3', "WINDOW 180X200", ""),
                ('4', "WINDOW 180X160", ""),
                ('5', "WINDOW 160X160", ""),
                ('6', "WINDOW 50X50", ""),
                ('7', "DOOR 80X250", ""),
                ('8', "DOOR 80X230", ""),
                ),
            name="",
            description='Predefined types',
            update=update_using_default,
            )
    gen: IntProperty(
            name='H Count', min=1, max=8, default=3,
            description='Horizontal Panes',
            update=update_window,
            )
    yuk: IntProperty(
            name='V Count', min=1, max=5, default=1,
            description='Vertical Panes',
            update=update_window,
            )
    kl1: IntProperty(
            name='Outer Frame', min=2, max=50, default=5,
            description='Outside Frame Thickness',
            update=update_window,
            )
    kl2: IntProperty(
            name='Risers', min=2, max=50, default=5,
            description='Risers Width',
            update=update_window,
            )
    fk: IntProperty(
            name='Inner Frame', min=1, max=20, default=2,
            description='Inside Frame Thickness',
            update=update_window,
            )

    mr: BoolProperty(name='Sill', default=True, description='Window Sill', update=update_window)
    mr1: IntProperty(name='', min=1, max=20, default=4, description='Height', update=update_window)
    mr2: IntProperty(name='', min=0, max=20, default=4, description='First Depth', update=update_window)
    mr3: IntProperty(name='', min=1, max=50, default=20, description='Second Depth', update=update_window)
    mr4: IntProperty(name='', min=0, max=50, default=0, description='Extrusion for Jamb',
                                update=update_window)

    mt1: EnumProperty(
            items=(
                ('1', "PVC", ""),
                ('2', "WOOD", ""),
                ('3', "Plastic", ""),
                ),
            name="",
            default='1',
            description='Material to use',
            update=update_window,
            )
    mt2: EnumProperty(
            items=(
                ('1', "PVC", ""),
                ('2', "WOOD", ""),
                ('3', "Plastic", ""),
                ),
            name="",
            default='3',
            description='Material to use',
            update=update_window,
            )

    r: FloatProperty(
            name='Rotation',
            min=0, max=360, default=0, precision=1,
            description='Panel rotation',
            update=update_window,
            )

    UST: EnumProperty(
            items=(
                ('1', "Flat", ""),
                ('2', "Arch", ""),
                ('3', "Inclined", ""),
                ('4', "Triangle", ""),
                ),
            name="Top", default='1',
            description='Type of window upper section',
            update=update_window,
            )
    DT2: EnumProperty(
            items=(
                ('1', "Difference", ""),
                ('2', "Radius", ""),
                ),
            name="",
            default='1',
            update=update_window,
            )
    DT3: EnumProperty(
            items=(
                ('1', "Difference", ""),
                ('2', "Incline %", ""),
                ('3', "Incline Angle", ""),
                ),
            name="",
            default='1', update=update_window,
            )

    VL1: IntProperty(name='', min=-10000, max=10000, default=30, update=update_window)  # Fark
    VL2: IntProperty(name='', min=1, max=10000, default=30, update=update_window)  # Cap
    VL3: IntProperty(name='', min=-100, max=100, default=30, update=update_window)  # Egim %
    VL4: IntProperty(name='', min=-45, max=45, default=30, update=update_window)  # Egim Aci

    res: IntProperty(name='Resolution', min=2, max=360, default=36, update=update_window)  # Res

    gnx0: IntProperty(name='', min=1, max=300, default=60, description='1st Window Width',
                                 update=update_window)
    gnx1: IntProperty(name='', min=1, max=300, default=110, description='2nd Window Width',
                                 update=update_window)
    gnx2: IntProperty(name='', min=1, max=300, default=60, description='3rd Window Width',
                                 update=update_window)
    gnx3: IntProperty(name='', min=1, max=300, default=60, description='4th Window Width',
                                 update=update_window)
    gnx4: IntProperty(name='', min=1, max=300, default=60, description='5th Window Width',
                                 update=update_window)
    gnx5: IntProperty(name='', min=1, max=300, default=60, description='6th Window Width',
                                 update=update_window)
    gnx6: IntProperty(name='', min=1, max=300, default=60, description='7th Window Width',
                                 update=update_window)
    gnx7: IntProperty(name='', min=1, max=300, default=60, description='8th Window Width',
                                 update=update_window)

    gny0: IntProperty(name='', min=1, max=300, default=190, description='1st Row Height',
                                 update=update_window)
    gny1: IntProperty(name='', min=1, max=300, default=45, description='2nd Row Height',
                                 update=update_window)
    gny2: IntProperty(name='', min=1, max=300, default=45, description='3rd Row Height',
                                 update=update_window)
    gny3: IntProperty(name='', min=1, max=300, default=45, description='4th Row Height',
                                 update=update_window)
    gny4: IntProperty(name='', min=1, max=300, default=45, description='5th Row Height',
                                 update=update_window)

    k00: BoolProperty(name='', default=True, update=update_window)
    k01: BoolProperty(name='', default=False, update=update_window)
    k02: BoolProperty(name='', default=True, update=update_window)
    k03: BoolProperty(name='', default=False, update=update_window)
    k04: BoolProperty(name='', default=False, update=update_window)
    k05: BoolProperty(name='', default=False, update=update_window)
    k06: BoolProperty(name='', default=False, update=update_window)
    k07: BoolProperty(name='', default=False, update=update_window)

    k10: BoolProperty(name='', default=False, update=update_window)
    k11: BoolProperty(name='', default=False, update=update_window)
    k12: BoolProperty(name='', default=False, update=update_window)
    k13: BoolProperty(name='', default=False, update=update_window)
    k14: BoolProperty(name='', default=False, update=update_window)
    k15: BoolProperty(name='', default=False, update=update_window)
    k16: BoolProperty(name='', default=False, update=update_window)
    k17: BoolProperty(name='', default=False, update=update_window)

    k20: BoolProperty(name='', default=False, update=update_window)
    k21: BoolProperty(name='', default=False, update=update_window)
    k22: BoolProperty(name='', default=False, update=update_window)
    k23: BoolProperty(name='', default=False, update=update_window)
    k24: BoolProperty(name='', default=False, update=update_window)
    k25: BoolProperty(name='', default=False, update=update_window)
    k26: BoolProperty(name='', default=False, update=update_window)
    k27: BoolProperty(name='', default=False, update=update_window)

    k30: BoolProperty(name='', default=False, update=update_window)
    k31: BoolProperty(name='', default=False, update=update_window)
    k32: BoolProperty(name='', default=False, update=update_window)
    k33: BoolProperty(name='', default=False, update=update_window)
    k34: BoolProperty(name='', default=False, update=update_window)
    k35: BoolProperty(name='', default=False, update=update_window)
    k36: BoolProperty(name='', default=False, update=update_window)
    k37: BoolProperty(name='', default=False, update=update_window)

    k40: BoolProperty(name='', default=False, update=update_window)
    k41: BoolProperty(name='', default=False, update=update_window)
    k42: BoolProperty(name='', default=False, update=update_window)
    k43: BoolProperty(name='', default=False, update=update_window)
    k44: BoolProperty(name='', default=False, update=update_window)
    k45: BoolProperty(name='', default=False, update=update_window)
    k46: BoolProperty(name='', default=False, update=update_window)
    k47: BoolProperty(name='', default=False, update=update_window)
    # opengl internal data
    glpoint_a: FloatVectorProperty(
            name="glpointa",
            description="Hidden property for opengl",
            default=(0, 0, 0),
            )
    glpoint_b: FloatVectorProperty(
            name="glpointb",
            description="Hidden property for opengl",
            default=(0, 0, 0),
            )
    glpoint_c: FloatVectorProperty(
            name="glpointc",
            description="Hidden property for opengl",
            default=(0, 0, 0),
            )
    glpoint_d: FloatVectorProperty(
            name="glpointc",
            description="Hidden property for opengl",
            default=(0, 0, 0),
            )


bpy.utils.register_class(GeneralPanelProperties)
Object.WindowPanelGenerator = CollectionProperty(type=GeneralPanelProperties)


# ------------------------------------------------------------------
# Define panel class to modify myobjects.
# ------------------------------------------------------------------
class ARCHIMESH_PT_WindowEdit(Panel):
    bl_idname = "ARCHIMESH_PT_window_edit"
    bl_label = "Window Panel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'Create'

    # -----------------------------------------------------
    # Verify if visible
    # -----------------------------------------------------
    @classmethod
    def poll(cls, context):
        o = context.object
        if o is None:
            return False
        if 'WindowPanelGenerator' not in o:
            return False
        else:
            return True

    # -----------------------------------------------------
    # Draw (create UI interface)
    # -----------------------------------------------------
    def draw(self, context):
        o = context.object
        # If the selected object didn't be created with the group 'WindowPanelGenerator', this panel is not created.
        # noinspection PyBroadException
        try:
            if 'WindowPanelGenerator' not in o:
                return
        except:
            return

        layout = self.layout
        if bpy.context.mode == 'EDIT_MESH':
            layout.label(text='Warning: Operator does not work in edit mode.', icon='ERROR')
        else:
            myobject = o.WindowPanelGenerator[0]
            layout.prop(myobject, 'prs')
            box = layout.box()
            box.prop(myobject, 'gen')
            box.prop(myobject, 'yuk')
            box.prop(myobject, 'kl1')
            box.prop(myobject, 'kl2')
            box.prop(myobject, 'fk')
            box.prop(myobject, 'r')  # rotation

            box.prop(myobject, 'mr')
            if myobject.mr is True:
                row = box.row()
                row.prop(myobject, 'mr1')
                row.prop(myobject, 'mr2')
                row = box.row()
                row.prop(myobject, 'mr3')
                row.prop(myobject, 'mr4')
            row = layout.row()
            row.label(text='Frame')
            row.label(text='Inner Frame')
            row = layout.row()
            row.prop(myobject, 'mt1')
            row.prop(myobject, 'mt2')

            box.prop(myobject, 'UST')
            if myobject.UST == '2':
                row = box.row()
                row.prop(myobject, 'DT2')
                if myobject.DT2 == '1':
                    row.prop(myobject, 'VL1')
                elif myobject.DT2 == '2':
                    row.prop(myobject, 'VL2')
                box.prop(myobject, 'res')
            elif myobject.UST == '3':
                row = box.row()
                row.prop(myobject, 'DT3')
                if myobject.DT3 == '1':
                    row.prop(myobject, 'VL1')
                elif myobject.DT3 == '2':
                    row.prop(myobject, 'VL3')
                elif myobject.DT3 == '3':
                    row.prop(myobject, 'VL4')
            elif myobject.UST == '4':
                row = box.row()
                row.prop(myobject, 'DT3')
                if myobject.DT3 == '1':
                    row.prop(myobject, 'VL1')
                elif myobject.DT3 == '2':
                    row.prop(myobject, 'VL3')
                elif myobject.DT3 == '3':
                    row.prop(myobject, 'VL4')
            row = layout.row()
            for i in range(0, myobject.gen):
                row.prop(myobject, 'gnx' + str(i))
            for j in range(0, myobject.yuk):
                row = layout.row()
                row.prop(myobject, 'gny' + str(myobject.yuk - j - 1))
                for i in range(0, myobject.gen):
                    row.prop(myobject, 'k' + str(myobject.yuk - j - 1) + str(i))