code cleanup: style and typo - some edits to bypass the comments spell checker.

1 files changed, 430 insertions, 430 deletions

diff --git a/add_mesh_BoltFactory/createMesh.py b/add_mesh_BoltFactory/createMesh.py
index 8bac9930..fa625b8d 100644
--- a/add_mesh_BoltFactory/createMesh.py
+++ b/add_mesh_BoltFactory/createMesh.py
@@ -20,7 +20,7 @@ import bpy
 import mathutils
 
 from math import *
-from itertools import * 
+from itertools import *
 
 NARROW_UI = 180
 MAX_INPUT_NUMBER = 50
@@ -47,14 +47,14 @@ def unpack_face_list(list_of_tuples):
 
         if len(face) != 3 and len(face) != 4:
             raise RuntimeError("{0} vertices in face".format(len(face)))
-        
+
         # rotate indices if the 4th is 0
         if len(face) == 4 and face[3] == 0:
             face = [face[3], face[0], face[1], face[2]]
 
         if len(face) == 3:
             face.append(0)
-            
+
         l.extend(face)
 
     return l
@@ -76,7 +76,7 @@ def RemoveDoubles(verts,faces,Decimal_Places = 4):
     new_faces = []
     dict_verts = {}
     Rounded_Verts = []
-    
+
     for v in verts:
         Rounded_Verts.append([round(v[0],Decimal_Places),round(v[1],Decimal_Places),round(v[2],Decimal_Places)])
 
@@ -89,12 +89,12 @@ def RemoveDoubles(verts,faces,Decimal_Places = 4):
             if Rounded_co not in dict_verts:
                 dict_verts[Rounded_co] = len(dict_verts)
                 new_verts.append(Real_co)
-            if dict_verts[Rounded_co] not in new_face: 
+            if dict_verts[Rounded_co] not in new_face:
                 new_face.append(dict_verts[Rounded_co])
         if len(new_face) == 3 or len(new_face) == 4:
             new_faces.append(new_face)
 
-    return new_verts,new_faces 
+    return new_verts,new_faces
 
 
 
@@ -123,13 +123,13 @@ def Scale_Mesh_Verts(verts,scale_factor):
 #        * axis (Vector object. (optional)) - The arbitrary axis of rotation used with "R"
 #
 #Returns: Matrix object.
-#    A new rotation matrix. 
+#    A new rotation matrix.
 def Simple_RotationMatrix(angle, matSize, axisFlag):
     if matSize != 4 :
         print ("Simple_RotationMatrix can only do 4x4")
-        
+
     q = radians(angle)  #make the rotation go clockwise
-    
+
     if axisFlag == 'x':
         matrix = mathutils.Matrix.Rotation(q, 4, 'X')
     elif  axisFlag == 'y':
@@ -143,7 +143,7 @@ def Simple_RotationMatrix(angle, matSize, axisFlag):
 
 ##########################################################################################
 ##########################################################################################
-##                    Converter Functions For Bolt Factory 
+##                    Converter Functions For Bolt Factory
 ##########################################################################################
 ##########################################################################################
 
@@ -157,7 +157,7 @@ def Get_Phillips_Bit_Height(Bit_Dia):
     Bit_Rad = Bit_Dia / 2.0
     x = Bit_Rad - Flat_Width_half
     y = tan(radians(60))*x
-    return float(y) 
+    return float(y)
 
 
 ##########################################################################################
@@ -168,11 +168,11 @@ def Get_Phillips_Bit_Height(Bit_Dia):
 
 # Returns a list of verts rotated by the given matrix. Used by SpinDup
 def Rot_Mesh(verts, matrix):
-    Vector = mathutils.Vector
+    from mathutils import Vector
     return [(matrix * Vector(v))[:] for v in verts]
 
 
-# Returns a list of faces that has there index incremented by offset 
+# Returns a list of faces that has there index incremented by offset
 def Copy_Faces(faces,offset):
     return [[(i + offset) for i in f] for f in faces]
 
@@ -181,60 +181,60 @@ def Copy_Faces(faces,offset):
 def SpinDup(VERTS,FACES,DEGREE,DIVISIONS,AXIS):
     verts=[]
     faces=[]
-    
+
     if DIVISIONS == 0:
-        DIVISIONS = 1  
-  
+        DIVISIONS = 1
+
     step = DEGREE/DIVISIONS # set step so pieces * step = degrees in arc
-    
+
     for i in range(int(DIVISIONS)):
         rotmat = Simple_RotationMatrix(step*i, 4, AXIS) # 4x4 rotation matrix, 30d about the x axis.
         Rot = Rot_Mesh(VERTS,rotmat)
-        faces.extend(Copy_Faces(FACES,len(verts)))    
+        faces.extend(Copy_Faces(FACES,len(verts)))
         verts.extend(Rot)
     return verts,faces
 
 
 
 # Returns a list of verts that have been moved up the z axis by DISTANCE
-def Move_Verts_Up_Z(VERTS,DISTANCE):        
+def Move_Verts_Up_Z(VERTS,DISTANCE):
     ret = []
     for v in VERTS:
         ret.append([v[0],v[1],v[2]+DISTANCE])
     return ret
 
 
-# Returns a list of verts and faces that has been mirrored in the AXIS 
+# Returns a list of verts and faces that has been mirrored in the AXIS
 def Mirror_Verts_Faces(VERTS,FACES,AXIS,FLIP_POINT =0):
     ret_vert = []
     ret_face = []
-    offset = len(VERTS)    
+    offset = len(VERTS)
     if AXIS == 'y':
         for v in VERTS:
             Delta = v[0] - FLIP_POINT
-            ret_vert.append([FLIP_POINT-Delta,v[1],v[2]]) 
+            ret_vert.append([FLIP_POINT-Delta,v[1],v[2]])
     if AXIS == 'x':
         for v in VERTS:
             Delta = v[1] - FLIP_POINT
-            ret_vert.append([v[0],FLIP_POINT-Delta,v[2]]) 
+            ret_vert.append([v[0],FLIP_POINT-Delta,v[2]])
     if AXIS == 'z':
         for v in VERTS:
             Delta = v[2] - FLIP_POINT
