add_mesh_BoltFactory/createMesh.py

   1 # ##### BEGIN GPL LICENSE BLOCK #####
   2 #
   3 #  This program is free software; you can redistribute it and/or
   4 #  modify it under the terms of the GNU General Public License
   5 #  as published by the Free Software Foundation; either version 2
   6 #  of the License, or (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software Foundation,
  15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16 #
  17 # ##### END GPL LICENSE BLOCK #####
  18
  19 import bpy
  20 import mathutils
  21
  22 from math import *
  23 from itertools import *
  24
  25 NARROW_UI = 180
  26 MAX_INPUT_NUMBER = 50
  27
  28 #Global_Scale = 0.001    #1 blender unit = X mm
  29 GLOBAL_SCALE = 0.1    #1 blender unit = X mm
  30 #Global_Scale = 1.0    #1 blender unit = X mm
  31
  32
  33
  34
  35 # next two utility functions are stolen from import_obj.py
  36
  37 def unpack_list(list_of_tuples):
  38     l = []
  39     for t in list_of_tuples:
  40         l.extend(t)
  41     return l
  42
  43 def unpack_face_list(list_of_tuples):
  44     l = []
  45     for t in list_of_tuples:
  46         face = [i for i in t]
  47
  48         if len(face) != 3 and len(face) != 4:
  49             raise RuntimeError("{0} vertices in face".format(len(face)))
  50
  51         # rotate indices if the 4th is 0
  52         if len(face) == 4 and face[3] == 0:
  53             face = [face[3], face[0], face[1], face[2]]
  54
  55         if len(face) == 3:
  56             face.append(0)
  57
  58         l.extend(face)
  59
  60     return l
  61
  62 """
  63 Remove Doubles takes a list on Verts and a list of Faces and
  64 removes the doubles, much like Blender does in edit mode.
  65 It doesn’t have the range function  but it will round the corrdinates
  66 and remove verts that are very close togther.  The function
  67 is useful because you can perform a “Remove Doubles” with out
  68 having to enter Edit Mode. Having to enter edit mode has the
  69 disadvantage of not being able to interactively change the properties.
  70 """
  71
  72
  73 def RemoveDoubles(verts,faces,Decimal_Places = 4):
  74
  75     new_verts = []
  76     new_faces = []
  77     dict_verts = {}
  78     Rounded_Verts = []
  79
  80     for v in verts:
  81         Rounded_Verts.append([round(v[0],Decimal_Places),round(v[1],Decimal_Places),round(v[2],Decimal_Places)])
  82
  83     for face in faces:
  84         new_face = []
  85         for vert_index in face:
  86             Real_co = tuple(verts[vert_index])
  87             Rounded_co = tuple(Rounded_Verts[vert_index])
  88
  89             if Rounded_co not in dict_verts:
  90                 dict_verts[Rounded_co] = len(dict_verts)
  91                 new_verts.append(Real_co)
  92             if dict_verts[Rounded_co] not in new_face:
  93                 new_face.append(dict_verts[Rounded_co])
  94         if len(new_face) == 3 or len(new_face) == 4:
  95             new_faces.append(new_face)
  96
  97     return new_verts,new_faces
  98
  99
 100
 101
 102 def Scale_Mesh_Verts(verts,scale_factor):
 103     Ret_verts = []
 104     for v in verts:
 105         Ret_verts.append([v[0]*scale_factor,v[1]*scale_factor,v[2]*scale_factor])
 106     return Ret_verts
 107
 108
 109
 110
 111
 112 #Create a matrix representing a rotation.
 113 #
 114 #Parameters:
 115 #
 116 #        * angle (float) - The angle of rotation desired.
 117 #        * matSize (int) - The size of the rotation matrix to construct. Can be 2d, 3d, or 4d.
 118 #        * axisFlag (string (optional)) - Possible values:
 119 #              o "x - x-axis rotation"
 120 #              o "y - y-axis rotation"
 121 #              o "z - z-axis rotation"
 122 #              o "r - arbitrary rotation around vector"
 123 #        * axis (Vector object. (optional)) - The arbitrary axis of rotation used with "R"
 124 #
 125 #Returns: Matrix object.
 126 #    A new rotation matrix.
 127 def Simple_RotationMatrix(angle, matSize, axisFlag):
 128     if matSize != 4 :
 129         print ("Simple_RotationMatrix can only do 4x4")
 130
 131     q = radians(angle)  #make the rotation go clockwise
 132
 133     if axisFlag == 'x':
 134         matrix = mathutils.Matrix.Rotation(q, 4, 'X')
 135     elif  axisFlag == 'y':
 136         matrix = mathutils.Matrix.Rotation(q, 4, 'Y')
 137     elif axisFlag == 'z':
 138         matrix = mathutils.Matrix.Rotation(q, 4, 'Z')
 139     else:
 140         print   ("Simple_RotationMatrix can only do x y z axis")
 141     return matrix
 142
 143
 144 ##########################################################################################
 145 ##########################################################################################
 146 ##                    Converter Functions For Bolt Factory
 147 ##########################################################################################
 148 ##########################################################################################
 149
 150
 151 def Flat_To_Radius(FLAT):
 152     h = (float(FLAT)/2)/cos(radians(30))
 153     return h
 154
 155 def Get_Phillips_Bit_Height(Bit_Dia):
 156     Flat_Width_half = (Bit_Dia*(0.5/1.82))/2.0
 157     Bit_Rad = Bit_Dia / 2.0
 158     x = Bit_Rad - Flat_Width_half
 159     y = tan(radians(60))*x
 160     return float(y)
 161
 162
 163 ##########################################################################################
 164 ##########################################################################################
 165 ##                    Miscellaneous Utilities
 166 ##########################################################################################
 167 ##########################################################################################
 168
 169 # Returns a list of verts rotated by the given matrix. Used by SpinDup
 170 def Rot_Mesh(verts, matrix):
 171     from mathutils import Vector
 172     return [(matrix * Vector(v))[:] for v in verts]
 173
 174
 175 # Returns a list of faces that has there index incremented by offset
 176 def Copy_Faces(faces,offset):
 177     return [[(i + offset) for i in f] for f in faces]
 178
 179
 180 # Much like Blenders built in SpinDup.
 181 def SpinDup(VERTS,FACES,DEGREE,DIVISIONS,AXIS):
 182     verts=[]
 183     faces=[]
 184
 185     if DIVISIONS == 0:
 186         DIVISIONS = 1
 187
 188     step = DEGREE/DIVISIONS # set step so pieces * step = degrees in arc
 189
 190     for i in range(int(DIVISIONS)):
 191         rotmat = Simple_RotationMatrix(step*i, 4, AXIS) # 4x4 rotation matrix, 30d about the x axis.
 192         Rot = Rot_Mesh(VERTS,rotmat)
 193         faces.extend(Copy_Faces(FACES,len(verts)))
 194         verts.extend(Rot)
 195     return verts,faces
 196
 197
 198
 199 # Returns a list of verts that have been moved up the z axis by DISTANCE
 200 def Move_Verts_Up_Z(VERTS,DISTANCE):
 201     ret = []
 202     for v in VERTS:
 203         ret.append([v[0],v[1],v[2]+DISTANCE])
 204     return ret
 205
 206
 207 # Returns a list of verts and faces that has been mirrored in the AXIS
 208 def Mirror_Verts_Faces(VERTS,FACES,AXIS,FLIP_POINT =0):
 209     ret_vert = []
 210     ret_face = []
 211     offset = len(VERTS)
 212     if AXIS == 'y':
 213         for v in VERTS:
 214             Delta = v[0] - FLIP_POINT
 215             ret_vert.append([FLIP_POINT-Delta,v[1],v[2]])
 216     if AXIS == 'x':
 217         for v in VERTS:
 218             Delta = v[1] - FLIP_POINT
 219             ret_vert.append([v[0],FLIP_POINT-Delta,v[2]])
 220     if AXIS == 'z':
 221         for v in VERTS:
 222             Delta = v[2] - FLIP_POINT
 223             ret_vert.append([v[0],v[1],FLIP_POINT-Delta])
 224
 225     for f in FACES:
 226         fsub = []
 227         for i in range(len(f)):
 228             fsub.append(f[i]+ offset)
 229         fsub.reverse() # flip the order to make norm point out
 230         ret_face.append(fsub)
 231
 232     return ret_vert,ret_face
 233
 234
 235
 236 # Returns a list of faces that
 237 # make up an array of 4 point polygon.
 238 def Build_Face_List_Quads(OFFSET,COLUM,ROW,FLIP = 0):
 239     Ret =[]
 240     RowStart = 0;
 241     for j in range(ROW):
 242         for i in range(COLUM):
 243             Res1 = RowStart + i;
 244             Res2 = RowStart + i + (COLUM +1)
 245             Res3 = RowStart + i + (COLUM +1) +1
 246             Res4 = RowStart+i+1
 247             if FLIP:
 248                 Ret.append([OFFSET+Res1,OFFSET+Res2,OFFSET+Res3,OFFSET+Res4])
 249             else:
 250                 Ret.append([OFFSET+Res4,OFFSET+Res3,OFFSET+Res2,OFFSET+Res1])
 251         RowStart += COLUM+1
 252     return Ret
 253
 254
 255 # Returns a list of faces that makes up a fill pattern for a
 256 # circle
 257 def Fill_Ring_Face(OFFSET,NUM,FACE_DOWN = 0):
 258     Ret =[]
 259     Face = [1,2,0]
 260     TempFace = [0,0,0]
 261     # A = 0  # UNUSED
 262     B = 1
 263     C = 2
 264     if NUM < 3:
 265         return None
 266     for i in range(NUM-2):
 267         if (i%2):
 268             TempFace[0] = Face[C];
 269             TempFace[1] = Face[C] + 1;
 270             TempFace[2] = Face[B];
 271             if FACE_DOWN:
 272                 Ret.append([OFFSET+Face[2],OFFSET+Face[1],OFFSET+Face[0]])
 273             else:
 274                 Ret.append([OFFSET+Face[0],OFFSET+Face[1],OFFSET+Face[2]])
 275         else:
 276             TempFace[0] =Face[C];
 277             if Face[C] == 0:
 278                 TempFace[1] = NUM-1;
 279             else:
 280                 TempFace[1] = Face[C] - 1;
 281             TempFace[2] = Face[B];
 282             if FACE_DOWN:
 283                 Ret.append([OFFSET+Face[0],OFFSET+Face[1],OFFSET+Face[2]])
 284             else:
 285                 Ret.append([OFFSET+Face[2],OFFSET+Face[1],OFFSET+Face[0]])
 286
 287         Face[0] = TempFace[0]
 288         Face[1] = TempFace[1]
 289         Face[2] = TempFace[2]
 290     return Ret
 291
 292 ######################################################################################
 293 ##########################################################################################
 294 ##########################################################################################
 295 ##                    Create Allen Bit
 296 ##########################################################################################
 297 ##########################################################################################
 298
 299
 300 def Allen_Fill(OFFSET,FLIP= 0):
 301     faces = []
 302     Lookup = [[19,1,0],
 303               [19,2,1],
 304               [19,3,2],
 305               [19,20,3],
 306               [20,4,3],
 307               [20,5,4],
 308               [20,6,5],
 309               [20,7,6],
 310               [20,8,7],
 311               [20,9,8],
 312
 313               [20,21,9],
 314
 315               [21,10,9],
 316               [21,11,10],
 317               [21,12,11],
 318               [21,13,12],
 319               [21,14,13],
 320               [21,15,14],
 321
 322               [21,22,15],
 323               [22,16,15],
 324               [22,17,16],
 325               [22,18,17]
 326               ]
 327     for i in Lookup:
 328         if FLIP:
 329             faces.append([OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
 330         else:
 331             faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2]])
 332
 333     return faces
 334
 335 def Allen_Bit_Dia(FLAT_DISTANCE):
 336     Flat_Radius = (float(FLAT_DISTANCE)/2.0)/cos(radians(30))
 337     return (Flat_Radius * 1.05) * 2.0
 338
 339 def Allen_Bit_Dia_To_Flat(DIA):
 340     Flat_Radius = (DIA/2.0)/1.05
 341     return (Flat_Radius * cos (radians(30)))* 2.0
 342
 343
 344
 345 def Create_Allen_Bit(FLAT_DISTANCE,HEIGHT):
 346     Div = 36
 347     verts = []
 348     faces = []
 349
 350     Flat_Radius = (float(FLAT_DISTANCE)/2.0)/cos(radians(30))
 351     OUTTER_RADIUS = Flat_Radius * 1.05
 352     Outter_Radius_Height = Flat_Radius * (0.1/5.77)
 353     FaceStart_Outside = len(verts)
 354     Deg_Step = 360.0 /float(Div)
 355
 356     for i in range(int(Div/2)+1):    # only do half and mirror later
 357         x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
 358         y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
 359         verts.append([x,y,0])
 360
 361     FaceStart_Inside = len(verts)
 362
 363     Deg_Step = 360.0 /float(6)
 364     for i in range(int(6/2)+1):
 365         x = sin(radians(i*Deg_Step))* Flat_Radius
 366         y = cos(radians(i*Deg_Step))* Flat_Radius
 367         verts.append([x,y,0-Outter_Radius_Height])
 368
 369     faces.extend(Allen_Fill(FaceStart_Outside,0))
 370
 371
 372     FaceStart_Bottom = len(verts)
 373
 374     Deg_Step = 360.0 /float(6)
 375     for i in range(int(6/2)+1):
 376         x = sin(radians(i*Deg_Step))* Flat_Radius
 377         y = cos(radians(i*Deg_Step))* Flat_Radius
 378         verts.append([x,y,0-HEIGHT])
 379
 380     faces.extend(Build_Face_List_Quads(FaceStart_Inside,3,1,True))
 381     faces.extend(Fill_Ring_Face(FaceStart_Bottom,4))
 382
 383
 384     M_Verts,M_Faces = Mirror_Verts_Faces(verts,faces,'y')
 385     verts.extend(M_Verts)
 386     faces.extend(M_Faces)
 387
 388     return verts,faces,OUTTER_RADIUS * 2.0
 389
 390
 391 ##########################################################################################
 392 ##########################################################################################
 393 ##                    Create Phillips Bit
 394 ##########################################################################################
 395 ##########################################################################################
 396
 397
 398 def Phillips_Fill(OFFSET,FLIP= 0):
 399     faces = []
 400     Lookup = [[0,1,10],
 401               [1,11,10],
 402               [1,2,11],
 403               [2,12,11],
 404
 405               [2,3,12],
 406               [3,4,12],
 407               [4,5,12],
 408               [5,6,12],
 409               [6,7,12],
 410
 411               [7,13,12],
 412               [7,8,13],
 413               [8,14,13],
 414               [8,9,14],
 415
 416
 417               [10,11,16,15],
 418               [11,12,16],
 419               [12,13,16],
 420               [13,14,17,16],
 421               [15,16,17,18]
 422
 423
 424               ]
 425     for i in Lookup:
 426         if FLIP:
 427             if len(i) == 3:
 428                 faces.append([OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
 429             else:
 430                 faces.append([OFFSET+i[3],OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
 431         else:
 432             if len(i) == 3:
 433                 faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2]])
 434             else:
 435                 faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2],OFFSET+i[3]])
 436     return faces
 437
 438
 439
 440 def Create_Phillips_Bit(FLAT_DIA,FLAT_WIDTH,HEIGHT):
 441     Div = 36
 442     verts = []
 443     faces = []
 444
 445     FLAT_RADIUS = FLAT_DIA * 0.5
 446     OUTTER_RADIUS = FLAT_RADIUS * 1.05
 447
 448     Flat_Half = float(FLAT_WIDTH)/2.0
 449
 450     FaceStart_Outside = len(verts)
 451     Deg_Step = 360.0 /float(Div)
 452     for i in range(int(Div/4)+1):    # only do half and mirror later
 453         x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
 454         y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
 455         verts.append([x,y,0])
 456
 457
 458     # FaceStart_Inside = len(verts)  # UNUSED
 459     verts.append([0,FLAT_RADIUS,0]) #10
 460     verts.append([Flat_Half,FLAT_RADIUS,0]) #11
 461     verts.append([Flat_Half,Flat_Half,0])     #12
 462     verts.append([FLAT_RADIUS,Flat_Half,0])    #13
 463     verts.append([FLAT_RADIUS,0,0])            #14
 464
 465
 466     verts.append([0,Flat_Half,0-HEIGHT])        #15
 467     verts.append([Flat_Half,Flat_Half,0-HEIGHT])    #16
 468     verts.append([Flat_Half,0,0-HEIGHT])            #17
 469
 470     verts.append([0,0,0-HEIGHT])            #18
 471
 472     faces.extend(Phillips_Fill(FaceStart_Outside,True))
 473
 474     Spin_Verts,Spin_Face = SpinDup(verts,faces,360,4,'z')
 475
 476     return Spin_Verts,Spin_Face,OUTTER_RADIUS * 2
 477
 478
 479 ##########################################################################################
 480 ##########################################################################################
 481 ##                    Create Head Types
 482 ##########################################################################################
 483 ##########################################################################################
 484
 485 def Max_Pan_Bit_Dia(HEAD_DIA):
 486     HEAD_RADIUS = HEAD_DIA * 0.5
 487     XRad = HEAD_RADIUS * 1.976
 488     return (sin(radians(10))*XRad) * 2.0
 489
 490
 491 def Create_Pan_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET):
 492
 493     DIV = 36
 494     HOLE_RADIUS = HOLE_DIA * 0.5
 495     HEAD_RADIUS = HEAD_DIA * 0.5
 496     SHANK_RADIUS = SHANK_DIA * 0.5
 497
 498     verts = []
 499     faces = []
 500     Row = 0
 501
 502     XRad = HEAD_RADIUS * 1.976
 503     ZRad = HEAD_RADIUS * 1.768
 504     EndRad = HEAD_RADIUS * 0.284
 505     EndZOffset = HEAD_RADIUS * 0.432
 506     HEIGHT = HEAD_RADIUS * 0.59
 507
 508 #    Dome_Rad =  5.6
 509 #    RAD_Offset = 4.9
 510 #    OtherRad = 0.8
 511 #    OtherRad_X_Offset = 4.2
 512 #    OtherRad_Z_Offset = 2.52
 513 #    XRad = 9.88
 514 #    ZRad = 8.84
 515 #    EndRad = 1.42
 516 #    EndZOffset = 2.16
 517 #    HEIGHT = 2.95
 518
 519     FaceStart = FACE_OFFSET
 520
 521     z = cos(radians(10))*ZRad
 522     verts.append([HOLE_RADIUS,0.0,(0.0-ZRad)+z])
 523     Start_Height = 0 - ((0.0-ZRad)+z)
 524     Row += 1
 525
 526     #for i in range(0,30,10):  was 0 to 30 more work needed to make this look good.
 527     for i in range(10,30,10):
 528         x = sin(radians(i))*XRad
 529         z = cos(radians(i))*ZRad
 530         verts.append([x,0.0,(0.0-ZRad)+z])
 531         Row += 1
 532
 533     for i in range(20,140,10):
 534         x = sin(radians(i))*EndRad
 535         z = cos(radians(i))*EndRad
 536         if ((0.0 - EndZOffset)+z) < (0.0-HEIGHT):
 537             verts.append([(HEAD_RADIUS -EndRad)+x,0.0,0.0 - HEIGHT])
 538         else:
 539             verts.append([(HEAD_RADIUS -EndRad)+x,0.0,(0.0 - EndZOffset)+z])
 540         Row += 1
 541
 542
 543     verts.append([SHANK_RADIUS,0.0,(0.0-HEIGHT)])
 544     Row += 1
 545
 546     verts.append([SHANK_RADIUS,0.0,(0.0-HEIGHT)-Start_Height])
 547     Row += 1
 548
 549
 550     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'z')
 551     sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
 552
 553     faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV))
 554
 555     # Global_Head_Height = HEIGHT  # UNUSED
 556
 557
 558     return Move_Verts_Up_Z(sVerts,Start_Height),faces,HEIGHT
 559
 560
 561
 562 def Create_Dome_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET):
 563     DIV = 36
 564     HOLE_RADIUS = HOLE_DIA * 0.5
 565     HEAD_RADIUS = HEAD_DIA * 0.5
 566     SHANK_RADIUS = SHANK_DIA * 0.5
 567
 568     verts = []
 569     faces = []
 570     Row = 0
 571     # BEVEL = HEIGHT * 0.01  # UNUSED
 572     #Dome_Rad =  HEAD_RADIUS * (1.0/1.75)
 573
 574     Dome_Rad =  HEAD_RADIUS * 1.12
 575     #Head_Height = HEAD_RADIUS * 0.78
 576     RAD_Offset = HEAD_RADIUS * 0.98
 577     Dome_Height = HEAD_RADIUS * 0.64
 578     OtherRad = HEAD_RADIUS * 0.16
 579     OtherRad_X_Offset = HEAD_RADIUS * 0.84
 580     OtherRad_Z_Offset = HEAD_RADIUS * 0.504
 581
 582
 583 #    Dome_Rad =  5.6
 584 #    RAD_Offset = 4.9
 585 #    Dome_Height = 3.2
 586 #    OtherRad = 0.8
 587 #    OtherRad_X_Offset = 4.2
 588 #    OtherRad_Z_Offset = 2.52
 589 #
 590
 591     FaceStart = FACE_OFFSET
 592
 593     verts.append([HOLE_RADIUS,0.0,0.0])
 594     Row += 1
 595
 596
 597     for i in range(0,60,10):
 598         x = sin(radians(i))*Dome_Rad
 599         z = cos(radians(i))*Dome_Rad
 600         if ((0.0-RAD_Offset)+z) <= 0:
 601             verts.append([x,0.0,(0.0-RAD_Offset)+z])
 602             Row += 1
 603
 604
 605     for i in range(60,160,10):
 606         x = sin(radians(i))*OtherRad
 607         z = cos(radians(i))*OtherRad
 608         z = (0.0-OtherRad_Z_Offset)+z
 609         if z < (0.0-Dome_Height):
 610             z = (0.0-Dome_Height)
 611         verts.append([OtherRad_X_Offset+x,0.0,z])
 612         Row += 1
 613
 614     verts.append([SHANK_RADIUS,0.0,(0.0-Dome_Height)])
 615     Row += 1
 616
 617
 618     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'z')
 619     sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
 620
 621     faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV))
 622
 623     return sVerts,faces,Dome_Height
 624
 625
 626
 627 def Create_CounterSink_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1):
 628     DIV = 36
 629
 630     HOLE_RADIUS = HOLE_DIA * 0.5
 631     HEAD_RADIUS = HEAD_DIA * 0.5
 632     SHANK_RADIUS = SHANK_DIA * 0.5
 633
 634
 635     verts = []
 636     faces = []
 637     Row = 0
 638
 639 #    HEAD_RADIUS = (HEIGHT/tan(radians(60))) + SHANK_RADIUS
 640     HEIGHT = tan(radians(60)) * (HEAD_RADIUS - SHANK_RADIUS)
 641     #print (RAD1)
 642
 643     FaceStart = len(verts)
 644
 645     verts.append([HOLE_RADIUS,0.0,0.0])
 646     Row += 1
 647
 648     #rad
 649
 650     for i in range(0,100,10):
 651         x = sin(radians(i))*RAD1
 652         z = cos(radians(i))*RAD1
 653         verts.append([(HEAD_RADIUS-RAD1)+x,0.0,(0.0-RAD1)+z])
 654         Row += 1
 655
 656
 657     verts.append([SHANK_RADIUS,0.0,0.0-HEIGHT])
 658     Row += 1
 659
 660
 661     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'z')
 662     sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
 663
 664
 665     faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV,1))
 666
 667     return sVerts,faces,HEIGHT
 668
 669
 670
 671
 672 def Create_Cap_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2):
 673     DIV = 36
 674
 675     HOLE_RADIUS = HOLE_DIA * 0.5
 676     HEAD_RADIUS = HEAD_DIA * 0.5
 677     SHANK_RADIUS = SHANK_DIA * 0.5
 678
 679     verts = []
 680     faces = []
 681     Row = 0
 682     BEVEL = HEIGHT * 0.01
 683
 684
 685     FaceStart = len(verts)
 686
 687     verts.append([HOLE_RADIUS,0.0,0.0])
 688     Row += 1
 689
 690     #rad
 691
 692     for i in range(0,100,10):
 693         x = sin(radians(i))*RAD1
 694         z = cos(radians(i))*RAD1
 695         verts.append([(HEAD_RADIUS-RAD1)+x,0.0,(0.0-RAD1)+z])
 696         Row += 1
 697
 698
 699     verts.append([HEAD_RADIUS,0.0,0.0-HEIGHT+BEVEL])
 700     Row += 1
 701
 702     verts.append([HEAD_RADIUS-BEVEL,0.0,0.0-HEIGHT])
 703     Row += 1
 704
 705     #rad2
 706
 707     for i in range(0,100,10):
 708         x = sin(radians(i))*RAD2
 709         z = cos(radians(i))*RAD2
 710         verts.append([(SHANK_RADIUS+RAD2)-x,0.0,(0.0-HEIGHT-RAD2)+z])
 711         Row += 1
 712
 713
 714     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'z')
 715     sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
 716
 717
 718     faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV))
 719
 720     return sVerts,faces,HEIGHT+RAD2
 721
 722
 723 def Create_Hex_Head(FLAT,HOLE_DIA,SHANK_DIA,HEIGHT):
 724
 725     verts = []
 726     faces = []
 727     HOLE_RADIUS = HOLE_DIA * 0.5
 728     Half_Flat = FLAT/2
 729     TopBevelRadius = Half_Flat - (Half_Flat* (0.05/8))
 730     Undercut_Height = (Half_Flat* (0.05/8))
 731     Shank_Bevel = (Half_Flat* (0.05/8))
 732     Flat_Height = HEIGHT - Undercut_Height - Shank_Bevel
 733     #Undercut_Height = 5
 734     SHANK_RADIUS = SHANK_DIA/2
 735     Row = 0;
 736
 737     verts.append([0.0,0.0,0.0])
 738
 739
 740     FaceStart = len(verts)
 741     #inner hole
 742
 743     x = sin(radians(0))*HOLE_RADIUS
 744     y = cos(radians(0))*HOLE_RADIUS
 745     verts.append([x,y,0.0])
 746
 747
 748     x = sin(radians(60/6))*HOLE_RADIUS
 749     y = cos(radians(60/6))*HOLE_RADIUS
 750     verts.append([x,y,0.0])
 751
 752
 753     x = sin(radians(60/3))*HOLE_RADIUS
 754     y = cos(radians(60/3))*HOLE_RADIUS
 755     verts.append([x,y,0.0])
 756
 757
 758     x = sin(radians(60/2))*HOLE_RADIUS
 759     y = cos(radians(60/2))*HOLE_RADIUS
 760     verts.append([x,y,0.0])
 761     Row += 1
 762
 763     #bevel
 764
 765     x = sin(radians(0))*TopBevelRadius
 766     y = cos(radians(0))*TopBevelRadius
 767     vec1 = mathutils.Vector([x,y,0.0])
 768     verts.append([x,y,0.0])
 769
 770
 771     x = sin(radians(60/6))*TopBevelRadius
 772     y = cos(radians(60/6))*TopBevelRadius
 773     vec2 = mathutils.Vector([x,y,0.0])
 774     verts.append([x,y,0.0])
 775
 776
 777     x = sin(radians(60/3))*TopBevelRadius
 778     y = cos(radians(60/3))*TopBevelRadius
 779     vec3 = mathutils.Vector([x,y,0.0])
 780     verts.append([x,y,0.0])
 781
 782
 783     x = sin(radians(60/2))*TopBevelRadius
 784     y = cos(radians(60/2))*TopBevelRadius
 785     vec4 = mathutils.Vector([x,y,0.0])
 786     verts.append([x,y,0.0])
 787     Row += 1
 788
 789     #Flats
 790
 791     x = tan(radians(0))*Half_Flat
 792     dvec = vec1 - mathutils.Vector([x,Half_Flat,0.0])
 793     verts.append([x,Half_Flat,-dvec.length])
 794
 795
 796     x = tan(radians(60/6))*Half_Flat
 797     dvec = vec2 - mathutils.Vector([x,Half_Flat,0.0])
 798     verts.append([x,Half_Flat,-dvec.length])
 799
 800
 801     x = tan(radians(60/3))*Half_Flat
 802     dvec = vec3 - mathutils.Vector([x,Half_Flat,0.0])
 803     Lowest_Point = -dvec.length
 804     verts.append([x,Half_Flat,-dvec.length])
 805
 806
 807     x = tan(radians(60/2))*Half_Flat
 808     dvec = vec4 - mathutils.Vector([x,Half_Flat,0.0])
 809     Lowest_Point = -dvec.length
 810     verts.append([x,Half_Flat,-dvec.length])
 811     Row += 1
 812
 813     #down Bits Tri
 814     x = tan(radians(0))*Half_Flat
 815     verts.append([x,Half_Flat,Lowest_Point])
 816
 817     x = tan(radians(60/6))*Half_Flat
 818     verts.append([x,Half_Flat,Lowest_Point])
 819
 820     x = tan(radians(60/3))*Half_Flat
 821     verts.append([x,Half_Flat,Lowest_Point])
 822
 823     x = tan(radians(60/2))*Half_Flat
 824     verts.append([x,Half_Flat,Lowest_Point])
 825     Row += 1
 826
 827     #down Bits
 828
 829     x = tan(radians(0))*Half_Flat
 830     verts.append([x,Half_Flat,-Flat_Height])
 831
 832     x = tan(radians(60/6))*Half_Flat
 833     verts.append([x,Half_Flat,-Flat_Height])
 834
 835     x = tan(radians(60/3))*Half_Flat
 836     verts.append([x,Half_Flat,-Flat_Height])
 837
 838     x = tan(radians(60/2))*Half_Flat
 839     verts.append([x,Half_Flat,-Flat_Height])
 840     Row += 1
 841
 842
 843     #under cut
 844
 845     x = sin(radians(0))*Half_Flat
 846     y = cos(radians(0))*Half_Flat
 847     vec1 = mathutils.Vector([x,y,0.0])
 848     verts.append([x,y,-Flat_Height])
 849
 850     x = sin(radians(60/6))*Half_Flat
 851     y = cos(radians(60/6))*Half_Flat
 852     vec2 = mathutils.Vector([x,y,0.0])
 853     verts.append([x,y,-Flat_Height])
 854
 855     x = sin(radians(60/3))*Half_Flat
 856     y = cos(radians(60/3))*Half_Flat
 857     vec3 = mathutils.Vector([x,y,0.0])
 858     verts.append([x,y,-Flat_Height])
 859
 860     x = sin(radians(60/2))*Half_Flat
 861     y = cos(radians(60/2))*Half_Flat
 862     vec3 = mathutils.Vector([x,y,0.0])
 863     verts.append([x,y,-Flat_Height])
 864     Row += 1
 865
 866     #under cut down bit
 867     x = sin(radians(0))*Half_Flat
 868     y = cos(radians(0))*Half_Flat
 869     vec1 = mathutils.Vector([x,y,0.0])
 870     verts.append([x,y,-Flat_Height-Undercut_Height])
 871
 872     x = sin(radians(60/6))*Half_Flat
 873     y = cos(radians(60/6))*Half_Flat
 874     vec2 = mathutils.Vector([x,y,0.0])
 875     verts.append([x,y,-Flat_Height-Undercut_Height])
 876
 877     x = sin(radians(60/3))*Half_Flat
 878     y = cos(radians(60/3))*Half_Flat
 879     vec3 = mathutils.Vector([x,y,0.0])
 880     verts.append([x,y,-Flat_Height-Undercut_Height])
 881
 882     x = sin(radians(60/2))*Half_Flat
 883     y = cos(radians(60/2))*Half_Flat
 884     vec3 = mathutils.Vector([x,y,0.0])
 885     verts.append([x,y,-Flat_Height-Undercut_Height])
 886     Row += 1
 887
 888     #under cut to Shank BEVEAL
 889     x = sin(radians(0))*(SHANK_RADIUS+Shank_Bevel)
 890     y = cos(radians(0))*(SHANK_RADIUS+Shank_Bevel)
 891     vec1 = mathutils.Vector([x,y,0.0])
 892     verts.append([x,y,-Flat_Height-Undercut_Height])
 893
 894     x = sin(radians(60/6))*(SHANK_RADIUS+Shank_Bevel)
 895     y = cos(radians(60/6))*(SHANK_RADIUS+Shank_Bevel)
 896     vec2 = mathutils.Vector([x,y,0.0])
 897     verts.append([x,y,-Flat_Height-Undercut_Height])
 898
 899     x = sin(radians(60/3))*(SHANK_RADIUS+Shank_Bevel)
 900     y = cos(radians(60/3))*(SHANK_RADIUS+Shank_Bevel)
 901     vec3 = mathutils.Vector([x,y,0.0])
 902     verts.append([x,y,-Flat_Height-Undercut_Height])
 903
 904     x = sin(radians(60/2))*(SHANK_RADIUS+Shank_Bevel)
 905     y = cos(radians(60/2))*(SHANK_RADIUS+Shank_Bevel)
 906     vec3 = mathutils.Vector([x,y,0.0])
 907     verts.append([x,y,-Flat_Height-Undercut_Height])
 908     Row += 1
 909
 910     #under cut to Shank BEVEAL
 911     x = sin(radians(0))*SHANK_RADIUS
 912     y = cos(radians(0))*SHANK_RADIUS
 913     vec1 = mathutils.Vector([x,y,0.0])
 914     verts.append([x,y,-Flat_Height-Undercut_Height-Shank_Bevel])
 915
 916     x = sin(radians(60/6))*SHANK_RADIUS
 917     y = cos(radians(60/6))*SHANK_RADIUS
 918     vec2 = mathutils.Vector([x,y,0.0])
 919     verts.append([x,y,-Flat_Height-Undercut_Height-Shank_Bevel])
 920
 921     x = sin(radians(60/3))*SHANK_RADIUS
 922     y = cos(radians(60/3))*SHANK_RADIUS
 923     vec3 = mathutils.Vector([x,y,0.0])
 924     verts.append([x,y,-Flat_Height-Undercut_Height-Shank_Bevel])
 925
 926     x = sin(radians(60/2))*SHANK_RADIUS
 927     y = cos(radians(60/2))*SHANK_RADIUS
 928     vec3 = mathutils.Vector([x,y,0.0])
 929     verts.append([x,y,-Flat_Height-Undercut_Height-Shank_Bevel])
 930     Row += 1
 931
 932
 933     #Global_Head_Height = 0 - (-HEIGHT-0.1)
 934     faces.extend(Build_Face_List_Quads(FaceStart,3,Row - 1))
 935
 936
 937     Mirror_Verts,Mirror_Faces = Mirror_Verts_Faces(verts,faces,'y')
 938     verts.extend(Mirror_Verts)
 939     faces.extend(Mirror_Faces)
 940
 941     Spin_Verts,Spin_Faces = SpinDup(verts,faces,360,6,'z')
 942
 943
 944     return Spin_Verts,Spin_Faces,0 - (-HEIGHT)
 945
 946
 947 ##########################################################################################
 948 ##########################################################################################
 949 ##                    Create External Thread
 950 ##########################################################################################
 951 ##########################################################################################
 952
 953
 954
 955 def Thread_Start3(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
 956
 957
 958     Ret_Row = 0;
 959
 960     # Half_Pitch = float(PITCH)/2  # UNUSED
 961     Height_Start = Height_Offset - PITCH
 962     Height_Step = float(PITCH)/float(DIV)
 963     Deg_Step = 360.0 /float(DIV)
 964
 965     Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
 966     Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
 967     Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
 968
 969 #theard start
 970
 971     Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV)
 972     for j in range(4):
 973
 974         for i in range(DIV+1):
 975             z = Height_Offset - (Height_Step*i)
 976             if z > Height_Start:
 977                 z = Height_Start
 978             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
 979             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
 980             verts.append([x,y,z])
 981         Height_Offset -= Crest_Height
 982         Ret_Row += 1
 983
 984         for i in range(DIV+1):
 985             z = Height_Offset - (Height_Step*i)
 986             if z > Height_Start:
 987                 z = Height_Start
 988
 989             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
 990             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
 991             verts.append([x,y,z ])
 992         Height_Offset -= Crest_to_Root_Height
 993         Ret_Row += 1
 994
 995
 996         for i in range(DIV+1):
 997             z = Height_Offset - (Height_Step*i)
 998             if z > Height_Start:
 999                 z = Height_Start
