createMesh.py

    vec3 = Vector([x, y, 0.0])
    verts.append([x, y, -Flat_Height - Undercut_Height])
    Row += 1

    # Under cut to Shank BEVEL
    x = sin(radians(0)) * (SHANK_RADIUS + Shank_Bevel)
    y = cos(radians(0)) * (SHANK_RADIUS + Shank_Bevel)
    vec1 = Vector([x, y, 0.0])
    verts.append([x, y, -Flat_Height - Undercut_Height])

    x = sin(radians(60 / 6)) * (SHANK_RADIUS + Shank_Bevel)
    y = cos(radians(60 / 6)) * (SHANK_RADIUS + Shank_Bevel)
    vec2 = Vector([x, y, 0.0])
    verts.append([x, y, -Flat_Height - Undercut_Height])

    x = sin(radians(60 / 3)) * (SHANK_RADIUS + Shank_Bevel)
    y = cos(radians(60 / 3)) * (SHANK_RADIUS + Shank_Bevel)
    vec3 = Vector([x, y, 0.0])
    verts.append([x, y, -Flat_Height - Undercut_Height])

    x = sin(radians(60 / 2)) * (SHANK_RADIUS + Shank_Bevel)
    y = cos(radians(60 / 2)) * (SHANK_RADIUS + Shank_Bevel)
    vec3 = Vector([x, y, 0.0])
    verts.append([x, y, -Flat_Height - Undercut_Height])
    Row += 1

    # Under cut to Shank BEVEL
    x = sin(radians(0)) * SHANK_RADIUS
    y = cos(radians(0)) * SHANK_RADIUS
    vec1 = Vector([x, y, 0.0])
    verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])

    x = sin(radians(60 / 6)) * SHANK_RADIUS
    y = cos(radians(60 / 6)) * SHANK_RADIUS
    vec2 = Vector([x, y, 0.0])
    verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])

    x = sin(radians(60 / 3)) * SHANK_RADIUS
    y = cos(radians(60 / 3)) * SHANK_RADIUS
    vec3 = Vector([x, y, 0.0])
    verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])

    x = sin(radians(60 / 2)) * SHANK_RADIUS
    y = cos(radians(60 / 2)) * SHANK_RADIUS
    vec3 = Vector([x, y, 0.0])
    verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])
    Row += 1

    faces.extend(Build_Face_List_Quads(FaceStart, 3, Row - 1))

    Mirror_Verts, Mirror_Faces = Mirror_Verts_Faces(verts, faces, 'y')
    verts.extend(Mirror_Verts)
    faces.extend(Mirror_Faces)

    Spin_Verts, Spin_Faces = SpinDup(verts, faces, 360, 6, 'z')

    return Spin_Verts, Spin_Faces, 0 - (-HEIGHT)



def Create_12_Point(FLAT, HOLE_DIA, SHANK_DIA, HEIGHT,FLANGE_DIA):
    FLANGE_HEIGHT = (1.89/8.0)*HEIGHT
    FLAT_HEIGHT = (4.18/8.0)*HEIGHT
#     FLANGE_DIA = (13.27/8.0)*FLAT

    FLANGE_RADIUS = FLANGE_DIA * 0.5
    FLANGE_TAPPER_HEIGHT =  HEIGHT - FLANGE_HEIGHT - FLAT_HEIGHT

#     HOLE_DIA = 0.0

    verts = []
    faces = []
    HOLE_RADIUS = HOLE_DIA / 2
    Half_Flat = FLAT / 2
    TopBevelRadius = Half_Flat - (Half_Flat * (0.05 / 8))
#     Undercut_Height = (Half_Flat * (0.05 / 8))
#     Shank_Bevel = (Half_Flat * (0.05 / 8))
#     Flat_Height = HEIGHT - Undercut_Height - Shank_Bevel
    # Undercut_Height = 5
    SHANK_RADIUS = SHANK_DIA / 2
    Row = 0

    verts.append([0.0, 0.0, 0.0])