-            ret_vert.append([v[0],v[1],FLIP_POINT-Delta]) 
-            
+            ret_vert.append([v[0],v[1],FLIP_POINT-Delta])
+
     for f in FACES:
         fsub = []
         for i in range(len(f)):
             fsub.append(f[i]+ offset)
         fsub.reverse() # flip the order to make norm point out
         ret_face.append(fsub)
-            
+
     return ret_vert,ret_face
 
 
 
-# Returns a list of faces that 
-# make up an array of 4 point polygon. 
+# Returns a list of faces that
+# make up an array of 4 point polygon.
 def Build_Face_List_Quads(OFFSET,COLUM,ROW,FLIP = 0):
     Ret =[]
     RowStart = 0;
@@ -252,7 +252,7 @@ def Build_Face_List_Quads(OFFSET,COLUM,ROW,FLIP = 0):
     return Ret
 
 
-# Returns a list of faces that makes up a fill pattern for a 
+# Returns a list of faces that makes up a fill pattern for a
 # circle
 def Fill_Ring_Face(OFFSET,NUM,FACE_DOWN = 0):
     Ret =[]
@@ -275,7 +275,7 @@ def Fill_Ring_Face(OFFSET,NUM,FACE_DOWN = 0):
         else:
             TempFace[0] =Face[C];
             if Face[C] == 0:
-                TempFace[1] = NUM-1; 
+                TempFace[1] = NUM-1;
             else:
                 TempFace[1] = Face[C] - 1;
             TempFace[2] = Face[B];
@@ -283,12 +283,12 @@ def Fill_Ring_Face(OFFSET,NUM,FACE_DOWN = 0):
                 Ret.append([OFFSET+Face[0],OFFSET+Face[1],OFFSET+Face[2]])
             else:
                 Ret.append([OFFSET+Face[2],OFFSET+Face[1],OFFSET+Face[0]])
-        
+
         Face[0] = TempFace[0]
         Face[1] = TempFace[1]
         Face[2] = TempFace[2]
     return Ret
-    
+
 ######################################################################################
 ##########################################################################################
 ##########################################################################################
@@ -309,16 +309,16 @@ def Allen_Fill(OFFSET,FLIP= 0):
               [20,7,6],
               [20,8,7],
               [20,9,8],
-              
+
               [20,21,9],
-              
+
               [21,10,9],
               [21,11,10],
               [21,12,11],
               [21,13,12],
               [21,14,13],
               [21,15,14],
-              
+
               [21,22,15],
               [22,16,15],
               [22,17,16],
@@ -329,62 +329,62 @@ def Allen_Fill(OFFSET,FLIP= 0):
             faces.append([OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
         else:
             faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2]])
-            
+
     return faces
 
 def Allen_Bit_Dia(FLAT_DISTANCE):
     Flat_Radius = (float(FLAT_DISTANCE)/2.0)/cos(radians(30))
     return (Flat_Radius * 1.05) * 2.0
-    
+
 def Allen_Bit_Dia_To_Flat(DIA):
     Flat_Radius = (DIA/2.0)/1.05
     return (Flat_Radius * cos (radians(30)))* 2.0
-    
-    
+
+
 
 def Create_Allen_Bit(FLAT_DISTANCE,HEIGHT):
     Div = 36
     verts = []
     faces = []
-    
+
     Flat_Radius = (float(FLAT_DISTANCE)/2.0)/cos(radians(30))
     OUTTER_RADIUS = Flat_Radius * 1.05
     Outter_Radius_Height = Flat_Radius * (0.1/5.77)
     FaceStart_Outside = len(verts)
     Deg_Step = 360.0 /float(Div)
-    
+
     for i in range(int(Div/2)+1):    # only do half and mirror later
         x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
         y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
         verts.append([x,y,0])
-    
+
     FaceStart_Inside = len(verts)
-        
-    Deg_Step = 360.0 /float(6) 
-    for i in range(int(6/2)+1): 
+
+    Deg_Step = 360.0 /float(6)
+    for i in range(int(6/2)+1):
         x = sin(radians(i*Deg_Step))* Flat_Radius
         y = cos(radians(i*Deg_Step))* Flat_Radius
-        verts.append([x,y,0-Outter_Radius_Height])     
-     
+        verts.append([x,y,0-Outter_Radius_Height])
+
     faces.extend(Allen_Fill(FaceStart_Outside,0))
-    
-    
+
+
     FaceStart_Bottom = len(verts)
-    
-    Deg_Step = 360.0 /float(6) 
-    for i in range(int(6/2)+1): 
+
+    Deg_Step = 360.0 /float(6)
+    for i in range(int(6/2)+1):
         x = sin(radians(i*Deg_Step))* Flat_Radius
         y = cos(radians(i*Deg_Step))* Flat_Radius
-        verts.append([x,y,0-HEIGHT])     
-        
+        verts.append([x,y,0-HEIGHT])
+
     faces.extend(Build_Face_List_Quads(FaceStart_Inside,3,1,True))
     faces.extend(Fill_Ring_Face(FaceStart_Bottom,4))
-    
-    
+
+
     M_Verts,M_Faces = Mirror_Verts_Faces(verts,faces,'y')
     verts.extend(M_Verts)
     faces.extend(M_Faces)
-    
+
     return verts,faces,OUTTER_RADIUS * 2.0
 
 
@@ -401,32 +401,32 @@ def Phillips_Fill(OFFSET,FLIP= 0):
               [1,11,10],
               [1,2,11],
               [2,12,11],
-              
+
               [2,3,12],
               [3,4,12],
               [4,5,12],
               [5,6,12],
               [6,7,12],
-              
+
               [7,13,12],
               [7,8,13],
               [8,14,13],
               [8,9,14],
-              
-              
+
+
               [10,11,16,15],
               [11,12,16],
               [12,13,16],
               [13,14,17,16],
               [15,16,17,18]