1000
1001             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1002             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1003             if j == 0:
1004                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1005                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1006             verts.append([x,y,z ])
1007         Height_Offset -= Root_Height
1008         Ret_Row += 1
1009
1010         for i in range(DIV+1):
1011             z = Height_Offset - (Height_Step*i)
1012             if z > Height_Start:
1013                 z = Height_Start
1014
1015             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1016             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1017
1018             if j == 0:
1019                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1020                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1021             verts.append([x,y,z ])
1022         Height_Offset -= Root_to_Crest_Height
1023         Ret_Row += 1
1024
1025     return Ret_Row,Height_Offset
1026
1027
1028 def Create_Shank_Verts(START_DIA,OUTTER_DIA,LENGTH,Z_LOCATION = 0):
1029
1030     verts = []
1031     DIV = 36
1032
1033     START_RADIUS = START_DIA/2
1034     OUTTER_RADIUS = OUTTER_DIA/2
1035
1036     Opp = abs(START_RADIUS - OUTTER_RADIUS)
1037     Taper_Lentgh = Opp/tan(radians(31));
1038
1039     if Taper_Lentgh > LENGTH:
1040         Taper_Lentgh = 0
1041
1042     Stright_Length = LENGTH - Taper_Lentgh
1043
1044     Deg_Step = 360.0 /float(DIV)
1045
1046     Row = 0
1047
1048     Lowest_Z_Vert = 0;
1049
1050     Height_Offset = Z_LOCATION
1051
1052
1053         #ring
1054     for i in range(DIV+1):
1055         x = sin(radians(i*Deg_Step))*START_RADIUS
1056         y = cos(radians(i*Deg_Step))*START_RADIUS
1057         z =  Height_Offset - 0
1058         verts.append([x,y,z])
1059         Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1060     Height_Offset -= Stright_Length
1061     Row += 1
1062
1063     for i in range(DIV+1):
1064         x = sin(radians(i*Deg_Step))*START_RADIUS
1065         y = cos(radians(i*Deg_Step))*START_RADIUS
1066         z =  Height_Offset - 0
1067         verts.append([x,y,z])
1068         Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1069     Height_Offset -= Taper_Lentgh
1070     Row += 1
1071
1072
1073     return verts,Row,Height_Offset
1074
1075
1076 def Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION = 0):
1077
1078     verts = []
1079     DIV = 36
1080
1081     INNER_RADIUS = INNER_DIA/2
1082     OUTTER_RADIUS = OUTTER_DIA/2
1083
1084     # Half_Pitch = float(PITCH)/2  # UNUSED
1085     Deg_Step = 360.0 /float(DIV)
1086     Height_Step = float(PITCH)/float(DIV)
1087
1088     Row = 0
1089
1090     Lowest_Z_Vert = 0;
1091
1092     Height_Offset = Z_LOCATION
1093
1094     Height_Start = Height_Offset
1095
1096     Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
1097     Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
1098     Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
1099
1100     Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV)
1101
1102     Height_Offset = Z_LOCATION + PITCH
1103     Cut_off = Z_LOCATION
1104
1105
1106     for j in range(1):
1107
1108         for i in range(DIV+1):
1109             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1110             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1111             z = Height_Offset - (Height_Step*i)
1112             if z > Cut_off : z = Cut_off
1113             verts.append([x,y,z])
1114             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1115         Height_Offset -= Crest_Height
1116         Row += 1
1117
1118         for i in range(DIV+1):
1119             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1120             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1121             z = Height_Offset - (Height_Step*i)
1122             if z > Cut_off : z = Cut_off
1123             verts.append([x,y,z])
1124             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1125         Height_Offset -= Crest_to_Root_Height
1126         Row += 1
1127
1128         for i in range(DIV+1):
1129             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1130             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1131             z = Height_Offset - (Height_Step*i)
1132             if z > Cut_off : z = Cut_off
1133             verts.append([x,y,z])
1134             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1135         Height_Offset -= Root_Height
1136         Row += 1
1137
1138         for i in range(DIV+1):
1139             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1140             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1141             z = Height_Offset - (Height_Step*i)
1142             if z > Cut_off : z = Cut_off
1143             verts.append([x,y,z])
1144             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1145         Height_Offset -= Root_to_Crest_Height
1146         Row += 1
1147
1148
1149     for j in range(2):
1150         for i in range(DIV+1):
1151             z = Height_Offset - (Height_Step*i)
1152             if z > Height_Start:
1153                 z = Height_Start
1154             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1155             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1156             verts.append([x,y,z])
1157             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1158         Height_Offset -= Crest_Height
1159         Row += 1
1160
1161         for i in range(DIV+1):
1162             z = Height_Offset - (Height_Step*i)
1163             if z > Height_Start:
1164                 z = Height_Start
1165
1166             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1167             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1168             verts.append([x,y,z ])
1169             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1170         Height_Offset -= Crest_to_Root_Height
1171         Row += 1
1172
1173
1174         for i in range(DIV+1):
1175             z = Height_Offset - (Height_Step*i)
1176             if z > Height_Start:
1177                 z = Height_Start
1178
1179             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1180             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1181             if j == 0:
1182                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1183                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1184             verts.append([x,y,z ])
1185             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1186         Height_Offset -= Root_Height
1187         Row += 1
1188
1189         for i in range(DIV+1):
1190             z = Height_Offset - (Height_Step*i)
1191             if z > Height_Start:
1192                 z = Height_Start
1193
1194             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1195             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1196
1197             if j == 0:
1198                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1199                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1200             verts.append([x,y,z ])
1201             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1202         Height_Offset -= Root_to_Crest_Height
1203         Row += 1
1204
1205
1206     return verts,Row,Height_Offset
1207
1208
1209
1210 def Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,HEIGHT,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION = 0):
1211     verts = []
1212
1213     DIV = 36
1214
1215     INNER_RADIUS = INNER_DIA/2
1216     OUTTER_RADIUS = OUTTER_DIA/2
1217
1218     # Half_Pitch = float(PITCH)/2  # UNUSED
1219     Deg_Step = 360.0 /float(DIV)
1220     Height_Step = float(PITCH)/float(DIV)
1221
1222     NUM_OF_START_THREADS = 4.0
1223     NUM_OF_END_THREADS = 3.0
1224     Num = int((HEIGHT- ((NUM_OF_START_THREADS*PITCH) + (NUM_OF_END_THREADS*PITCH) ))/PITCH)
1225     Row = 0
1226
1227
1228     Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
1229     Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
1230     Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
1231
1232
1233     Height_Offset = Z_LOCATION
1234
1235     Lowest_Z_Vert = 0;
1236
1237     for j in range(Num):
1238
1239         for i in range(DIV+1):
1240             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1241             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1242             z = Height_Offset - (Height_Step*i)
1243             verts.append([x,y,z])
1244             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1245         Height_Offset -= Crest_Height
1246         Row += 1
1247
1248         for i in range(DIV+1):
1249             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1250             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1251             z = Height_Offset - (Height_Step*i)
1252             verts.append([x,y,z])
1253             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1254         Height_Offset -= Crest_to_Root_Height
1255         Row += 1
1256
1257
1258         for i in range(DIV+1):
1259             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1260             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1261             z = Height_Offset - (Height_Step*i)
1262             verts.append([x,y,z])
1263             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1264         Height_Offset -= Root_Height
1265         Row += 1
1266
1267         for i in range(DIV+1):
1268             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1269             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1270             z = Height_Offset - (Height_Step*i)
1271             verts.append([x,y,z])
1272             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1273         Height_Offset -= Root_to_Crest_Height
1274         Row += 1
1275
1276     return verts,Row,Height_Offset
1277
1278
1279
1280 def Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION = 0):
1281     verts = []
1282
1283     DIV = 36
1284
1285     INNER_RADIUS = INNER_DIA/2
1286     OUTTER_RADIUS = OUTTER_DIA/2
1287
1288     # Half_Pitch = float(PITCH)/2  # UNUSED
1289     Deg_Step = 360.0 /float(DIV)
1290     Height_Step = float(PITCH)/float(DIV)
1291
1292     Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
1293     Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
1294     Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
1295
1296     # Col = 0  # UNUSED
1297     Row = 0
1298
1299     Height_Offset = Z_LOCATION
1300
1301     Tapper_Height_Start = Height_Offset - PITCH - PITCH
1302
1303     Max_Height = Tapper_Height_Start - PITCH
1304
1305     Lowest_Z_Vert = 0;
1306
1307     # FaceStart = len(verts)  # UNUSED
1308     for j in range(4):
1309
1310         for i in range(DIV+1):
1311             z = Height_Offset - (Height_Step*i)
1312             z = max(z,Max_Height)
1313             Tapper_Radius = OUTTER_RADIUS
1314             if z < Tapper_Height_Start:
1315                 Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
1316
1317             x = sin(radians(i*Deg_Step))*(Tapper_Radius)
1318             y = cos(radians(i*Deg_Step))*(Tapper_Radius)
1319             verts.append([x,y,z])
1320             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1321         Height_Offset -= Crest_Height
1322         Row += 1
1323
1324         for i in range(DIV+1):
1325             z = Height_Offset - (Height_Step*i)
1326             z = max(z,Max_Height)
1327             Tapper_Radius = OUTTER_RADIUS
1328             if z < Tapper_Height_Start:
1329                 Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
1330
1331             x = sin(radians(i*Deg_Step))*(Tapper_Radius)
1332             y = cos(radians(i*Deg_Step))*(Tapper_Radius)
1333             verts.append([x,y,z])
1334             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1335         Height_Offset -= Crest_to_Root_Height
1336         Row += 1
1337
1338
1339         for i in range(DIV+1):
1340             z = Height_Offset - (Height_Step*i)
1341             z = max(z,Max_Height)
1342             Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
1343             if Tapper_Radius > INNER_RADIUS:
1344                 Tapper_Radius = INNER_RADIUS
1345
1346             x = sin(radians(i*Deg_Step))*(Tapper_Radius)
1347             y = cos(radians(i*Deg_Step))*(Tapper_Radius)
1348             verts.append([x,y,z])
1349             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1350         Height_Offset -= Root_Height
1351         Row += 1
1352
1353         for i in range(DIV+1):
1354             z = Height_Offset - (Height_Step*i)
1355             z = max(z,Max_Height)
1356             Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
1357             if Tapper_Radius > INNER_RADIUS:
1358                 Tapper_Radius = INNER_RADIUS
1359
1360             x = sin(radians(i*Deg_Step))*(Tapper_Radius)
1361             y = cos(radians(i*Deg_Step))*(Tapper_Radius)
1362             verts.append([x,y,z])
1363             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1364         Height_Offset -= Root_to_Crest_Height
1365         Row += 1
1366
1367     return verts,Row,Height_Offset,Lowest_Z_Vert
1368
1369
1370
1371
1372 def Create_External_Thread(SHANK_DIA,SHANK_LENGTH,INNER_DIA,OUTTER_DIA,PITCH,LENGTH,CREST_PERCENT,ROOT_PERCENT):
1373
1374     verts = []
1375     faces = []
1376
1377     DIV = 36
1378
1379     Total_Row = 0
1380     # Thread_Len = 0  # UNUSED
1381
1382     Face_Start = len(verts)
1383     Offset = 0.0;
1384
1385
1386     Shank_Verts,Shank_Row,Offset = Create_Shank_Verts(SHANK_DIA,OUTTER_DIA,SHANK_LENGTH,Offset)
1387     Total_Row += Shank_Row
1388
1389     Thread_Start_Verts,Thread_Start_Row,Offset = Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Offset)
1390     Total_Row += Thread_Start_Row
1391
1392
1393     Thread_Verts,Thread_Row,Offset = Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,LENGTH,CREST_PERCENT,ROOT_PERCENT,Offset)
1394     Total_Row += Thread_Row
1395
1396
1397     Thread_End_Verts,Thread_End_Row,Offset,Lowest_Z_Vert = Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Offset )
1398     Total_Row += Thread_End_Row
1399
1400
1401     verts.extend(Shank_Verts)
1402     verts.extend(Thread_Start_Verts)
1403     verts.extend(Thread_Verts)
1404     verts.extend(Thread_End_Verts)
1405
1406     faces.extend(Build_Face_List_Quads(Face_Start,DIV,Total_Row -1,0))
1407     faces.extend(Fill_Ring_Face(len(verts)-DIV,DIV,1))
1408
1409     return verts,faces,0.0 - Lowest_Z_Vert
1410
1411
1412 ##########################################################################################
1413 ##########################################################################################
1414 ##                    Create Nut
1415 ##########################################################################################
1416 ##########################################################################################
1417
1418 def add_Hex_Nut(FLAT,HOLE_DIA,HEIGHT):
1419     global Global_Head_Height
1420     global Global_NutRad
1421
1422     verts = []
1423     faces = []
1424     HOLE_RADIUS = HOLE_DIA * 0.5
1425     Half_Flat = FLAT/2
1426     Half_Height = HEIGHT/2
1427     TopBevelRadius = Half_Flat - 0.05
1428
1429     Global_NutRad =  TopBevelRadius
1430
1431     Row = 0;
1432     Lowest_Z_Vert = 0.0;
1433
1434     verts.append([0.0,0.0,0.0])
1435
1436
1437     FaceStart = len(verts)
1438     #inner hole
1439
1440     x = sin(radians(0))*HOLE_RADIUS
1441     y = cos(radians(0))*HOLE_RADIUS
1442     #print ("rad 0 x;",  x,  "y:" ,y )
1443     verts.append([x,y,0.0])
1444
1445
1446     x = sin(radians(60/6))*HOLE_RADIUS
1447     y = cos(radians(60/6))*HOLE_RADIUS
1448     #print ("rad 60/6x;",  x,  "y:" ,y )
1449     verts.append([x,y,0.0])
1450
1451
1452     x = sin(radians(60/3))*HOLE_RADIUS
1453     y = cos(radians(60/3))*HOLE_RADIUS
1454     #print ("rad 60/3x;",  x,  "y:" ,y )
1455     verts.append([x,y,0.0])
1456
1457
1458     x = sin(radians(60/2))*HOLE_RADIUS
1459     y = cos(radians(60/2))*HOLE_RADIUS
1460     #print ("rad 60/2x;",  x,  "y:" ,y )
1461     verts.append([x,y,0.0])
1462     Row += 1
1463
1464
1465     #bevel
1466
1467     x = sin(radians(0))*TopBevelRadius
1468     y = cos(radians(0))*TopBevelRadius
1469     vec1 = mathutils.Vector([x,y,0.0])
1470     verts.append([x,y,0.0])
1471
1472
1473     x = sin(radians(60/6))*TopBevelRadius
1474     y = cos(radians(60/6))*TopBevelRadius
1475     vec2 = mathutils.Vector([x,y,0.0])
1476     verts.append([x,y,0.0])
1477
1478
1479     x = sin(radians(60/3))*TopBevelRadius
1480     y = cos(radians(60/3))*TopBevelRadius
1481     vec3 = mathutils.Vector([x,y,0.0])
1482     verts.append([x,y,0.0])
1483
1484
1485     x = sin(radians(60/2))*TopBevelRadius
1486     y = cos(radians(60/2))*TopBevelRadius
1487     vec4 = mathutils.Vector([x,y,0.0])
1488     verts.append([x,y,0.0])
1489     Row += 1
1490
1491     #Flats
1492
1493     x = tan(radians(0))*Half_Flat
1494     dvec = vec1 - mathutils.Vector([x,Half_Flat,0.0])
1495     verts.append([x,Half_Flat,-dvec.length])
1496     Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
1497
1498
1499     x = tan(radians(60/6))*Half_Flat
1500     dvec = vec2 - mathutils.Vector([x,Half_Flat,0.0])
1501     verts.append([x,Half_Flat,-dvec.length])
1502     Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
1503
1504
1505     x = tan(radians(60/3))*Half_Flat
1506     dvec = vec3 - mathutils.Vector([x,Half_Flat,0.0])
1507     Lowest_Point = -dvec.length
1508     verts.append([x,Half_Flat,-dvec.length])
1509     Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
1510
1511     x = tan(radians(60/2))*Half_Flat
1512     dvec = vec4 - mathutils.Vector([x,Half_Flat,0.0])
1513     Lowest_Point = -dvec.length
1514     verts.append([x,Half_Flat,-dvec.length])
1515     Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
1516     Row += 1
1517
1518     #down Bits Tri
1519     x = tan(radians(0))*Half_Flat
1520     verts.append([x,Half_Flat,Lowest_Point])
1521
1522
1523     x = tan(radians(60/6))*Half_Flat
1524     verts.append([x,Half_Flat,Lowest_Point])
1525     x = tan(radians(60/3))*Half_Flat
1526     verts.append([x,Half_Flat,Lowest_Point])
1527
1528     x = tan(radians(60/2))*Half_Flat
1529     verts.append([x,Half_Flat,Lowest_Point])
1530     Lowest_Z_Vert = min(Lowest_Z_Vert,Lowest_Point)
1531     Row += 1
1532
1533     #down Bits
1534
1535     x = tan(radians(0))*Half_Flat
1536     verts.append([x,Half_Flat,-Half_Height])
1537
1538     x = tan(radians(60/6))*Half_Flat
1539     verts.append([x,Half_Flat,-Half_Height])
1540
1541     x = tan(radians(60/3))*Half_Flat
1542     verts.append([x,Half_Flat,-Half_Height])
1543
1544     x = tan(radians(60/2))*Half_Flat
1545     verts.append([x,Half_Flat,-Half_Height])
1546     Lowest_Z_Vert = min(Lowest_Z_Vert,-Half_Height)
1547     Row += 1
1548
1549     faces.extend(Build_Face_List_Quads(FaceStart,3,Row - 1))
1550
1551     Global_Head_Height = HEIGHT
1552
1553     Tvert,tface = Mirror_Verts_Faces(verts,faces,'z',Lowest_Z_Vert)
1554     verts.extend(Tvert)
1555     faces.extend(tface)
1556
1557
1558     Tvert,tface = Mirror_Verts_Faces(verts,faces,'y')
1559     verts.extend(Tvert)
1560     faces.extend(tface)
1561
1562     S_verts,S_faces = SpinDup(verts,faces,360,6,'z')
1563
1564     #return verts,faces,TopBevelRadius
1565     return S_verts,S_faces,TopBevelRadius
1566
1567
1568
1569 def add_Nylon_Head(OUTSIDE_RADIUS,Z_LOCATION = 0):
1570     DIV = 36
1571     verts = []
1572     faces = []
1573     Row = 0
1574
1575     INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.25/4.75))
1576     EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4/4.75))
1577     RAD1 = (OUTSIDE_RADIUS * (0.5/4.75))
1578     OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0/4.75))
1579
1580
1581     FaceStart = len(verts)
1582
1583     # Start_Height = 0 - 3  # UNUSED
1584     Height_Offset = Z_LOCATION
1585     Lowest_Z_Vert = 0
1586
1587     x = INNER_HOLE
1588     z = (Height_Offset - OVER_ALL_HEIGTH) + EDGE_THICKNESS
1589     verts.append([x,0.0,z])
1590     Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1591     Row += 1
1592
1593     x = INNER_HOLE
1594     z = (Height_Offset - OVER_ALL_HEIGTH)
1595     verts.append([x,0.0,z])
1596     Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1597     Row += 1
1598
1599
1600     for i in range(180,80,-10):
1601         x = sin(radians(i))*RAD1
1602         z = cos(radians(i))*RAD1
1603         verts.append([(OUTSIDE_RADIUS-RAD1)+x,0.0,((Height_Offset - OVER_ALL_HEIGTH)+RAD1)+z])
1604         Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1605         Row += 1
1606
1607
1608     x = OUTSIDE_RADIUS - 0
1609     z = Height_Offset
1610     verts.append([x,0.0,z])
1611     Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1612     Row += 1
1613
1614     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'z')
1615     sVerts.extend(verts)        #add the start verts to the Spin verts to complete the loop
1616
1617     faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV))
1618
1619     return Move_Verts_Up_Z(sVerts,0),faces,Lowest_Z_Vert
1620
1621
1622
1623 def add_Nylon_Part(OUTSIDE_RADIUS,Z_LOCATION = 0):
1624     DIV = 36
1625     verts = []
1626     faces = []
1627     Row = 0
1628
1629     INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.5/4.75))
1630     EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4/4.75))
1631     # RAD1 = (OUTSIDE_RADIUS * (0.5/4.75))  # UNUSED
1632     OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0/4.75))
1633     PART_THICKNESS = OVER_ALL_HEIGTH - EDGE_THICKNESS
1634     PART_INNER_HOLE = (OUTSIDE_RADIUS * (2.5/4.75))
1635
1636     FaceStart = len(verts)
1637
1638     # Start_Height = 0 - 3  # UNUSED
1639     Height_Offset = Z_LOCATION
1640     Lowest_Z_Vert = 0
1641
1642
1643     x = INNER_HOLE + EDGE_THICKNESS
1644     z = Height_Offset
1645     verts.append([x,0.0,z])
1646     Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1647     Row += 1
1648
1649     x = PART_INNER_HOLE
1650     z = Height_Offset
1651     verts.append([x,0.0,z])
1652     Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1653     Row += 1
1654
1655     x = PART_INNER_HOLE
1656     z = Height_Offset - PART_THICKNESS
1657     verts.append([x,0.0,z])
1658     Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1659     Row += 1
1660
1661     x = INNER_HOLE + EDGE_THICKNESS
1662     z = Height_Offset - PART_THICKNESS
1663     verts.append([x,0.0,z])
1664     Lowest_Z_Vert = min(Lowest_Z_Vert,z)
1665     Row += 1
1666
1667
1668     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'z')
1669     sVerts.extend(verts)  #add the start verts to the Spin verts to complete the loop
1670
1671     faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV,1))
1672
1673     return sVerts,faces,0 - Lowest_Z_Vert
1674
1675
1676 ##########################################################################################
1677 ##########################################################################################
1678 ##                    Create Internal Thread
1679 ##########################################################################################
1680 ##########################################################################################
1681
1682
1683 def Create_Internal_Thread_Start_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
1684
1685
1686     Ret_Row = 0;
1687
1688     Height_Offset = Height_Offset + PITCH  #Move the offset up so that the verts start at
1689                                            #at the correct place  (Height_Start)
1690
1691     # Half_Pitch = float(PITCH)/2  # UNUSED
1692     Height_Start = Height_Offset - PITCH
1693     Height_Step = float(PITCH)/float(DIV)
1694     Deg_Step = 360.0 /float(DIV)
1695
1696     Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
1697     Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
1698     Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
1699
1700
1701     Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV)
1702     for j in range(1):  #FIXME - for j in range(1) what?!
1703
1704         for i in range(DIV+1):
1705             z = Height_Offset - (Height_Step*i)
1706             if z > Height_Start:
1707                 z = Height_Start
1708             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1709             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1710             verts.append([x,y,z])
1711         Height_Offset -= Crest_Height
1712         Ret_Row += 1
1713
1714         for i in range(DIV+1):
1715             z = Height_Offset - (Height_Step*i)
1716             if z > Height_Start:
1717                 z = Height_Start
1718
1719             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1720             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1721             verts.append([x,y,z ])
1722         Height_Offset -= Crest_to_Root_Height
1723         Ret_Row += 1
1724
1725
1726         for i in range(DIV+1):
1727             z = Height_Offset - (Height_Step*i)
1728             if z > Height_Start:
1729                 z = Height_Start
1730
1731             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1732             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1733             if j == 0:
1734                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1735                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1736             verts.append([x,y,z ])
1737         Height_Offset -= Root_Height
1738         Ret_Row += 1
1739
1740         for i in range(DIV+1):
1741             z = Height_Offset - (Height_Step*i)
1742             if z > Height_Start:
1743                 z = Height_Start
1744
1745             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1746             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1747
1748             if j == 0:
1749                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1750                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
1751             verts.append([x,y,z ])
1752         Height_Offset -= Root_to_Crest_Height
1753         Ret_Row += 1
1754
1755     return Ret_Row,Height_Offset
1756
1757
1758 def Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
1759
1760
1761     Ret_Row = 0;
1762
1763     # Half_Pitch = float(PITCH)/2  # UNUSED
1764     #Height_End = Height_Offset - PITCH - PITCH - PITCH- PITCH - PITCH- PITCH
1765     Height_End = Height_Offset - PITCH
1766     #Height_End = -2.1
1767     Height_Step = float(PITCH)/float(DIV)
1768     Deg_Step = 360.0 /float(DIV)
1769
1770     Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
1771     Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
1772     Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
1773
1774
1775     Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV)
1776
1777     Num = 0
1778
1779     for j in range(2):
1780
1781         for i in range(DIV+1):
1782             z = Height_Offset - (Height_Step*i)
1783             if z < Height_End:
1784                 z = Height_End
1785             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1786             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1787             verts.append([x,y,z])
1788         Height_Offset -= Crest_Height
1789         Ret_Row += 1
1790
1791
1792         for i in range(DIV+1):
1793             z = Height_Offset - (Height_Step*i)
1794             if z < Height_End:
1795                 z = Height_End
1796
1797             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1798             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1799             verts.append([x,y,z ])
1800         Height_Offset -= Crest_to_Root_Height
1801         Ret_Row += 1
1802
1803
1804         for i in range(DIV+1):
1805             z = Height_Offset - (Height_Step*i)
1806             if z < Height_End:
1807                 z = Height_End
1808
1809             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1810             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1811             if j == Num:
1812                 x = sin(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
1813                 y = cos(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
1814             if j > Num:
1815                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS)
1816                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS )
1817
1818             verts.append([x,y,z ])
1819         Height_Offset -= Root_Height
1820         Ret_Row += 1
1821
1822
1823         for i in range(DIV+1):
1824             z = Height_Offset - (Height_Step*i)
1825             if z < Height_End:
1826                 z = Height_End
1827
1828             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1829             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1830
1831             if j == Num:
1832                 x = sin(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
1833                 y = cos(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
1834             if j > Num:
1835                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS )
1836                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS )
1837
1838             verts.append([x,y,z ])
1839         Height_Offset -= Root_to_Crest_Height
1840         Ret_Row += 1
1841
1842
1843     return Ret_Row,Height_End  # send back Height End as this is the lowest point
1844
1845
1846 def Create_Internal_Thread(INNER_DIA,OUTTER_DIA,PITCH,HEIGHT,CREST_PERCENT,ROOT_PERCENT,INTERNAL = 1):
1847     verts = []
1848     faces = []
1849
1850     DIV = 36
1851
1852     INNER_RADIUS = INNER_DIA/2
1853     OUTTER_RADIUS = OUTTER_DIA/2
1854
1855     # Half_Pitch = float(PITCH)/2  # UNUSED
1856     Deg_Step = 360.0 /float(DIV)
1857     Height_Step = float(PITCH)/float(DIV)
1858
1859     Num = int(round((HEIGHT- PITCH)/PITCH))  # less one pitch for the start and end that is 1/2 pitch high
1860
1861     # Col = 0  # UNUSED
1862     Row = 0
1863
1864
1865     Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
1866     Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
1867     Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
1868
1869     Height_Offset = 0
1870     FaceStart = len(verts)
1871
1872     Row_Inc,Height_Offset = Create_Internal_Thread_Start_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset)
1873     Row += Row_Inc
1874
1875     for j in range(Num):
1876
1877         for i in range(DIV+1):
1878             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1879             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1880             verts.append([x,y,Height_Offset - (Height_Step*i) ])
1881         Height_Offset -= Crest_Height
1882         Row += 1
1883
1884         for i in range(DIV+1):
1885             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
1886             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
1887             verts.append([x,y,Height_Offset - (Height_Step*i) ])
1888         Height_Offset -= Crest_to_Root_Height
1889         Row += 1
1890
1891         for i in range(DIV+1):
1892             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1893             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1894             verts.append([x,y,Height_Offset - (Height_Step*i) ])
1895         Height_Offset -= Root_Height
1896         Row += 1
1897
1898         for i in range(DIV+1):
1899             x = sin(radians(i*Deg_Step))*INNER_RADIUS
1900             y = cos(radians(i*Deg_Step))*INNER_RADIUS
1901             verts.append([x,y,Height_Offset - (Height_Step*i) ])
1902         Height_Offset -= Root_to_Crest_Height
1903         Row += 1
1904
1905
1906     Row_Inc,Height_Offset = Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset)
1907     Row += Row_Inc
1908
1909     faces.extend(Build_Face_List_Quads(FaceStart,DIV,Row -1,INTERNAL))
1910
1911     return verts,faces,0 - Height_Offset
1912
1913
1914 def Nut_Mesh(props, context):
1915
1916     verts = []
1917     faces = []
1918     Head_Verts = []
1919     Head_Faces= []
1920     #sc = context.scene
1921
1922     New_Nut_Height = 5
1923
1924     Face_Start = len(verts)
1925     Thread_Verts,Thread_Faces,New_Nut_Height = Create_Internal_Thread(props.bf_Minor_Dia,props.bf_Major_Dia,props.bf_Pitch,props.bf_Hex_Nut_Height,props.bf_Crest_Percent,props.bf_Root_Percent,1)
1926     verts.extend(Thread_Verts)
1927     faces.extend(Copy_Faces(Thread_Faces,Face_Start))
1928
1929     Face_Start = len(verts)
1930     Head_Verts,Head_Faces,Lock_Nut_Rad = add_Hex_Nut(props.bf_Hex_Nut_Flat_Distance,props.bf_Major_Dia,New_Nut_Height)
1931     verts.extend((Head_Verts))
1932     faces.extend(Copy_Faces(Head_Faces,Face_Start))
1933
1934     LowZ = 0 - New_Nut_Height
1935
1936     if props.bf_Nut_Type == 'bf_Nut_Lock':
1937         Face_Start = len(verts)
1938         Nylon_Head_Verts,Nylon_Head_faces,LowZ = add_Nylon_Head(Lock_Nut_Rad,0-New_Nut_Height)
1939         verts.extend((Nylon_Head_Verts))
1940         faces.extend(Copy_Faces(Nylon_Head_faces,Face_Start))
1941
1942         Face_Start = len(verts)
1943         Nylon_Verts,Nylon_faces,Temp_LowZ = add_Nylon_Part(Lock_Nut_Rad,0-New_Nut_Height)
1944         verts.extend((Nylon_Verts))
1945         faces.extend(Copy_Faces(Nylon_faces,Face_Start))
1946
1947
1948     return Move_Verts_Up_Z(verts,0 - LowZ),faces
1949
1950
1951
1952 ##########################################################################################
1953 ##########################################################################################
1954 ##########################################################################################
1955 ##                    Create Bolt
1956 ##########################################################################################
1957 ##########################################################################################
1958
1959
1960
1961 def Bolt_Mesh(props, context):
1962
1963
1964     verts = []
1965     faces = []
1966     Bit_Verts = []
1967     Bit_Faces = []
1968     Bit_Dia = 0.001
1969     Head_Verts = []
1970     Head_Faces= []
1971     Head_Height = 0.0
1972     #sc = context.scene
1973
1974     ReSized_Allen_Bit_Flat_Distance = props.bf_Allen_Bit_Flat_Distance   # set default
1975
1976
1977     Head_Height = props.bf_Hex_Head_Height # will be changed by the Head Functions
1978
1979
1980     if props.bf_Bit_Type == 'bf_Bit_Allen' and props.bf_Head_Type == 'bf_Head_Pan':
1981         #need to size Allen bit if it is too big.
1982         if  Allen_Bit_Dia(props.bf_Allen_Bit_Flat_Distance) > Max_Pan_Bit_Dia(props.bf_Pan_Head_Dia):
1983             ReSized_Allen_Bit_Flat_Distance = Allen_Bit_Dia_To_Flat(Max_Pan_Bit_Dia(props.bf_Pan_Head_Dia)) * 1.05
1984             #print ("Resized Allen Bit Flat Distance to ",ReSized_Allen_Bit_Flat_Distance)
1985
1986     #bit Mesh
1987     if props.bf_Bit_Type == 'bf_Bit_Allen':
1988         Bit_Verts,Bit_Faces,Bit_Dia = Create_Allen_Bit(ReSized_Allen_Bit_Flat_Distance,props.bf_Allen_Bit_Depth)
1989
1990     if props.bf_Bit_Type == 'bf_Bit_Philips':
1991         Bit_Verts,Bit_Faces,Bit_Dia = Create_Phillips_Bit(props.bf_Philips_Bit_Dia,props.bf_Philips_Bit_Dia*(0.5/1.82),props.bf_Phillips_Bit_Depth)
1992
1993
1994     #Head Mesh
1995
1996     if props.bf_Head_Type =='bf_Head_Hex':
1997         Head_Verts,Head_Faces,Head_Height = Create_Hex_Head(props.bf_Hex_Head_Flat_Distance,Bit_Dia,props.bf_Shank_Dia,props.bf_Hex_Head_Height)
1998
1999     elif props.bf_Head_Type == 'bf_Head_Cap':
2000         Head_Verts,Head_Faces,Head_Height = Create_Cap_Head(Bit_Dia,props.bf_Cap_Head_Dia,props.bf_Shank_Dia,props.bf_Cap_Head_Height,props.bf_Cap_Head_Dia*(1.0/19.0),props.bf_Cap_Head_Dia*(1.0/19.0))
2001
2002     elif props.bf_Head_Type =='bf_Head_Dome':
2003         Head_Verts,Head_Faces,Head_Height = Create_Dome_Head(Bit_Dia,props.bf_Dome_Head_Dia,props.bf_Shank_Dia,props.bf_Hex_Head_Height,1,1,0)
2004
2005     elif props.bf_Head_Type == 'bf_Head_Pan':
2006         Head_Verts,Head_Faces,Head_Height = Create_Pan_Head(Bit_Dia,props.bf_Pan_Head_Dia,props.bf_Shank_Dia,props.bf_Hex_Head_Height,1,1,0)
2007
2008     elif props.bf_Head_Type == 'bf_Head_CounterSink':
2009         Head_Verts,Head_Faces,Head_Height = Create_CounterSink_Head(Bit_Dia,props.bf_CounterSink_Head_Dia,props.bf_Shank_Dia,props.bf_CounterSink_Head_Dia,props.bf_CounterSink_Head_Dia*(0.09/6.31))
2010 #Head_Verts,Head_Faces,Head_Height = Create_CounterSink_Head(Bit_Dia,props.bf_CounterSink_Head_Dia,props.bf_Shank_Dia,props.bf_CounterSink_Head_Dia,props.bf_CounterSink_Head_Dia*(1.0/19.0))
2011
2012     Face_Start = len(verts)
2013     verts.extend(Move_Verts_Up_Z(Bit_Verts,Head_Height))
2014     faces.extend(Copy_Faces(Bit_Faces,Face_Start))
2015
2016     Face_Start = len(verts)
2017     verts.extend(Move_Verts_Up_Z(Head_Verts,Head_Height))
2018     faces.extend(Copy_Faces(Head_Faces,Face_Start))
2019
2020     Face_Start = len(verts)
2021     Thread_Verts,Thread_Faces,Thread_Height = Create_External_Thread(props.bf_Shank_Dia,props.bf_Shank_Length,props.bf_Minor_Dia,props.bf_Major_Dia,props.bf_Pitch,props.bf_Thread_Length,props.bf_Crest_Percent,props.bf_Root_Percent)
2022
2023     verts.extend(Move_Verts_Up_Z(Thread_Verts,00))
2024     faces.extend(Copy_Faces(Thread_Faces,Face_Start))
2025
2026     return Move_Verts_Up_Z(verts,Thread_Height),faces
2027
2028 # calculates the matrix for the new object
2029 # depending on user pref
2030 def align_matrix(context):
2031     loc = Matrix.Translation(context.scene.cursor_location)
2032     obj_align = context.user_preferences.edit.object_align
2033     if (context.space_data.type == 'VIEW_3D'
2034         and obj_align == 'VIEW'):
2035         rot = context.space_data.region_3d.view_matrix.to_3x3().inverted().to_4x4()
2036     else:
2037         rot = Matrix()
2038     align_matrix = loc * rot
2039     return align_matrix
2040
2041
2042 # Create a new mesh (object) from verts/edges/faces.
2043 # verts/edges/faces ... List of vertices/edges/faces for the
2044 #                       new mesh (as used in from_pydata).
2045 # name ... Name of the new mesh (& object).
2046 # edit ... Replace existing mesh data.
2047 # Note: Using "edit" will destroy/delete existing mesh data.
2048 def create_mesh_object(context, verts, edges, faces, name, edit, align_matrix):
2049     scene = context.scene
2050     obj_act = scene.objects.active
2051
2052     # Can't edit anything, unless we have an active obj.
2053     if edit and not obj_act:
2054         return None
2055
2056     # Create new mesh
2057     mesh = bpy.data.meshes.new(name)
2058
2059     # Make a mesh from a list of verts/edges/faces.
2060     mesh.from_pydata(verts, edges, faces)
2061
2062     # Update mesh geometry after adding stuff.
2063     mesh.update()
2064
2065     # Deselect all objects when in object mode
2066     if bpy.ops.object.select_all.poll():
2067         bpy.ops.object.select_all(action='DESELECT')
2068
2069     if edit:
2070         # Replace geometry of existing object
2071
2072         # Use the active obj and select it.
2073         ob_new = obj_act
2074         ob_new.select = True
2075
2076         if obj_act.mode == 'OBJECT':
2077             # Get existing mesh datablock.
2078             old_mesh = ob_new.data
2079
2080             # Set object data to nothing
2081             ob_new.data = None
2082
2083             # Clear users of existing mesh datablock.
2084             old_mesh.user_clear()
2085
2086             # Remove old mesh datablock if no users are left.
2087             if (old_mesh.users == 0):
2088                 bpy.data.meshes.remove(old_mesh)
2089
2090             # Assign new mesh datablock.
2091             ob_new.data = mesh
2092
2093     else:
2094         # Create new object
2095         ob_new = bpy.data.objects.new(name, mesh)
2096
2097         # Link new object to the given scene and select it.
2098         scene.objects.link(ob_new)
2099         ob_new.select = True
2100
2101         # Place the object at the 3D cursor location.
2102         # apply viewRotaion
2103         ob_new.matrix_world = align_matrix
2104
2105     if obj_act and obj_act.mode == 'EDIT':
2106         if not edit:
2107             # We are in EditMode, switch to ObjectMode.
2108             bpy.ops.object.mode_set(mode='OBJECT')
2109
2110             # Select the active object as well.
2111             obj_act.select = True
2112
2113             # Apply location of new object.
2114             scene.update()
2115
2116             # Join new object into the active.
2117             bpy.ops.object.join()
2118
2119             # Switching back to EditMode.
2120             bpy.ops.object.mode_set(mode='EDIT')
2121
2122             ob_new = obj_act
2123
2124     else:
2125         # We are in ObjectMode.
2126         # Make the new object the active one.
2127         scene.objects.active = ob_new
2128
2129     return ob_new
2130
2131
2132 def Create_New_Mesh(props, context, align_matrix):
2133
2134     verts = []
2135     faces = []
2136     # sMeshName =''  # UNUSED
2137     sObjName =''
2138
2139     if props.bf_Model_Type == 'bf_Model_Bolt':
2140         #print('Create Bolt')
2141         verts, faces = Bolt_Mesh(props, context)
2142         # sMeshName = 'Bolt'  # UNUSED
2143         sObjName = 'Bolt'
2144
2145     if props.bf_Model_Type == 'bf_Model_Nut':
2146         #print('Create Nut')
2147         verts, faces = Nut_Mesh(props, context)
2148         # sMeshName = 'Nut'  # UNUSED
2149         sObjName = 'Nut'
2150
2151
2152     verts, faces = RemoveDoubles(verts, faces)
2153
2154     verts = Scale_Mesh_Verts(verts,GLOBAL_SCALE)
2155
2156     obj = create_mesh_object(context, verts, [], faces,sObjName,
2157             props.edit, align_matrix)
2158
2159     return obj
2160
2161