#     print("HOLE_RADIUS" + str(HOLE_RADIUS))
#     print("TopBevelRadius" + str(TopBevelRadius))

    FaceStart = len(verts)

    # inner hole
    x = sin(radians(0)) * HOLE_RADIUS
    y = cos(radians(0)) * HOLE_RADIUS
    verts.append([x, y, 0.0])

    x = sin(radians(5)) * HOLE_RADIUS
    y = cos(radians(5)) * HOLE_RADIUS
    verts.append([x, y, 0.0])

    x = sin(radians(10)) * HOLE_RADIUS
    y = cos(radians(10)) * HOLE_RADIUS
    verts.append([x, y, 0.0])

    x = sin(radians(15)) * HOLE_RADIUS
    y = cos(radians(15)) * HOLE_RADIUS
    verts.append([x, y, 0.0])

    x = sin(radians(20)) * HOLE_RADIUS
    y = cos(radians(20)) * HOLE_RADIUS
    verts.append([x, y, 0.0])

    x = sin(radians(25)) * HOLE_RADIUS
    y = cos(radians(25)) * HOLE_RADIUS
    verts.append([x, y, 0.0])

    x = sin(radians(30)) * HOLE_RADIUS
    y = cos(radians(30)) * HOLE_RADIUS
    verts.append([x, y, 0.0])

    Row += 1



    # bevel
    x = sin(radians(0)) * TopBevelRadius
    y = cos(radians(0)) * TopBevelRadius
    vec1 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    x = sin(radians(5)) * TopBevelRadius
    y = cos(radians(5)) * TopBevelRadius
    vec2 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    x = sin(radians(10)) * TopBevelRadius
    y = cos(radians(10)) * TopBevelRadius
    vec3 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    x = sin(radians(15)) * TopBevelRadius
    y = cos(radians(15)) * TopBevelRadius
    vec4 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    x = sin(radians(20)) * TopBevelRadius
    y = cos(radians(20)) * TopBevelRadius
    vec5 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    x = sin(radians(25)) * TopBevelRadius
    y = cos(radians(25)) * TopBevelRadius
    vec6 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    x = sin(radians(30)) * TopBevelRadius
    y = cos(radians(30)) * TopBevelRadius
    vec7 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    Row += 1


    #45Deg bevel on the top

    #First we work out how far up the Y axis the vert is
    v_origin = Vector([0.0,0.0,0.0]) # center of the model
    v_15Deg_Point = Vector([tan(radians(15)) * Half_Flat,Half_Flat,0.0])  #Is a know point to work back from

    x = tan(radians(0)) * Half_Flat
    Point_Distance =(tan(radians(30)) * v_15Deg_Point.x)+Half_Flat
    dvec = vec1 - Vector([x, Point_Distance, 0.0])
    verts.append([x, Point_Distance, -dvec.length])
    v_0_Deg_Top_Point = Vector([x, Point_Distance, -dvec.length])

    v_0_Deg_Point = Vector([x, Point_Distance,0.0])

    v_5Deg_Line = Vector([tan(radians(5)) * Half_Flat, Half_Flat, 0.0])
    v_5Deg_Line.length *= 2  # extende out the line on a 5 deg angle

    #We cross 2 lines. One from the origin to the 0 Deg point
    #and the second is from the origin extended out past the first line
    # This gives the cross point of the
    v_Cross = geometry.intersect_line_line_2d(v_0_Deg_Point,v_15Deg_Point,v_origin,v_5Deg_Line)
    dvec = vec2 - Vector([v_Cross.x,v_Cross.y,0.0])
    verts.append([v_Cross.x,v_Cross.y,-dvec.length])
    v_5_Deg_Top_Point = Vector([v_Cross.x,v_Cross.y,-dvec.length])

    v_10Deg_Line = Vector([tan(radians(10)) * Half_Flat, Half_Flat, 0.0])
    v_10Deg_Line.length *= 2  # extende out the line

    v_Cross = geometry.intersect_line_line_2d(v_0_Deg_Point,v_15Deg_Point,v_origin,v_10Deg_Line)
    dvec = vec3 - Vector([v_Cross.x,v_Cross.y,0.0])
    verts.append([v_Cross.x,v_Cross.y,-dvec.length])
    v_10_Deg_Top_Point = Vector([v_Cross.x,v_Cross.y,-dvec.length])

    #The remain points are stright forward because y is all the same y height (Half_Flat)
    x = tan(radians(15)) * Half_Flat
    dvec = vec4 - Vector([x, Half_Flat, 0.0])
    Lowest_Point = -dvec.length
    verts.append([x, Half_Flat, -dvec.length])
    v_15_Deg_Top_Point = Vector([x, Half_Flat, -dvec.length])

    x = tan(radians(20)) * Half_Flat
    dvec = vec5 - Vector([x, Half_Flat, 0.0])
    Lowest_Point = -dvec.length
    verts.append([x, Half_Flat, -dvec.length])
    v_20_Deg_Top_Point = Vector([x, Half_Flat, -dvec.length])

    x = tan(radians(25)) * Half_Flat
    dvec = vec6 - Vector([x, Half_Flat, 0.0])
    Lowest_Point = -dvec.length
    verts.append([x, Half_Flat, -dvec.length])
    v_25_Deg_Top_Point = Vector([x, Half_Flat, -dvec.length])

    x = tan(radians(30)) * Half_Flat
    dvec = vec7 - Vector([x, Half_Flat, 0.0])
    Lowest_Point = -dvec.length
    verts.append([x, Half_Flat, -dvec.length])
    v_30_Deg_Top_Point = Vector([x, Half_Flat, -dvec.length])
    Row += 1


    #Down Bits