-              
-              
+
+
               ]
     for i in Lookup:
         if FLIP:
             if len(i) == 3:
                 faces.append([OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
-            else:    
+            else:
                 faces.append([OFFSET+i[3],OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
         else:
             if len(i) == 3:
@@ -441,20 +441,20 @@ def Create_Phillips_Bit(FLAT_DIA,FLAT_WIDTH,HEIGHT):
     Div = 36
     verts = []
     faces = []
-    
+
     FLAT_RADIUS = FLAT_DIA * 0.5
     OUTTER_RADIUS = FLAT_RADIUS * 1.05
-    
+
     Flat_Half = float(FLAT_WIDTH)/2.0
-        
+
     FaceStart_Outside = len(verts)
     Deg_Step = 360.0 /float(Div)
     for i in range(int(Div/4)+1):    # only do half and mirror later
         x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
         y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
         verts.append([x,y,0])
-    
-        
+
+
     # FaceStart_Inside = len(verts)  # UNUSED
     verts.append([0,FLAT_RADIUS,0]) #10
     verts.append([Flat_Half,FLAT_RADIUS,0]) #11
@@ -462,19 +462,19 @@ def Create_Phillips_Bit(FLAT_DIA,FLAT_WIDTH,HEIGHT):
     verts.append([FLAT_RADIUS,Flat_Half,0])    #13
     verts.append([FLAT_RADIUS,0,0])            #14
 
- 
+
     verts.append([0,Flat_Half,0-HEIGHT])        #15
     verts.append([Flat_Half,Flat_Half,0-HEIGHT])    #16
     verts.append([Flat_Half,0,0-HEIGHT])            #17
-    
+
     verts.append([0,0,0-HEIGHT])            #18
-    
+
     faces.extend(Phillips_Fill(FaceStart_Outside,True))
 
     Spin_Verts,Spin_Face = SpinDup(verts,faces,360,4,'z')
-   
+
     return Spin_Verts,Spin_Face,OUTTER_RADIUS * 2
-    
+
 
 ##########################################################################################
 ##########################################################################################
@@ -504,7 +504,7 @@ def Create_Pan_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET):
     EndRad = HEAD_RADIUS * 0.284
     EndZOffset = HEAD_RADIUS * 0.432
     HEIGHT = HEAD_RADIUS * 0.59
-    
+
 #    Dome_Rad =  5.6
 #    RAD_Offset = 4.9
 #    OtherRad = 0.8
@@ -515,7 +515,7 @@ def Create_Pan_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET):
 #    EndRad = 1.42
 #    EndZOffset = 2.16
 #    HEIGHT = 2.95
-    
+
     FaceStart = FACE_OFFSET
 
     z = cos(radians(10))*ZRad
@@ -538,23 +538,23 @@ def Create_Pan_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET):
         else:
             verts.append([(HEAD_RADIUS -EndRad)+x,0.0,(0.0 - EndZOffset)+z])
         Row += 1
-        
-        
+
+
     verts.append([SHANK_RADIUS,0.0,(0.0-HEIGHT)])
     Row += 1
-    
+
     verts.append([SHANK_RADIUS,0.0,(0.0-HEIGHT)-Start_Height])
     Row += 1
 
 
     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'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))
 
     # Global_Head_Height = HEIGHT  # UNUSED
 
-    
+
     return Move_Verts_Up_Z(sVerts,Start_Height),faces,HEIGHT
 
 
@@ -564,13 +564,13 @@ def Create_Dome_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET):
     HOLE_RADIUS = HOLE_DIA * 0.5
     HEAD_RADIUS = HEAD_DIA * 0.5
     SHANK_RADIUS = SHANK_DIA * 0.5
-    
+
     verts = []
     faces = []
     Row = 0
     # BEVEL = HEIGHT * 0.01  # UNUSED
     #Dome_Rad =  HEAD_RADIUS * (1.0/1.75)
-    
+
     Dome_Rad =  HEAD_RADIUS * 1.12
     #Head_Height = HEAD_RADIUS * 0.78
     RAD_Offset = HEAD_RADIUS * 0.98
@@ -578,18 +578,18 @@ def Create_Dome_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET):
     OtherRad = HEAD_RADIUS * 0.16
     OtherRad_X_Offset = HEAD_RADIUS * 0.84
     OtherRad_Z_Offset = HEAD_RADIUS * 0.504
-    
-    
+
+
 #    Dome_Rad =  5.6
 #    RAD_Offset = 4.9
 #    Dome_Height = 3.2
 #    OtherRad = 0.8
 #    OtherRad_X_Offset = 4.2
 #    OtherRad_Z_Offset = 2.52
-#    
-    
+#
+
     FaceStart = FACE_OFFSET
-    
+
     verts.append([HOLE_RADIUS,0.0,0.0])
     Row += 1
 
@@ -610,14 +610,14 @@ def Create_Dome_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET):
             z = (0.0-Dome_Height)
         verts.append([OtherRad_X_Offset+x,0.0,z])
         Row += 1
-        
+
     verts.append([SHANK_RADIUS,0.0,(0.0-Dome_Height)])
     Row += 1
 
 
     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'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))
 
     return sVerts,faces,Dome_Height
@@ -626,12 +626,12 @@ def Create_Dome_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET):
 
 def Create_CounterSink_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1):
     DIV = 36
-    
+
     HOLE_RADIUS = HOLE_DIA * 0.5
     HEAD_RADIUS = HEAD_DIA * 0.5
     SHANK_RADIUS = SHANK_DIA * 0.5
-    
-    
+
+
     verts = []
     faces = []
     Row = 0
@@ -639,20 +639,20 @@ def Create_CounterSink_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1):
 #    HEAD_RADIUS = (HEIGHT/tan(radians(60))) + SHANK_RADIUS
     HEIGHT = tan(radians(60)) * (HEAD_RADIUS - SHANK_RADIUS)
     #print (RAD1)
-    
+
     FaceStart = len(verts)
 
     verts.append([HOLE_RADIUS,0.0,0.0])
     Row += 1
 
     #rad
-    
+
     for i in range(0,100,10):
         x = sin(radians(i))*RAD1
         z = cos(radians(i))*RAD1
         verts.append([(HEAD_RADIUS-RAD1)+x,0.0,(0.0-RAD1)+z])
         Row += 1
-    
+
 
     verts.append([SHANK_RADIUS,0.0,0.0-HEIGHT])
     Row += 1
@@ -660,10 +660,10 @@ def Create_CounterSink_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1):
 
     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'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,1))
-    
+
     return sVerts,faces,HEIGHT
 
 
@@ -671,31 +671,31 @@ def Create_CounterSink_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1):
 
 def Create_Cap_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2):
     DIV = 36
-    
+
     HOLE_RADIUS = HOLE_DIA * 0.5
     HEAD_RADIUS = HEAD_DIA * 0.5
     SHANK_RADIUS = SHANK_DIA * 0.5
-    
+
     verts = []
     faces = []
     Row = 0
     BEVEL = HEIGHT * 0.01
-    
-    
+
+
     FaceStart = len(verts)
 
     verts.append([HOLE_RADIUS,0.0,0.0])
     Row += 1
 
     #rad
-    
+
     for i in range(0,100,10):
         x = sin(radians(i))*RAD1
         z = cos(radians(i))*RAD1
         verts.append([(HEAD_RADIUS-RAD1)+x,0.0,(0.0-RAD1)+z])
         Row += 1
-    
-    
+
+
     verts.append([HEAD_RADIUS,0.0,0.0-HEIGHT+BEVEL])
     Row += 1
 
@@ -703,246 +703,246 @@ def Create_Cap_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2):
     Row += 1
 
     #rad2
-   
+
     for i in range(0,100,10):
         x = sin(radians(i))*RAD2
         z = cos(radians(i))*RAD2
         verts.append([(SHANK_RADIUS+RAD2)-x,0.0,(0.0-HEIGHT-RAD2)+z])
         Row += 1
-    
+
 
     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'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))
-    
+
     return sVerts,faces,HEIGHT+RAD2
 
 
 def Create_Hex_Head(FLAT,HOLE_DIA,SHANK_DIA,HEIGHT):
-    
+
     verts = []
     faces = []
     HOLE_RADIUS = HOLE_DIA * 0.5
     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)) 
+    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])
-    
-    
+
+
     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(60/6))*HOLE_RADIUS
     y = cos(radians(60/6))*HOLE_RADIUS
     verts.append([x,y,0.0])
-    
-    
+
+
     x = sin(radians(60/3))*HOLE_RADIUS
     y = cos(radians(60/3))*HOLE_RADIUS
     verts.append([x,y,0.0])
-    
-    
+
+
     x = sin(radians(60/2))*HOLE_RADIUS
     y = cos(radians(60/2))*HOLE_RADIUS
     verts.append([x,y,0.0])
     Row += 1
-    
+
     #bevel
-    
+
     x = sin(radians(0))*TopBevelRadius
     y = cos(radians(0))*TopBevelRadius
     vec1 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,0.0])
-    
-    
+
+
     x = sin(radians(60/6))*TopBevelRadius
     y = cos(radians(60/6))*TopBevelRadius
     vec2 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,0.0])
-    
-    
+
+
     x = sin(radians(60/3))*TopBevelRadius
     y = cos(radians(60/3))*TopBevelRadius
     vec3 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,0.0])
-    
-    
+
+
     x = sin(radians(60/2))*TopBevelRadius
     y = cos(radians(60/2))*TopBevelRadius
     vec4 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,0.0])
     Row += 1
-    
+
     #Flats
-    
+
     x = tan(radians(0))*Half_Flat
     dvec = vec1 - mathutils.Vector([x,Half_Flat,0.0])
     verts.append([x,Half_Flat,-dvec.length])
-    
-    
+
+
     x = tan(radians(60/6))*Half_Flat
     dvec = vec2 - mathutils.Vector([x,Half_Flat,0.0])
     verts.append([x,Half_Flat,-dvec.length])
-    
+
 
     x = tan(radians(60/3))*Half_Flat
     dvec = vec3 - mathutils.Vector([x,Half_Flat,0.0])
     Lowest_Point = -dvec.length
     verts.append([x,Half_Flat,-dvec.length])
-    
+
 
     x = tan(radians(60/2))*Half_Flat
     dvec = vec4 - mathutils.Vector([x,Half_Flat,0.0])
     Lowest_Point = -dvec.length
     verts.append([x,Half_Flat,-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])
     Row += 1
 
     #down Bits
-    
+
     x = tan(radians(0))*Half_Flat
     verts.append([x,Half_Flat,-Flat_Height])
-    
+
     x = tan(radians(60/6))*Half_Flat
     verts.append([x,Half_Flat,-Flat_Height])
 
     x = tan(radians(60/3))*Half_Flat
     verts.append([x,Half_Flat,-Flat_Height])
-    
+
     x = tan(radians(60/2))*Half_Flat
     verts.append([x,Half_Flat,-Flat_Height])
     Row += 1
-    
-    
-    #under cut 
-       
+
+
+    #under cut
+
     x = sin(radians(0))*Half_Flat
     y = cos(radians(0))*Half_Flat
     vec1 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height])
-    
+
     x = sin(radians(60/6))*Half_Flat
     y = cos(radians(60/6))*Half_Flat
     vec2 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height])
-    
+
     x = sin(radians(60/3))*Half_Flat
     y = cos(radians(60/3))*Half_Flat
     vec3 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height])
-    
+
     x = sin(radians(60/2))*Half_Flat
     y = cos(radians(60/2))*Half_Flat
     vec3 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height])
     Row += 1
-    
+
     #under cut down bit
     x = sin(radians(0))*Half_Flat
     y = cos(radians(0))*Half_Flat
     vec1 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height-Undercut_Height])
-    
+
     x = sin(radians(60/6))*Half_Flat
     y = cos(radians(60/6))*Half_Flat
     vec2 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height-Undercut_Height])
-    
+
     x = sin(radians(60/3))*Half_Flat
     y = cos(radians(60/3))*Half_Flat
     vec3 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height-Undercut_Height])
-    
+
     x = sin(radians(60/2))*Half_Flat
     y = cos(radians(60/2))*Half_Flat
     vec3 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height-Undercut_Height])
     Row += 1
-    
+
     #under cut to Shank BEVEAL
     x = sin(radians(0))*(SHANK_RADIUS+Shank_Bevel)
     y = cos(radians(0))*(SHANK_RADIUS+Shank_Bevel)
     vec1 = mathutils.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 = mathutils.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 = mathutils.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 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height-Undercut_Height])
     Row += 1