#     print ("Point_Distance")
#     print (Point_Distance)



    Flange_Adjacent  = FLANGE_RADIUS - Point_Distance
    if (Flange_Adjacent  == 0.0):
        Flange_Adjacent  = 0.000001
    Flange_Opposite = FLANGE_TAPPER_HEIGHT

#     print ("Flange_Opposite")
#     print (Flange_Opposite)
#     print ("Flange_Adjacent")
#     print (Flange_Adjacent)

    FLANGE_ANGLE_RAD = atan(Flange_Opposite/Flange_Adjacent )
#     FLANGE_ANGLE_RAD = radians(45)
#     print("FLANGE_ANGLE_RAD")
#     print (degrees (FLANGE_ANGLE_RAD))


    v_Extended_Flange_Edge = Vector([0.0,0.0,-HEIGHT + FLANGE_HEIGHT + (tan(FLANGE_ANGLE_RAD)* FLANGE_RADIUS) ])
#     print("v_Extended_Flange_Edge")
#     print (v_Extended_Flange_Edge)

    #0deg
    v_Flange_Edge = Vector([sin(radians(0)) * FLANGE_RADIUS,cos(radians(0)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT ])
    v_Cross = geometry.intersect_line_line(v_0_Deg_Top_Point,Vector([v_0_Deg_Top_Point.x,v_0_Deg_Top_Point.y,-HEIGHT]),v_Flange_Edge,v_Extended_Flange_Edge)
    verts.append(v_Cross[0])

    #5deg
    v_Flange_Edge = Vector([sin(radians(5)) * FLANGE_RADIUS,cos(radians(5)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT ])
    v_Cross = geometry.intersect_line_line(v_5_Deg_Top_Point,Vector([v_5_Deg_Top_Point.x,v_5_Deg_Top_Point.y,-HEIGHT]),v_Flange_Edge,v_Extended_Flange_Edge)
    verts.append(v_Cross[0])

    #10deg
    v_Flange_Edge = Vector([sin(radians(10)) * FLANGE_RADIUS,cos(radians(10)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT ])
    v_Cross = geometry.intersect_line_line(v_10_Deg_Top_Point,Vector([v_10_Deg_Top_Point.x,v_10_Deg_Top_Point.y,-HEIGHT]),v_Flange_Edge,v_Extended_Flange_Edge)
    verts.append(v_Cross[0])

    #15deg
    v_Flange_Edge = Vector([sin(radians(15)) * FLANGE_RADIUS,cos(radians(15)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT ])
    v_Cross = geometry.intersect_line_line(v_15_Deg_Top_Point,Vector([v_15_Deg_Top_Point.x,v_15_Deg_Top_Point.y,-HEIGHT]),v_Flange_Edge,v_Extended_Flange_Edge)
    verts.append(v_Cross[0])


    #20deg
    v_Flange_Edge = Vector([sin(radians(20)) * FLANGE_RADIUS,cos(radians(20)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT ])
    v_Cross = geometry.intersect_line_line(v_20_Deg_Top_Point,Vector([v_20_Deg_Top_Point.x,v_20_Deg_Top_Point.y,-HEIGHT]),v_Flange_Edge,v_Extended_Flange_Edge)
    verts.append(v_Cross[0])

    #25deg
    v_Flange_Edge = Vector([sin(radians(25)) * FLANGE_RADIUS,cos(radians(25)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT ])
    v_Cross = geometry.intersect_line_line(v_25_Deg_Top_Point,Vector([v_25_Deg_Top_Point.x,v_25_Deg_Top_Point.y,-HEIGHT]),v_Flange_Edge,v_Extended_Flange_Edge)
    verts.append(v_Cross[0])


    #30deg
    v_Flange_Edge = Vector([sin(radians(30)) * FLANGE_RADIUS,cos(radians(30)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT ])
    v_Cross = geometry.intersect_line_line(v_30_Deg_Top_Point,Vector([v_30_Deg_Top_Point.x,v_30_Deg_Top_Point.y,-HEIGHT]),v_Flange_Edge,v_Extended_Flange_Edge)
    verts.append(v_Cross[0])

    Row += 1



    verts.append([sin(radians(0)) * FLANGE_RADIUS,cos(radians(0)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT ])
    verts.append([sin(radians(5)) * FLANGE_RADIUS,cos(radians(5)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT])
    verts.append([sin(radians(10)) * FLANGE_RADIUS,cos(radians(10)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT])
    verts.append([sin(radians(15)) * FLANGE_RADIUS,cos(radians(15)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT])
    verts.append([sin(radians(20)) * FLANGE_RADIUS,cos(radians(20)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT])
    verts.append([sin(radians(25)) * FLANGE_RADIUS,cos(radians(25)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT])
    verts.append([sin(radians(30)) * FLANGE_RADIUS,cos(radians(30)) * FLANGE_RADIUS,-HEIGHT + FLANGE_HEIGHT])

    Row += 1

    verts.append([sin(radians(0)) * FLANGE_RADIUS,cos(radians(0)) * FLANGE_RADIUS,-HEIGHT])
    verts.append([sin(radians(5)) * FLANGE_RADIUS,cos(radians(5)) * FLANGE_RADIUS,-HEIGHT])
    verts.append([sin(radians(10)) * FLANGE_RADIUS,cos(radians(10)) * FLANGE_RADIUS,-HEIGHT])
    verts.append([sin(radians(15)) * FLANGE_RADIUS,cos(radians(15)) * FLANGE_RADIUS,-HEIGHT])
    verts.append([sin(radians(20)) * FLANGE_RADIUS,cos(radians(20)) * FLANGE_RADIUS,-HEIGHT])
    verts.append([sin(radians(25)) * FLANGE_RADIUS,cos(radians(25)) * FLANGE_RADIUS,-HEIGHT])
    verts.append([sin(radians(30)) * FLANGE_RADIUS,cos(radians(30)) * FLANGE_RADIUS,-HEIGHT])

    Row += 1


    verts.append([sin(radians(0)) * SHANK_RADIUS,cos(radians(0)) * SHANK_RADIUS,-HEIGHT])
    verts.append([sin(radians(0)) * SHANK_RADIUS,cos(radians(0)) * SHANK_RADIUS,-HEIGHT])
    verts.append([sin(radians(10)) * SHANK_RADIUS,cos(radians(10)) * SHANK_RADIUS,-HEIGHT])
    verts.append([sin(radians(10)) * SHANK_RADIUS,cos(radians(10)) * SHANK_RADIUS,-HEIGHT])
    verts.append([sin(radians(20)) * SHANK_RADIUS,cos(radians(20)) * SHANK_RADIUS,-HEIGHT])
    verts.append([sin(radians(20)) * SHANK_RADIUS,cos(radians(20)) * SHANK_RADIUS,-HEIGHT])
    verts.append([sin(radians(30)) * SHANK_RADIUS,cos(radians(30)) * SHANK_RADIUS,-HEIGHT])

    Row += 1


    faces.extend(Build_Face_List_Quads(FaceStart, 6, Row - 1))

    Spin_Verts, Spin_Faces = SpinDup(verts, faces, 360,12, 'z')

    return Spin_Verts, Spin_Faces, 0 - (-HEIGHT)


def Create_12_Point_Head(FLAT, HOLE_DIA, SHANK_DIA, HEIGHT,FLANGE_DIA):
    #TODO add under head radius
    return  Create_12_Point(FLAT, HOLE_DIA, SHANK_DIA, HEIGHT,FLANGE_DIA)



# ####################################################################
#                    Create External Thread
# ####################################################################


def Thread_Start3(verts, INNER_RADIUS, OUTTER_RADIUS, PITCH, DIV_COUNT,
                  CREST_PERCENT, ROOT_PERCENT, Height_Offset):

    Ret_Row = 0

    Height_Start = Height_Offset - PITCH
    Height_Step = float(PITCH) / float(DIV_COUNT)
    Deg_Step = 360.0 / float(DIV_COUNT)

    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
    Root_to_Crest_Height = Crest_to_Root_Height = \
                        (float(PITCH) - (Crest_Height + Root_Height)) / 2.0

    # thread start
    Rank = float(OUTTER_RADIUS - INNER_RADIUS) / float(DIV_COUNT)
    for j in range(4):

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            if z > Height_Start:
                z = Height_Start
            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            verts.append([x, y, z])
        Height_Offset -= Crest_Height
        Ret_Row += 1

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            if z > Height_Start:
                z = Height_Start

            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            verts.append([x, y, z])
        Height_Offset -= Crest_to_Root_Height
        Ret_Row += 1

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            if z > Height_Start:
                z = Height_Start

            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
            if j == 0:
                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
            verts.append([x, y, z])
        Height_Offset -= Root_Height
        Ret_Row += 1

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            if z > Height_Start:
                z = Height_Start

            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
            y = cos(radians(i * Deg_Step)) * INNER_RADIUS

            if j == 0:
                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
            verts.append([x, y, z])
        Height_Offset -= Root_to_Crest_Height
        Ret_Row += 1

    return Ret_Row, Height_Offset


def Create_Shank_Verts(START_DIA, OUTTER_DIA, LENGTH, Z_LOCATION, DIV_COUNT):

    verts = []

    START_RADIUS = START_DIA / 2
    OUTTER_RADIUS = OUTTER_DIA / 2

    Opp = abs(START_RADIUS - OUTTER_RADIUS)
    Taper_Lentgh = Opp / tan(radians(31))

    if Taper_Lentgh > LENGTH:
        Taper_Lentgh = 0

    Stright_Length = LENGTH - Taper_Lentgh

    Deg_Step = 360.0 / float(DIV_COUNT)

    Row = 0

    Lowest_Z_Vert = 0

    Height_Offset = Z_LOCATION

    # Ring
    for i in range(DIV_COUNT + 1):
        x = sin(radians(i * Deg_Step)) * START_RADIUS
        y = cos(radians(i * Deg_Step)) * START_RADIUS
        z = Height_Offset - 0
        verts.append([x, y, z])
        Lowest_Z_Vert = min(Lowest_Z_Vert, z)
    Height_Offset -= Stright_Length
    Row += 1

    for i in range(DIV_COUNT + 1):
        x = sin(radians(i * Deg_Step)) * START_RADIUS
        y = cos(radians(i * Deg_Step)) * START_RADIUS
        z = Height_Offset - 0
        verts.append([x, y, z])
        Lowest_Z_Vert = min(Lowest_Z_Vert, z)
    Height_Offset -= Taper_Lentgh
    Row += 1

    return verts, Row, Height_Offset


def Create_Thread_Start_Verts(INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
                              ROOT_PERCENT, Z_LOCATION, DIV_COUNT):

    verts = []

    INNER_RADIUS = INNER_DIA / 2
    OUTTER_RADIUS = OUTTER_DIA / 2

    Deg_Step = 360.0 / float(DIV_COUNT)
    Height_Step = float(PITCH) / float(DIV_COUNT)

    Row = 0

    Lowest_Z_Vert = 0

    Height_Offset = Z_LOCATION

    Height_Start = Height_Offset

    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
    Root_to_Crest_Height = Crest_to_Root_Height = \
                        (float(PITCH) - (Crest_Height + Root_Height)) / 2.0

    Rank = float(OUTTER_RADIUS - INNER_RADIUS) / float(DIV_COUNT)

    Height_Offset = Z_LOCATION + PITCH
    Cut_off = Z_LOCATION

    for j in range(1):

        for i in range(DIV_COUNT + 1):
            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            z = Height_Offset - (Height_Step * i)
            if z > Cut_off:
                z = Cut_off
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Crest_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            z = Height_Offset - (Height_Step * i)
            if z > Cut_off:
                z = Cut_off
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Crest_to_Root_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            z = Height_Offset - (Height_Step * i)
            if z > Cut_off:
                z = Cut_off
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Root_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            z = Height_Offset - (Height_Step * i)
            if z > Cut_off:
                z = Cut_off
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Root_to_Crest_Height
        Row += 1

    for j in range(2):
        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            if z > Height_Start:
                z = Height_Start
            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Crest_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            if z > Height_Start:
                z = Height_Start

            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Crest_to_Root_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            if z > Height_Start:
                z = Height_Start

            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
            if j == 0:
                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Root_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            if z > Height_Start:
                z = Height_Start

            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
            y = cos(radians(i * Deg_Step)) * INNER_RADIUS

            if j == 0:
                x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
                y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Root_to_Crest_Height
        Row += 1

    return verts, Row, Height_Offset


def Create_Thread_Verts(INNER_DIA, OUTTER_DIA, PITCH, HEIGHT,
                        CREST_PERCENT, ROOT_PERCENT, Z_LOCATION, DIV_COUNT):

    verts = []

    INNER_RADIUS = INNER_DIA / 2
    OUTTER_RADIUS = OUTTER_DIA / 2

    Deg_Step = 360.0 / float(DIV_COUNT)
    Height_Step = float(PITCH) / float(DIV_COUNT)

    NUM_OF_START_THREADS = 4.0
    NUM_OF_END_THREADS = 3.0
    Num = int((HEIGHT - ((NUM_OF_START_THREADS * PITCH) + (NUM_OF_END_THREADS * PITCH))) / PITCH)
    Row = 0

    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
    Root_to_Crest_Height = Crest_to_Root_Height = \
                        (float(PITCH) - (Crest_Height + Root_Height)) / 2.0

    Height_Offset = Z_LOCATION

    Lowest_Z_Vert = 0

    for j in range(Num):

        for i in range(DIV_COUNT + 1):
            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            z = Height_Offset - (Height_Step * i)
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Crest_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
            y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
            z = Height_Offset - (Height_Step * i)
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Crest_to_Root_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
            z = Height_Offset - (Height_Step * i)
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Root_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            x = sin(radians(i * Deg_Step)) * INNER_RADIUS
            y = cos(radians(i * Deg_Step)) * INNER_RADIUS
            z = Height_Offset - (Height_Step * i)
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Root_to_Crest_Height
        Row += 1

    return verts, Row, Height_Offset


def Create_Thread_End_Verts(INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
                            ROOT_PERCENT, Z_LOCATION, DIV_COUNT):
    verts = []

    INNER_RADIUS = INNER_DIA / 2
    OUTTER_RADIUS = OUTTER_DIA / 2

    Deg_Step = 360.0 / float(DIV_COUNT)
    Height_Step = float(PITCH) / float(DIV_COUNT)

    Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
    Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
    Root_to_Crest_Height = Crest_to_Root_Height = \
                        (float(PITCH) - (Crest_Height + Root_Height)) / 2.0

    Row = 0

    Height_Offset = Z_LOCATION
    Tapper_Height_Start = Height_Offset - PITCH - PITCH
    Max_Height = Tapper_Height_Start - PITCH
    Lowest_Z_Vert = 0

    for j in range(4):

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            z = max(z, Max_Height)
            Tapper_Radius = OUTTER_RADIUS
            if z < Tapper_Height_Start:
                Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)

            x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
            y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Crest_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            z = max(z, Max_Height)
            Tapper_Radius = OUTTER_RADIUS
            if z < Tapper_Height_Start:
                Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)

            x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
            y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Crest_to_Root_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            z = max(z, Max_Height)
            Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
            if Tapper_Radius > INNER_RADIUS:
                Tapper_Radius = INNER_RADIUS

            x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
            y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Root_Height
        Row += 1

        for i in range(DIV_COUNT + 1):
            z = Height_Offset - (Height_Step * i)
            z = max(z, Max_Height)
            Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
            if Tapper_Radius > INNER_RADIUS:
                Tapper_Radius = INNER_RADIUS

            x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
            y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
            verts.append([x, y, z])
            Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Height_Offset -= Root_to_Crest_Height
        Row += 1

    return verts, Row, Height_Offset, Lowest_Z_Vert


def Create_External_Thread(SHANK_DIA, SHANK_LENGTH, INNER_DIA, OUTTER_DIA,
                           PITCH, LENGTH, CREST_PERCENT, ROOT_PERCENT, DIV_COUNT):

    verts = []
    faces = []

    Total_Row = 0
    # Thread_Len = 0  # UNUSED

    Face_Start = len(verts)
    Offset = 0.0

    Shank_Verts, Shank_Row, Offset = Create_Shank_Verts(
                                                    SHANK_DIA, OUTTER_DIA, SHANK_LENGTH,
                                                    Offset, DIV_COUNT
                                                    )
    Total_Row += Shank_Row

    Thread_Start_Verts, Thread_Start_Row, Offset = Create_Thread_Start_Verts(
                                                    INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
                                                    ROOT_PERCENT, Offset, DIV_COUNT
                                                    )
    Total_Row += Thread_Start_Row

    Thread_Verts, Thread_Row, Offset = Create_Thread_Verts(
                                                    INNER_DIA, OUTTER_DIA, PITCH, LENGTH,
                                                    CREST_PERCENT, ROOT_PERCENT, Offset, DIV_COUNT
                                                    )
    Total_Row += Thread_Row

    Thread_End_Verts, Thread_End_Row, Offset, Lowest_Z_Vert = Create_Thread_End_Verts(
                                                    INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
                                                    ROOT_PERCENT, Offset, DIV_COUNT
                                                    )
    Total_Row += Thread_End_Row

    verts.extend(Shank_Verts)
    verts.extend(Thread_Start_Verts)
    verts.extend(Thread_Verts)
    verts.extend(Thread_End_Verts)

    faces.extend(Build_Face_List_Quads(Face_Start, DIV_COUNT, Total_Row - 1, 0))
    faces.extend(Fill_Ring_Face(len(verts) - DIV_COUNT, DIV_COUNT, 1))

    return verts, faces, 0.0 - Lowest_Z_Vert


# ####################################################################
#                   Create Nut
# ####################################################################

def add_Hex_Nut(FLAT, HOLE_DIA, HEIGHT):
    global Global_Head_Height
    global Global_NutRad

    verts = []
    faces = []
    HOLE_RADIUS = HOLE_DIA * 0.5
    Half_Flat = FLAT / 2
    Half_Height = HEIGHT / 2
    TopBevelRadius = Half_Flat - 0.05

    Global_NutRad = TopBevelRadius

    Row = 0
    Lowest_Z_Vert = 0.0

    verts.append([0.0, 0.0, 0.0])

    FaceStart = len(verts)
    # inner hole

    x = sin(radians(0)) * HOLE_RADIUS
    y = cos(radians(0)) * HOLE_RADIUS
    # print ("rad 0 x;",  x,  "y:" ,y )
    verts.append([x, y, 0.0])

    x = sin(radians(60 / 6)) * HOLE_RADIUS
    y = cos(radians(60 / 6)) * HOLE_RADIUS
    # print ("rad 60/6x;",  x,  "y:" ,y )
    verts.append([x, y, 0.0])

    x = sin(radians(60 / 3)) * HOLE_RADIUS
    y = cos(radians(60 / 3)) * HOLE_RADIUS
    # print ("rad 60/3x;",  x,  "y:" ,y )
    verts.append([x, y, 0.0])

    x = sin(radians(60 / 2)) * HOLE_RADIUS
    y = cos(radians(60 / 2)) * HOLE_RADIUS
    # print ("rad 60/2x;",  x,  "y:" ,y )
    verts.append([x, y, 0.0])
    Row += 1

    # Bevel

    x = sin(radians(0)) * TopBevelRadius
    y = cos(radians(0)) * TopBevelRadius
    vec1 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    x = sin(radians(60 / 6)) * TopBevelRadius
    y = cos(radians(60 / 6)) * TopBevelRadius
    vec2 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    x = sin(radians(60 / 3)) * TopBevelRadius
    y = cos(radians(60 / 3)) * TopBevelRadius
    vec3 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])

    x = sin(radians(60 / 2)) * TopBevelRadius
    y = cos(radians(60 / 2)) * TopBevelRadius
    vec4 = Vector([x, y, 0.0])
    verts.append([x, y, 0.0])
    Row += 1

    # Flats
    x = tan(radians(0)) * Half_Flat
    dvec = vec1 - Vector([x, Half_Flat, 0.0])
    verts.append([x, Half_Flat, -dvec.length])
    Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)

    x = tan(radians(60 / 6)) * Half_Flat
    dvec = vec2 - Vector([x, Half_Flat, 0.0])
    verts.append([x, Half_Flat, -dvec.length])
    Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)

    x = tan(radians(60 / 3)) * Half_Flat
    dvec = vec3 - Vector([x, Half_Flat, 0.0])
    Lowest_Point = -dvec.length
    verts.append([x, Half_Flat, -dvec.length])
    Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)

    x = tan(radians(60 / 2)) * Half_Flat
    dvec = vec4 - Vector([x, Half_Flat, 0.0])
    Lowest_Point = -dvec.length
    verts.append([x, Half_Flat, -dvec.length])
    Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)
    Row += 1

    # down Bits Tri
    x = tan(radians(0)) * Half_Flat
    verts.append([x, Half_Flat, Lowest_Point])

    x = tan(radians(60 / 6)) * Half_Flat
    verts.append([x, Half_Flat, Lowest_Point])
    x = tan(radians(60 / 3)) * Half_Flat
    verts.append([x, Half_Flat, Lowest_Point])

    x = tan(radians(60 / 2)) * Half_Flat
    verts.append([x, Half_Flat, Lowest_Point])
    Lowest_Z_Vert = min(Lowest_Z_Vert, Lowest_Point)
    Row += 1

    # down Bits

    x = tan(radians(0)) * Half_Flat
    verts.append([x, Half_Flat, -Half_Height])

    x = tan(radians(60 / 6)) * Half_Flat
    verts.append([x, Half_Flat, -Half_Height])

    x = tan(radians(60 / 3)) * Half_Flat
    verts.append([x, Half_Flat, -Half_Height])

    x = tan(radians(60 / 2)) * Half_Flat
    verts.append([x, Half_Flat, -Half_Height])
    Lowest_Z_Vert = min(Lowest_Z_Vert, -Half_Height)
    Row += 1

    faces.extend(Build_Face_List_Quads(FaceStart, 3, Row - 1))

    Global_Head_Height = HEIGHT

    Tvert, tface = Mirror_Verts_Faces(verts, faces, 'z', Lowest_Z_Vert)
    verts.extend(Tvert)
    faces.extend(tface)

    Tvert, tface = Mirror_Verts_Faces(verts, faces, 'y')
    verts.extend(Tvert)
    faces.extend(tface)

    S_verts, S_faces = SpinDup(verts, faces, 360, 6, 'z')

    # return verts, faces, TopBevelRadius
    return S_verts, S_faces, TopBevelRadius


def add_Nylon_Head(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
    verts = []
    faces = []
    Row = 0

    INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.25 / 4.75))
    EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4 / 4.75))
    RAD1 = (OUTSIDE_RADIUS * (0.5 / 4.75))
    OVER_ALL_HEIGHT = (OUTSIDE_RADIUS * (2.0 / 4.75))

    FaceStart = len(verts)

    # Start_Height = 0 - 3  # UNUSED
    Height_Offset = Z_LOCATION
    Lowest_Z_Vert = 0

    x = INNER_HOLE
    z = (Height_Offset - OVER_ALL_HEIGHT) + EDGE_THICKNESS
    verts.append([x, 0.0, z])
    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
    Row += 1

    x = INNER_HOLE
    z = (Height_Offset - OVER_ALL_HEIGHT)
    verts.append([x, 0.0, z])
    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
    Row += 1

    for i in range(180, 80, -10):
        x = sin(radians(i)) * RAD1
        z = cos(radians(i)) * RAD1
        verts.append([(OUTSIDE_RADIUS - RAD1) + x, 0.0, ((Height_Offset - OVER_ALL_HEIGHT) + RAD1) + z])
        Lowest_Z_Vert = min(Lowest_Z_Vert, z)
        Row += 1

    x = OUTSIDE_RADIUS - 0
    z = Height_Offset
    verts.append([x, 0.0, z])
    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
    Row += 1

    sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
    sVerts.extend(verts)        # add the start verts to the Spin verts to complete the loop

    faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT,1))

    return Move_Verts_Up_Z(sVerts, 0), faces, Lowest_Z_Vert


def add_Nylon_Part(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
    verts = []
    faces = []
    Row = 0

    INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.5 / 4.75))
    EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4 / 4.75))
    OVER_ALL_HEIGHT = (OUTSIDE_RADIUS * (2.0 / 4.75))
    PART_THICKNESS = OVER_ALL_HEIGHT - EDGE_THICKNESS
    PART_INNER_HOLE = (OUTSIDE_RADIUS * (2.5 / 4.75))

    FaceStart = len(verts)

    Height_Offset = Z_LOCATION
    Lowest_Z_Vert = 0

    x = INNER_HOLE + EDGE_THICKNESS
    z = Height_Offset
    verts.append([x, 0.0, z])
    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
    Row += 1

    x = PART_INNER_HOLE
    z = Height_Offset
    verts.append([x, 0.0, z])
    Lowest_Z_Vert = min(Lowest_Z_Vert, z)
    Row += 1