-    
+
     #under cut to Shank BEVEAL
     x = sin(radians(0))*SHANK_RADIUS
     y = cos(radians(0))*SHANK_RADIUS
     vec1 = mathutils.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 = mathutils.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 = mathutils.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 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,-Flat_Height-Undercut_Height-Shank_Bevel])
     Row += 1
-    
-    
+
+
     #Global_Head_Height = 0 - (-HEIGHT-0.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)
-   
+
 
 ##########################################################################################
 ##########################################################################################
@@ -953,26 +953,26 @@ def Create_Hex_Head(FLAT,HOLE_DIA,SHANK_DIA,HEIGHT):
 
 
 def Thread_Start3(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
-    
-    
+
+
     Ret_Row = 0;
-    
+
     # Half_Pitch = float(PITCH)/2  # UNUSED
     Height_Start = Height_Offset - PITCH
     Height_Step = float(PITCH)/float(DIV)
     Deg_Step = 360.0 /float(DIV)
-    
+
     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
-   
+
 #theard start
 
     Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV)
     for j in range(4):
-        
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            z = Height_Offset - (Height_Step*i)
             if z > Height_Start:
                 z = Height_Start
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
@@ -980,24 +980,24 @@ def Thread_Start3(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_
             verts.append([x,y,z])
         Height_Offset -= Crest_Height
         Ret_Row += 1
-    
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            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+1):
-            z = Height_Offset - (Height_Step*i) 
+            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:
@@ -1006,12 +1006,12 @@ def Thread_Start3(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_
             verts.append([x,y,z ])
         Height_Offset -= Root_Height
         Ret_Row += 1
-    
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            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
 
@@ -1021,7 +1021,7 @@ def Thread_Start3(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_
             verts.append([x,y,z ])
         Height_Offset -= Root_to_Crest_Height
         Ret_Row += 1
-   
+
     return Ret_Row,Height_Offset
 
 
@@ -1029,29 +1029,29 @@ def Create_Shank_Verts(START_DIA,OUTTER_DIA,LENGTH,Z_LOCATION = 0):
 
     verts = []
     DIV = 36
-    
+
     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)
-    
+
     Row = 0
-    
-    Lowest_Z_Vert = 0;    
-    
+
+    Lowest_Z_Vert = 0;
+
     Height_Offset = Z_LOCATION
 
 
         #ring
-    for i in range(DIV+1): 
+    for i in range(DIV+1):
         x = sin(radians(i*Deg_Step))*START_RADIUS
         y = cos(radians(i*Deg_Step))*START_RADIUS
         z =  Height_Offset - 0
@@ -1060,7 +1060,7 @@ def Create_Shank_Verts(START_DIA,OUTTER_DIA,LENGTH,Z_LOCATION = 0):
     Height_Offset -= Stright_Length
     Row += 1
 
-    for i in range(DIV+1): 
+    for i in range(DIV+1):
         x = sin(radians(i*Deg_Step))*START_RADIUS
         y = cos(radians(i*Deg_Step))*START_RADIUS
         z =  Height_Offset - 0
@@ -1074,37 +1074,37 @@ def Create_Shank_Verts(START_DIA,OUTTER_DIA,LENGTH,Z_LOCATION = 0):
 
 
 def Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION = 0):
-    
+
     verts = []
     DIV = 36
-    
+
     INNER_RADIUS = INNER_DIA/2
     OUTTER_RADIUS = OUTTER_DIA/2
-    
+
     # Half_Pitch = float(PITCH)/2  # UNUSED
     Deg_Step = 360.0 /float(DIV)
     Height_Step = float(PITCH)/float(DIV)
 
     Row = 0
-    
-    Lowest_Z_Vert = 0;    
-    
+
+    Lowest_Z_Vert = 0;
+
     Height_Offset = Z_LOCATION
-        
-    Height_Start = Height_Offset 
-    
+
+    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)
-    
-    Height_Offset = Z_LOCATION + PITCH 
+
+    Height_Offset = Z_LOCATION + PITCH
     Cut_off = Z_LOCATION
-  
-    
+
+
     for j in range(1):
-        
+
         for i in range(DIV+1):
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
@@ -1114,7 +1114,7 @@ def Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERC
             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
         Height_Offset -= Crest_Height
         Row += 1
-    
+
         for i in range(DIV+1):
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
@@ -1124,31 +1124,31 @@ def Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERC
             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
         Height_Offset -= Crest_to_Root_Height
         Row += 1
-        
+
         for i in range(DIV+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 
+            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+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 
+            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+1):
-            z = Height_Offset - (Height_Step*i) 
+            z = Height_Offset - (Height_Step*i)
             if z > Height_Start:
                 z = Height_Start
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
@@ -1157,25 +1157,25 @@ def Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERC
             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
         Height_Offset -= Crest_Height
         Row += 1
-    
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            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+1):
-            z = Height_Offset - (Height_Step*i) 
+            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:
@@ -1185,12 +1185,12 @@ def Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERC
             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
         Height_Offset -= Root_Height
         Row += 1
-    
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            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
 
@@ -1201,20 +1201,20 @@ def Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERC
             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 = 0):
     verts = []
-        
+
     DIV = 36
-    
+
     INNER_RADIUS = INNER_DIA/2
     OUTTER_RADIUS = OUTTER_DIA/2
-    
+
     # Half_Pitch = float(PITCH)/2  # UNUSED
     Deg_Step = 360.0 /float(DIV)
     Height_Step = float(PITCH)/float(DIV)
@@ -1223,7 +1223,7 @@ def Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,HEIGHT,CREST_PERCENT,ROOT_PER
     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)
@@ -1231,20 +1231,20 @@ def Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,HEIGHT,CREST_PERCENT,ROOT_PER
 
 
     Height_Offset = Z_LOCATION
-    
+
     Lowest_Z_Vert = 0;
 
     for j in range(Num):
-        
+
         for i in range(DIV+1):
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
-            z = Height_Offset - (Height_Step*i) 
+            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+1):
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
@@ -1253,38 +1253,38 @@ def Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,HEIGHT,CREST_PERCENT,ROOT_PER
             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
         Height_Offset -= Crest_to_Root_Height
         Row += 1
-    
-        
+
+
         for i in range(DIV+1):
             x = sin(radians(i*Deg_Step))*INNER_RADIUS
             y = cos(radians(i*Deg_Step))*INNER_RADIUS
-            z = Height_Offset - (Height_Step*i) 
+            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+1):
             x = sin(radians(i*Deg_Step))*INNER_RADIUS
             y = cos(radians(i*Deg_Step))*INNER_RADIUS
-            z = Height_Offset - (Height_Step*i) 
+            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 = 0):
     verts = []
-        
+
     DIV = 36
 
     INNER_RADIUS = INNER_DIA/2
     OUTTER_RADIUS = OUTTER_DIA/2
-    
+
     # Half_Pitch = float(PITCH)/2  # UNUSED
     Deg_Step = 360.0 /float(DIV)
     Height_Step = float(PITCH)/float(DIV)
@@ -1292,21 +1292,21 @@ def Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCEN
     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
-       
+
     # Col = 0  # UNUSED
     Row = 0
-    
-    Height_Offset = Z_LOCATION 
-    
-    Tapper_Height_Start = Height_Offset - PITCH - PITCH 
-    
-    Max_Height = Tapper_Height_Start - PITCH 
-    
+
+    Height_Offset = Z_LOCATION
+
+    Tapper_Height_Start = Height_Offset - PITCH - PITCH
+
+    Max_Height = Tapper_Height_Start - PITCH
+
     Lowest_Z_Vert = 0;
-    
+
     # FaceStart = len(verts)  # UNUSED
     for j in range(4):
-        
+
         for i in range(DIV+1):
             z = Height_Offset - (Height_Step*i)
             z = max(z,Max_Height)
@@ -1320,7 +1320,7 @@ def Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCEN
             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
         Height_Offset -= Crest_Height
         Row += 1
-    
+
         for i in range(DIV+1):
             z = Height_Offset - (Height_Step*i)
             z = max(z,Max_Height)
@@ -1334,80 +1334,80 @@ def Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCEN
             Lowest_Z_Vert = min(Lowest_Z_Vert,z)
         Height_Offset -= Crest_to_Root_Height
         Row += 1
-    
-        
+
+
         for i in range(DIV+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+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):
-    
+
     verts = []
     faces = []
 
     DIV = 36
-    
+
     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)
     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)
     Total_Row += Thread_Start_Row
-    
-    
+
+
     Thread_Verts,Thread_Row,Offset = Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,LENGTH,CREST_PERCENT,ROOT_PERCENT,Offset)
     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 )
-    Total_Row += Thread_End_Row       
-    
-    
+    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,Total_Row -1,0))
     faces.extend(Fill_Ring_Face(len(verts)-DIV,DIV,1))
-    
+
     return verts,faces,0.0 - Lowest_Z_Vert
- 
+
 
 ##########################################################################################
 ##########################################################################################
@@ -1418,89 +1418,89 @@ def Create_External_Thread(SHANK_DIA,SHANK_LENGTH,INNER_DIA,OUTTER_DIA,PITCH,LEN
 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 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,0.0])
-    
-    
+
+
     x = sin(radians(60/6))*TopBevelRadius
     y = cos(radians(60/6))*TopBevelRadius
     vec2 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,0.0])
-    
-    
+
+
     x = sin(radians(60/3))*TopBevelRadius
     y = cos(radians(60/3))*TopBevelRadius
     vec3 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,0.0])
-    
-    
+
+
     x = sin(radians(60/2))*TopBevelRadius
     y = cos(radians(60/2))*TopBevelRadius
     vec4 = mathutils.Vector([x,y,0.0])
     verts.append([x,y,0.0])
     Row += 1
-    
+
     #Flats
-    
+
     x = tan(radians(0))*Half_Flat
     dvec = vec1 - mathutils.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 - mathutils.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 - mathutils.Vector([x,Half_Flat,0.0])
@@ -1514,53 +1514,53 @@ def add_Hex_Nut(FLAT,HOLE_DIA,HEIGHT):
     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
 
@@ -1576,44 +1576,44 @@ def add_Nylon_Head(OUTSIDE_RADIUS,Z_LOCATION = 0):
     EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4/4.75))
     RAD1 = (OUTSIDE_RADIUS * (0.5/4.75))
     OVER_ALL_HEIGTH = (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_HEIGTH) + 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_HEIGTH)
     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_HEIGTH)+RAD1)+z])
         Lowest_Z_Vert = min(Lowest_Z_Vert,z)
         Row += 1
-    
-    
+
+
     x = OUTSIDE_RADIUS - 0
-    z = Height_Offset 
+    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,'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))
 
     return Move_Verts_Up_Z(sVerts,0),faces,Lowest_Z_Vert
@@ -1632,32 +1632,32 @@ def add_Nylon_Part(OUTSIDE_RADIUS,Z_LOCATION = 0):
     OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0/4.75))
     PART_THICKNESS = OVER_ALL_HEIGTH - EDGE_THICKNESS
     PART_INNER_HOLE = (OUTSIDE_RADIUS * (2.5/4.75))
-    
+
     FaceStart = len(verts)
 
     # Start_Height = 0 - 3  # UNUSED
     Height_Offset = Z_LOCATION
     Lowest_Z_Vert = 0
-    
+
 
     x = INNER_HOLE + EDGE_THICKNESS
-    z = Height_Offset 
+    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
-    
+
     x = PART_INNER_HOLE
     z = Height_Offset - PART_THICKNESS
     verts.append([x,0.0,z])
     Lowest_Z_Vert = min(Lowest_Z_Vert,z)
     Row += 1
-    
+
     x = INNER_HOLE + EDGE_THICKNESS
     z = Height_Offset - PART_THICKNESS
     verts.append([x,0.0,z])
@@ -1667,7 +1667,7 @@ def add_Nylon_Part(OUTSIDE_RADIUS,Z_LOCATION = 0):
 
     sVerts,sFaces = SpinDup(verts,faces,360,DIV,'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,1))
 
     return sVerts,faces,0 - Lowest_Z_Vert
@@ -1681,28 +1681,28 @@ def add_Nylon_Part(OUTSIDE_RADIUS,Z_LOCATION = 0):
 
 
 def Create_Internal_Thread_Start_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
-    
-    
+
+
     Ret_Row = 0;
-    
-    Height_Offset = Height_Offset + PITCH  #Move the offset up so that the verts start at 
+
+    Height_Offset = Height_Offset + PITCH  #Move the offset up so that the verts start at
                                            #at the correct place  (Height_Start)
-    
+
     # Half_Pitch = float(PITCH)/2  # UNUSED
-    Height_Start = Height_Offset - PITCH 
+    Height_Start = Height_Offset - PITCH
     Height_Step = float(PITCH)/float(DIV)
     Deg_Step = 360.0 /float(DIV)
-    
+
     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)
     for j in range(1):  #FIXME - for j in range(1) what?!
-        
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            z = Height_Offset - (Height_Step*i)
             if z > Height_Start:
                 z = Height_Start
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
@@ -1710,24 +1710,24 @@ def Create_Internal_Thread_Start_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DI
             verts.append([x,y,z])
         Height_Offset -= Crest_Height
         Ret_Row += 1
-    
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            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+1):
-            z = Height_Offset - (Height_Step*i) 
+            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:
@@ -1736,12 +1736,12 @@ def Create_Internal_Thread_Start_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DI
             verts.append([x,y,z ])
         Height_Offset -= Root_Height
         Ret_Row += 1
-    
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            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
 
@@ -1751,35 +1751,35 @@ def Create_Internal_Thread_Start_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DI
             verts.append([x,y,z ])
         Height_Offset -= Root_to_Crest_Height
         Ret_Row += 1
-   
+
     return Ret_Row,Height_Offset
 
 
 def Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
-    
-    
+
+
     Ret_Row = 0;
-    
+
     # Half_Pitch = float(PITCH)/2  # UNUSED
     #Height_End = Height_Offset - PITCH - PITCH - PITCH- PITCH - PITCH- PITCH
-    Height_End = Height_Offset - PITCH 
+    Height_End = Height_Offset - PITCH
     #Height_End = -2.1
     Height_Step = float(PITCH)/float(DIV)
     Deg_Step = 360.0 /float(DIV)
-    
+
     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)
-    
+
     Num = 0
-    
+
     for j in range(2):
-        
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            z = Height_Offset - (Height_Step*i)
             if z < Height_End:
                 z = Height_End
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
@@ -1787,25 +1787,25 @@ def Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,
             verts.append([x,y,z])
         Height_Offset -= Crest_Height
         Ret_Row += 1
-    
-    
+
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            z = Height_Offset - (Height_Step*i)
             if z < Height_End:
                 z = Height_End
-            
+
             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+1):
-            z = Height_Offset - (Height_Step*i) 
+            z = Height_Offset - (Height_Step*i)
             if z < Height_End:
                 z = Height_End
-            
+
             x = sin(radians(i*Deg_Step))*INNER_RADIUS
             y = cos(radians(i*Deg_Step))*INNER_RADIUS
             if j == Num:
@@ -1814,17 +1814,17 @@ def Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,
             if j > Num:
                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS)
                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS )
-                
+
             verts.append([x,y,z ])
         Height_Offset -= Root_Height
         Ret_Row += 1
-    
-    
+
+
         for i in range(DIV+1):
-            z = Height_Offset - (Height_Step*i) 
+            z = Height_Offset - (Height_Step*i)
             if z < Height_End:
                 z = Height_End
-            
+
             x = sin(radians(i*Deg_Step))*INNER_RADIUS
             y = cos(radians(i*Deg_Step))*INNER_RADIUS
 
@@ -1834,80 +1834,80 @@ def Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,
             if j > Num:
                 x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS )
                 y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS )
-                
+
             verts.append([x,y,z ])
         Height_Offset -= Root_to_Crest_Height
         Ret_Row += 1
 
-       
+
     return Ret_Row,Height_End  # send back Height End as this is the lowest point
 
 
 def Create_Internal_Thread(INNER_DIA,OUTTER_DIA,PITCH,HEIGHT,CREST_PERCENT,ROOT_PERCENT,INTERNAL = 1):
     verts = []
     faces = []
-    
+
     DIV = 36
-    
+
     INNER_RADIUS = INNER_DIA/2
     OUTTER_RADIUS = OUTTER_DIA/2
-    
+
     # Half_Pitch = float(PITCH)/2  # UNUSED
     Deg_Step = 360.0 /float(DIV)
     Height_Step = float(PITCH)/float(DIV)
-            
-    Num = int(round((HEIGHT- PITCH)/PITCH))  # less one pitch for the start and end that is 1/2 pitch high    
-    
+
+    Num = int(round((HEIGHT- PITCH)/PITCH))  # less one pitch for the start and end that is 1/2 pitch high
+
     # Col = 0  # UNUSED
     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 = 0
     FaceStart = len(verts)
-    
+
     Row_Inc,Height_Offset = Create_Internal_Thread_Start_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset)
     Row += Row_Inc
-    
+
     for j in range(Num):
-        
+
         for i in range(DIV+1):
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
             verts.append([x,y,Height_Offset - (Height_Step*i) ])
         Height_Offset -= Crest_Height
         Row += 1
-    
+
         for i in range(DIV+1):
             x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
             y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
             verts.append([x,y,Height_Offset - (Height_Step*i) ])
         Height_Offset -= Crest_to_Root_Height
         Row += 1
-        
+
         for i in range(DIV+1):
             x = sin(radians(i*Deg_Step))*INNER_RADIUS
             y = cos(radians(i*Deg_Step))*INNER_RADIUS
             verts.append([x,y,Height_Offset - (Height_Step*i) ])
         Height_Offset -= Root_Height
         Row += 1
-    
+
         for i in range(DIV+1):
             x = sin(radians(i*Deg_Step))*INNER_RADIUS
             y = cos(radians(i*Deg_Step))*INNER_RADIUS
             verts.append([x,y,Height_Offset - (Height_Step*i) ])
         Height_Offset -= Root_to_Crest_Height
         Row += 1
-    
+
 
     Row_Inc,Height_Offset = Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset)
     Row += Row_Inc
-    
+
     faces.extend(Build_Face_List_Quads(FaceStart,DIV,Row -1,INTERNAL))
-    
+
     return verts,faces,0 - Height_Offset
 
 
@@ -1920,30 +1920,30 @@ def Nut_Mesh(props, context):
     #sc = context.scene
 
     New_Nut_Height = 5
-    
+
     Face_Start = len(verts)
     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)
     verts.extend(Thread_Verts)
     faces.extend(Copy_Faces(Thread_Faces,Face_Start))
-    
+
     Face_Start = len(verts)
     Head_Verts,Head_Faces,Lock_Nut_Rad = add_Hex_Nut(props.bf_Hex_Nut_Flat_Distance,props.bf_Major_Dia,New_Nut_Height)
     verts.extend((Head_Verts))
     faces.extend(Copy_Faces(Head_Faces,Face_Start))
-    
+
     LowZ = 0 - New_Nut_Height
-    
+
     if props.bf_Nut_Type == 'bf_Nut_Lock':
         Face_Start = len(verts)
-        Nylon_Head_Verts,Nylon_Head_faces,LowZ = add_Nylon_Head(Lock_Nut_Rad,0-New_Nut_Height)    
+        Nylon_Head_Verts,Nylon_Head_faces,LowZ = add_Nylon_Head(Lock_Nut_Rad,0-New_Nut_Height)
         verts.extend((Nylon_Head_Verts))
         faces.extend(Copy_Faces(Nylon_Head_faces,Face_Start))
-    
+
         Face_Start = len(verts)
-        Nylon_Verts,Nylon_faces,Temp_LowZ = add_Nylon_Part(Lock_Nut_Rad,0-New_Nut_Height)    
+        Nylon_Verts,Nylon_faces,Temp_LowZ = add_Nylon_Part(Lock_Nut_Rad,0-New_Nut_Height)
         verts.extend((Nylon_Verts))
         faces.extend(Copy_Faces(Nylon_faces,Face_Start))
-    
+
 
     return Move_Verts_Up_Z(verts,0 - LowZ),faces
 
@@ -1960,7 +1960,7 @@ def Nut_Mesh(props, context):
 
 def Bolt_Mesh(props, context):
 
-    
+
     verts = []
     faces = []
     Bit_Verts = []
@@ -1971,41 +1971,41 @@ def Bolt_Mesh(props, context):
     Head_Height = 0.0
     #sc = context.scene
 
-    ReSized_Allen_Bit_Flat_Distance = props.bf_Allen_Bit_Flat_Distance   # set default  
-   
-    
+    ReSized_Allen_Bit_Flat_Distance = props.bf_Allen_Bit_Flat_Distance   # set default
+
+
     Head_Height = props.bf_Hex_Head_Height # will be changed by the Head Functions
-    
-    
+
+
     if props.bf_Bit_Type == 'bf_Bit_Allen' and props.bf_Head_Type == 'bf_Head_Pan':
         #need to size Allen bit if it is too big.
         if  Allen_Bit_Dia(props.bf_Allen_Bit_Flat_Distance) > Max_Pan_Bit_Dia(props.bf_Pan_Head_Dia):
             ReSized_Allen_Bit_Flat_Distance = Allen_Bit_Dia_To_Flat(Max_Pan_Bit_Dia(props.bf_Pan_Head_Dia)) * 1.05
-            #print ("Resized Allen Bit Flat Distance to ",ReSized_Allen_Bit_Flat_Distance) 
- 
+            #print ("Resized Allen Bit Flat Distance to ",ReSized_Allen_Bit_Flat_Distance)
+
     #bit Mesh
     if props.bf_Bit_Type == 'bf_Bit_Allen':
         Bit_Verts,Bit_Faces,Bit_Dia = Create_Allen_Bit(ReSized_Allen_Bit_Flat_Distance,props.bf_Allen_Bit_Depth)
-    
+
     if props.bf_Bit_Type == 'bf_Bit_Philips':
         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)
-   
-        
+
+
     #Head Mesh
-    
-    if props.bf_Head_Type =='bf_Head_Hex':  
+
+    if props.bf_Head_Type =='bf_Head_Hex':
         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)
 
-    elif props.bf_Head_Type == 'bf_Head_Cap':  
+    elif props.bf_Head_Type == 'bf_Head_Cap':
         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))
 
-    elif props.bf_Head_Type =='bf_Head_Dome':  
+    elif props.bf_Head_Type =='bf_Head_Dome':
         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)
 
-    elif props.bf_Head_Type == 'bf_Head_Pan':  
+    elif props.bf_Head_Type == 'bf_Head_Pan':
         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)
 
-    elif props.bf_Head_Type == 'bf_Head_CounterSink':  
+    elif props.bf_Head_Type == 'bf_Head_CounterSink':
         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))
 #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))
 
@@ -2022,7 +2022,7 @@ def Bolt_Mesh(props, context):
 
     verts.extend(Move_Verts_Up_Z(Thread_Verts,00))
     faces.extend(Copy_Faces(Thread_Faces,Face_Start))
-    
+
     return Move_Verts_Up_Z(verts,Thread_Height),faces
 
 # calculates the matrix for the new object
@@ -2135,27 +2135,27 @@ def Create_New_Mesh(props, context, align_matrix):
     faces = []
     # sMeshName =''  # UNUSED
     sObjName =''
-        
+
     if props.bf_Model_Type == 'bf_Model_Bolt':
         #print('Create Bolt')
         verts, faces = Bolt_Mesh(props, context)
         # sMeshName = 'Bolt'  # UNUSED
         sObjName = 'Bolt'
-    
+
     if props.bf_Model_Type == 'bf_Model_Nut':
         #print('Create Nut')
         verts, faces = Nut_Mesh(props, context)
         # sMeshName = 'Nut'  # UNUSED
         sObjName = 'Nut'
 
-    
+
     verts, faces = RemoveDoubles(verts, faces)
-    
+
     verts = Scale_Mesh_Verts(verts,GLOBAL_SCALE)
-  
+
     obj = create_mesh_object(context, verts, [], faces,sObjName,
             props.edit, align_matrix)
 
     return obj
-    
+