diff --git a/add_mesh_BoltFactory/Boltfactory.py b/add_mesh_BoltFactory/Boltfactory.py
index be0ba617d916228e96e55cf4685b336a92d54416..89af117cc1cf6120ea3ce8e5d1a85ffd285917b2 100644
--- a/add_mesh_BoltFactory/Boltfactory.py
+++ b/add_mesh_BoltFactory/Boltfactory.py
@@ -18,199 +18,248 @@
import bpy
-import mathutils
-from bpy.props import *
-from add_mesh_BoltFactory.createMesh import *
-
-##------------------------------------------------------------
-# calculates the matrix for the new object
-# depending on user pref
+from mathutils import Matrix
+from bpy.props import (
+ BoolProperty,
+ EnumProperty,
+ FloatProperty,
+ IntProperty,
+ )
+from . import createMesh
+
+
+# ------------------------------------------------------------
+# calculates the matrix for the new object depending on user pref
def align_matrix(context):
- loc = mathutils.Matrix.Translation(context.scene.cursor_location)
+ loc = Matrix.Translation(context.scene.cursor_location)
obj_align = context.user_preferences.edit.object_align
- if (context.space_data.type == 'VIEW_3D'
- and obj_align == 'VIEW'):
+ if (context.space_data.type == 'VIEW_3D' and obj_align == 'VIEW'):
rot = context.space_data.region_3d.view_matrix.to_3x3().inverted().to_4x4()
else:
- rot = mathutils.Matrix()
+ rot = Matrix()
align_matrix = loc * rot
return align_matrix
-
class add_mesh_bolt(bpy.types.Operator):
- """"""
bl_idname = "mesh.bolt_add"
bl_label = "Add Bolt"
bl_options = {'REGISTER', 'UNDO', 'PRESET'}
- bl_description = "adds many types of Bolts"
+ bl_description = "Construct many types of Bolts"
- align_matrix = mathutils.Matrix()
+ align_matrix = Matrix()
MAX_INPUT_NUMBER = 50
- # edit - Whether to add or update.
- edit = BoolProperty(name="",
+ # edit - Whether to add or update
+ edit = BoolProperty(
+ name="",
description="",
default=False,
- options={'HIDDEN'})
-
-
- #Model Types
- Model_Type_List = [('bf_Model_Bolt','BOLT','Bolt Model'),
- ('bf_Model_Nut','NUT','Nut Model')]
- bf_Model_Type = EnumProperty( attr='bf_Model_Type',
+ options={'HIDDEN'}
+ )
+ # Model Types
+ Model_Type_List = [('bf_Model_Bolt', 'BOLT', 'Bolt Model'),
+ ('bf_Model_Nut', 'NUT', 'Nut Model')]
+ bf_Model_Type = EnumProperty(
+ attr='bf_Model_Type',
name='Model',
description='Choose the type off model you would like',
- items = Model_Type_List, default = 'bf_Model_Bolt')
-
- #Head Types
- Model_Type_List = [('bf_Head_Hex','HEX','Hex Head'),
- ('bf_Head_Cap','CAP','Cap Head'),
- ('bf_Head_Dome','DOME','Dome Head'),
- ('bf_Head_Pan','PAN','Pan Head'),
- ('bf_Head_CounterSink','COUNTER SINK','Counter Sink Head')]
- bf_Head_Type = EnumProperty( attr='bf_Head_Type',
+ items=Model_Type_List, default='bf_Model_Bolt'
+ )
+ # Head Types
+ Model_Type_List = [('bf_Head_Hex', 'HEX', 'Hex Head'),
+ ('bf_Head_Cap', 'CAP', 'Cap Head'),
+ ('bf_Head_Dome', 'DOME', 'Dome Head'),
+ ('bf_Head_Pan', 'PAN', 'Pan Head'),
+ ('bf_Head_CounterSink', 'COUNTER SINK', 'Counter Sink Head')]
+ bf_Head_Type = EnumProperty(
+ attr='bf_Head_Type',
name='Head',
description='Choose the type off Head you would like',
- items = Model_Type_List, default = 'bf_Head_Hex')
-
- #Bit Types
- Bit_Type_List = [('bf_Bit_None','NONE','No Bit Type'),
- ('bf_Bit_Allen','ALLEN','Allen Bit Type'),
- ('bf_Bit_Philips','PHILLIPS','Phillips Bit Type')]
- bf_Bit_Type = EnumProperty( attr='bf_Bit_Type',
+ items=Model_Type_List, default='bf_Head_Hex'
+ )
+ # Bit Types
+ Bit_Type_List = [('bf_Bit_None', 'NONE', 'No Bit Type'),
+ ('bf_Bit_Allen', 'ALLEN', 'Allen Bit Type'),
+ ('bf_Bit_Philips', 'PHILLIPS', 'Phillips Bit Type')]
+ bf_Bit_Type = EnumProperty(
+ attr='bf_Bit_Type',
name='Bit Type',
description='Choose the type of bit to you would like',
- items = Bit_Type_List, default = 'bf_Bit_None')
-
- #Nut Types
- Nut_Type_List = [('bf_Nut_Hex','HEX','Hex Nut'),
- ('bf_Nut_Lock','LOCK','Lock Nut')]
- bf_Nut_Type = EnumProperty( attr='bf_Nut_Type',
+ items=Bit_Type_List, default='bf_Bit_None'
+ )
+ # Nut Types
+ Nut_Type_List = [('bf_Nut_Hex', 'HEX', 'Hex Nut'),
+ ('bf_Nut_Lock', 'LOCK', 'Lock Nut')]
+ bf_Nut_Type = EnumProperty(
+ attr='bf_Nut_Type',
name='Nut Type',
description='Choose the type of nut you would like',
- items = Nut_Type_List, default = 'bf_Nut_Hex')
-
- #Shank Types
- bf_Shank_Length = FloatProperty(attr='bf_Shank_Length',
- name='Shank Length', default = 0,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Length of the unthreaded shank')
-
- bf_Shank_Dia = FloatProperty(attr='bf_Shank_Dia',
- name='Shank Dia', default = 3,
- min = 0, soft_min = 0,max = MAX_INPUT_NUMBER,
- description='Diameter of the shank')
-
- bf_Phillips_Bit_Depth = FloatProperty(attr='bf_Phillips_Bit_Depth',
- name='Bit Depth', default = 1.1431535482406616,
- min = 0, soft_min = 0,max = MAX_INPUT_NUMBER,
- description='Depth of the Phillips Bit')
-
- bf_Allen_Bit_Depth = FloatProperty(attr='bf_Allen_Bit_Depth',
- name='Bit Depth', default = 1.5,
- min = 0, soft_min = 0,max = MAX_INPUT_NUMBER,
- description='Depth of the Allen Bit')
-
- bf_Allen_Bit_Flat_Distance = FloatProperty( attr='bf_Allen_Bit_Flat_Distance',
- name='Flat Dist', default = 2.5,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Flat Distance of the Allen Bit')
-
- bf_Hex_Head_Height = FloatProperty( attr='bf_Hex_Head_Height',
- name='Head Height', default = 2,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Height of the Hex Head')
-
- bf_Hex_Head_Flat_Distance = FloatProperty( attr='bf_Hex_Head_Flat_Distance',
- name='Flat Dist', default = 5.5,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Flat Distance of the Hex Head')
-
- bf_CounterSink_Head_Dia = FloatProperty( attr='bf_CounterSink_Head_Dia',
- name='Head Dia', default = 5.5,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Diameter of the Counter Sink Head')
-
- bf_Cap_Head_Height = FloatProperty( attr='bf_Cap_Head_Height',
- name='Head Height', default = 5.5,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Height of the Cap Head')
-
- bf_Cap_Head_Dia = FloatProperty( attr='bf_Cap_Head_Dia',
- name='Head Dia', default = 3,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Diameter of the Cap Head')
-
- bf_Dome_Head_Dia = FloatProperty( attr='bf_Dome_Head_Dia',
- name='Dome Head Dia', default = 5.6,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Length of the unthreaded shank')
-
- bf_Pan_Head_Dia = FloatProperty( attr='bf_Pan_Head_Dia',
- name='Pan Head Dia', default = 5.6,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
+ items=Nut_Type_List, default='bf_Nut_Hex'
+ )
+ # Shank Types
+ bf_Shank_Length = FloatProperty(
+ attr='bf_Shank_Length',
+ name='Shank Length', default=0,
+ min=0, soft_min=0, max=MAX_INPUT_NUMBER,
+ description='Length of the unthreaded shank'
+ )
+ bf_Shank_Dia = FloatProperty(
+ attr='bf_Shank_Dia',
+ name='Shank Dia', default=3,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Diameter of the shank'
+ )
+ bf_Phillips_Bit_Depth = FloatProperty(
+ attr='bf_Phillips_Bit_Depth',
+ name='Bit Depth', default=1.1431535482406616,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Depth of the Phillips Bit'
+ )
+ bf_Allen_Bit_Depth = FloatProperty(
+ attr='bf_Allen_Bit_Depth',
+ name='Bit Depth', default=1.5,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Depth of the Allen Bit'
+ )
+ bf_Allen_Bit_Flat_Distance = FloatProperty(
+ attr='bf_Allen_Bit_Flat_Distance',
+ name='Flat Dist', default=2.5,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Flat Distance of the Allen Bit'
+ )
+ bf_Hex_Head_Height = FloatProperty(
+ attr='bf_Hex_Head_Height',
+ name='Head Height', default=2,
+ min=0, soft_min=0, max=MAX_INPUT_NUMBER,
+ description='Height of the Hex Head'
+ )
+ bf_Hex_Head_Flat_Distance = FloatProperty(
+ attr='bf_Hex_Head_Flat_Distance',
+ name='Flat Dist', default=5.5,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Flat Distance of the Hex Head'
+ )
+ bf_CounterSink_Head_Dia = FloatProperty(
+ attr='bf_CounterSink_Head_Dia',
+ name='Head Dia', default=5.5,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Diameter of the Counter Sink Head'
+ )
+ bf_Cap_Head_Height = FloatProperty(
+ attr='bf_Cap_Head_Height',
+ name='Head Height', default=5.5,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Height of the Cap Head'
+ )
+ bf_Cap_Head_Dia = FloatProperty(
+ attr='bf_Cap_Head_Dia',
+ name='Head Dia', default=3,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Diameter of the Cap Head'
+ )
+ bf_Dome_Head_Dia = FloatProperty(
+ attr='bf_Dome_Head_Dia',
+ name='Dome Head Dia', default=5.6,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Length of the unthreaded shank'
+ )
+ bf_Pan_Head_Dia = FloatProperty(
+ attr='bf_Pan_Head_Dia',
+ name='Pan Head Dia', default=5.6,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
description='Diameter of the Pan Head')
- bf_Philips_Bit_Dia = FloatProperty(attr='bf_Philips_Bit_Dia',
- name='Bit Dia', default = 1.8199999332427979,
- min = 0, soft_min = 0,max = MAX_INPUT_NUMBER,
+ bf_Philips_Bit_Dia = FloatProperty(
+ attr='bf_Philips_Bit_Dia',
+ name='Bit Dia', default=1.8199999332427979,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
description='Diameter of the Philips Bit')
- bf_Thread_Length = FloatProperty( attr='bf_Thread_Length',
- name='Thread Length', default = 6,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
+ bf_Thread_Length = FloatProperty(
+ attr='bf_Thread_Length',
+ name='Thread Length', default=6,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
description='Length of the Thread')
- bf_Major_Dia = FloatProperty( attr='bf_Major_Dia',
- name='Major Dia', default = 3,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
+ bf_Major_Dia = FloatProperty(
+ attr='bf_Major_Dia',
+ name='Major Dia', default=3,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
description='Outside diameter of the Thread')
- bf_Pitch = FloatProperty( attr='bf_Pitch',
- name='Pitch', default = 0.35,
- min = 0.1, soft_min = 0.1, max = 7.0,
- description='Pitch if the thread')
-
- bf_Minor_Dia = FloatProperty( attr='bf_Minor_Dia',
- name='Minor Dia', default = 2.6211137771606445,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Inside diameter of the Thread')
-
- bf_Crest_Percent = IntProperty( attr='bf_Crest_Percent',
- name='Crest Percent', default = 10,
- min = 1, soft_min = 1, max = 90,
- description='Percent of the pitch that makes up the Crest')
-
- bf_Root_Percent = IntProperty( attr='bf_Root_Percent',
- name='Root Percent', default = 10,
- min = 1, soft_min = 1, max = 90,
- description='Percent of the pitch that makes up the Root')
-
- bf_Div_Count = IntProperty( attr='bf_Div_Count',
- name='Div count', default = 36,
- min = 4, soft_min = 4, max = 4096,
- description='Div count determine circle resolution')
-
- bf_Hex_Nut_Height = FloatProperty( attr='bf_Hex_Nut_Height',
- name='Hex Nut Height', default = 2.4,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Height of the Hex Nut')
-
- bf_Hex_Nut_Flat_Distance = FloatProperty( attr='bf_Hex_Nut_Flat_Distance',
- name='Hex Nut Flat Dist', default = 5.5,
- min = 0, soft_min = 0, max = MAX_INPUT_NUMBER,
- description='Flat distance of the Hex Nut')
+ bf_Pitch = FloatProperty(
+ attr='bf_Pitch',
+ name='Pitch', default=0.35,
+ min=0.1, soft_min=0.1,
+ max=7.0,
+ description='Pitch if the thread'
+ )
+ bf_Minor_Dia = FloatProperty(
+ attr='bf_Minor_Dia',
+ name='Minor Dia', default=2.6211137771606445,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Inside diameter of the Thread'
+ )
+ bf_Crest_Percent = IntProperty(
+ attr='bf_Crest_Percent',
+ name='Crest Percent', default=10,
+ min=1, soft_min=1,
+ max=90,
+ description='Percent of the pitch that makes up the Crest'
+ )
+ bf_Root_Percent = IntProperty(
+ attr='bf_Root_Percent',
+ name='Root Percent', default=10,
+ min=1, soft_min=1,
+ max=90,
+ description='Percent of the pitch that makes up the Root'
+ )
+ bf_Div_Count = IntProperty(
+ attr='bf_Div_Count',
+ name='Div count', default=36,
+ min=4, soft_min=4,
+ max=4096,
+ description='Div count determine circle resolution'
+ )
+ bf_Hex_Nut_Height = FloatProperty(
+ attr='bf_Hex_Nut_Height',
+ name='Hex Nut Height', default=2.4,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Height of the Hex Nut'
+ )
+ bf_Hex_Nut_Flat_Distance = FloatProperty(
+ attr='bf_Hex_Nut_Flat_Distance',
+ name='Hex Nut Flat Dist', default=5.5,
+ min=0, soft_min=0,
+ max=MAX_INPUT_NUMBER,
+ description='Flat distance of the Hex Nut'
+ )
def draw(self, context):
layout = self.layout
col = layout.column()
- #ENUMS
+ # ENUMS
col.prop(self, 'bf_Model_Type')
col.separator()
- #Bit
+ # Bit
if self.bf_Model_Type == 'bf_Model_Bolt':
col.prop(self, 'bf_Bit_Type')
if self.bf_Bit_Type == 'bf_Bit_None':
@@ -222,8 +271,7 @@ class add_mesh_bolt(bpy.types.Operator):
col.prop(self, 'bf_Phillips_Bit_Depth')
col.prop(self, 'bf_Philips_Bit_Dia')
col.separator()
-
- #Head
+ # Head
if self.bf_Model_Type == 'bf_Model_Bolt':
col.prop(self, 'bf_Head_Type')
if self.bf_Head_Type == 'bf_Head_Hex':
@@ -239,18 +287,18 @@ class add_mesh_bolt(bpy.types.Operator):
elif self.bf_Head_Type == 'bf_Head_CounterSink':
col.prop(self, 'bf_CounterSink_Head_Dia')
col.separator()
- #Shank
+ # Shank
if self.bf_Model_Type == 'bf_Model_Bolt':
col.label(text='Shank')
col.prop(self, 'bf_Shank_Length')
col.prop(self, 'bf_Shank_Dia')
col.separator()
- #Nut
+ # Nut
if self.bf_Model_Type == 'bf_Model_Nut':
col.prop(self, 'bf_Nut_Type')
col.prop(self, 'bf_Hex_Nut_Height')
col.prop(self, 'bf_Hex_Nut_Flat_Distance')
- #Thread
+ # Thread
col.label(text='Thread')
if self.bf_Model_Type == 'bf_Model_Bolt':
col.prop(self, 'bf_Thread_Length')
@@ -261,23 +309,17 @@ class add_mesh_bolt(bpy.types.Operator):
col.prop(self, 'bf_Root_Percent')
col.prop(self, 'bf_Div_Count')
-
-
- ##### POLL #####
@classmethod
def poll(cls, context):
return context.scene is not None
- ##### EXECUTE #####
def execute(self, context):
-
- #print('EXECUTING...')
- Create_New_Mesh(self, context, self.align_matrix)
+ # print('EXECUTING...')
+ createMesh.Create_New_Mesh(self, context, self.align_matrix)
return {'FINISHED'}
- ##### INVOKE #####
def invoke(self, context, event):
- #print('\n___________START_____________')
+ # print('\n___________START_____________')
# store creation_matrix
self.align_matrix = align_matrix(context)
self.execute(context)
diff --git a/add_mesh_BoltFactory/__init__.py b/add_mesh_BoltFactory/__init__.py
index 16dd9a9c140d203eb4c2f1c4d16797c2ca2595aa..8c94ec35bafbfa9b071eed5493906aeacf9974ad 100644
--- a/add_mesh_BoltFactory/__init__.py
+++ b/add_mesh_BoltFactory/__init__.py
@@ -19,11 +19,11 @@
bl_info = {
"name": "BoltFactory",
"author": "Aaron Keith",
- "version": (0, 3, 1),
+ "version": (0, 3, 2),
"blender": (2, 78, 0),
"location": "View3D > Add > Mesh",
"description": "Add a bolt or nut",
- "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
+ "wiki_url": "https://wiki.blender.org/index.php/Extensions:2.6/Py/"
"Scripts/Add_Mesh/BoltFactory",
"category": "Add Mesh",
}
@@ -32,13 +32,15 @@ bl_info = {
if "bpy" in locals():
import importlib
importlib.reload(Boltfactory)
+ importlib.reload(createMesh)
else:
- from add_mesh_BoltFactory import Boltfactory
+ from . import Boltfactory
+ from . import createMesh
import bpy
-################################################################################
-##### REGISTER #####
+
+# ### REGISTER ###
def add_mesh_bolt_button(self, context):
self.layout.operator(Boltfactory.add_mesh_bolt.bl_idname, text="Bolt", icon="MOD_SCREW")
@@ -48,13 +50,15 @@ def register():
bpy.utils.register_module(__name__)
bpy.types.INFO_MT_mesh_add.append(add_mesh_bolt_button)
- #bpy.types.VIEW3D_PT_tools_objectmode.prepend(add_mesh_bolt_button) #just for testing
+ # bpy.types.VIEW3D_PT_tools_objectmode.prepend(add_mesh_bolt_button) # just for testing
+
def unregister():
bpy.utils.unregister_module(__name__)
bpy.types.INFO_MT_mesh_add.remove(add_mesh_bolt_button)
- #bpy.types.VIEW3D_PT_tools_objectmode.remove(add_mesh_bolt_button) #just for testing
+ # bpy.types.VIEW3D_PT_tools_objectmode.remove(add_mesh_bolt_button) # just for testing
+
if __name__ == "__main__":
register()
diff --git a/add_mesh_BoltFactory/createMesh.py b/add_mesh_BoltFactory/createMesh.py
index 58470c0162b62342d44ac72931f75d799315ec64..fcdefdc147275ef94184240dcdd3c034f6d6e051 100644
--- a/add_mesh_BoltFactory/createMesh.py
+++ b/add_mesh_BoltFactory/createMesh.py
@@ -17,19 +17,23 @@
# ##### END GPL LICENSE BLOCK #####
import bpy
-import mathutils
-
-from math import *
-from itertools import *
+from mathutils import (
+ Matrix,
+ Vector,
+ )
+from math import (
+ sin,
+ cos,
+ tan,
+ radians,
+ )
NARROW_UI = 180
MAX_INPUT_NUMBER = 50
-#Global_Scale = 0.001 #1 blender unit = X mm
-GLOBAL_SCALE = 0.1 #1 blender unit = X mm
-#Global_Scale = 1.0 #1 blender unit = X mm
-
-
+# Global_Scale = 0.001 # 1 blender unit = X mm
+GLOBAL_SCALE = 0.1 # 1 blender unit = X mm
+# Global_Scale = 1.0 # 1 blender unit = X mm
# next two utility functions are stolen from import_obj.py
@@ -40,6 +44,7 @@ def unpack_list(list_of_tuples):
l.extend(t)
return l
+
def unpack_face_list(list_of_tuples):
l = []
for t in list_of_tuples:
@@ -59,6 +64,7 @@ def unpack_face_list(list_of_tuples):
return l
+
"""
Remove Doubles takes a list on Verts and a list of Faces and
removes the doubles, much like Blender does in edit mode.
@@ -70,7 +76,7 @@ disadvantage of not being able to interactively change the properties.
"""
-def RemoveDoubles(verts,faces,Decimal_Places = 4):
+def RemoveDoubles(verts, faces, Decimal_Places=4):
new_verts = []
new_faces = []
@@ -78,7 +84,9 @@ def RemoveDoubles(verts,faces,Decimal_Places = 4):
Rounded_Verts = []
for v in verts:
- Rounded_Verts.append([round(v[0],Decimal_Places),round(v[1],Decimal_Places),round(v[2],Decimal_Places)])
+ Rounded_Verts.append([round(v[0], Decimal_Places),
+ round(v[1], Decimal_Places),
+ round(v[2], Decimal_Places)])
for face in faces:
new_face = []
@@ -94,24 +102,19 @@ def RemoveDoubles(verts,faces,Decimal_Places = 4):
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
-
-def Scale_Mesh_Verts(verts,scale_factor):
+def Scale_Mesh_Verts(verts, scale_factor):
Ret_verts = []
for v in verts:
- Ret_verts.append([v[0]*scale_factor,v[1]*scale_factor,v[2]*scale_factor])
+ Ret_verts.append([v[0] * scale_factor, v[1] * scale_factor, v[2] * scale_factor])
return Ret_verts
-
-
-
-#Create a matrix representing a rotation.
+# Create a matrix representing a rotation.
#
-#Parameters:
+# Parameters:
#
# * angle (float) - The angle of rotation desired.
# * matSize (int) - The size of the rotation matrix to construct. Can be 2d, 3d, or 4d.
@@ -122,49 +125,46 @@ def Scale_Mesh_Verts(verts,scale_factor):
# o "r - arbitrary rotation around vector"
# * axis (Vector object. (optional)) - The arbitrary axis of rotation used with "R"
#
-#Returns: Matrix object.
+# Returns: Matrix object.
# A new rotation matrix.
+
def Simple_RotationMatrix(angle, matSize, axisFlag):
- if matSize != 4 :
- print ("Simple_RotationMatrix can only do 4x4")
+ if matSize != 4:
+ print("Simple_RotationMatrix can only do 4x4")
- q = radians(angle) #make the rotation go clockwise
+ q = radians(angle) # make the rotation go clockwise
if axisFlag == 'x':
- matrix = mathutils.Matrix.Rotation(q, 4, 'X')
- elif axisFlag == 'y':
- matrix = mathutils.Matrix.Rotation(q, 4, 'Y')
+ matrix = Matrix.Rotation(q, 4, 'X')
+ elif axisFlag == 'y':
+ matrix = Matrix.Rotation(q, 4, 'Y')
elif axisFlag == 'z':
- matrix = mathutils.Matrix.Rotation(q, 4, 'Z')
+ matrix = Matrix.Rotation(q, 4, 'Z')
else:
- print ("Simple_RotationMatrix can only do x y z axis")
+ print("Simple_RotationMatrix can only do x y z axis")
return matrix
-##########################################################################################
-##########################################################################################
-## Converter Functions For Bolt Factory
-##########################################################################################
-##########################################################################################
-
+# ####################################################################
+# Converter Functions For Bolt Factory
+# ####################################################################
def Flat_To_Radius(FLAT):
- h = (float(FLAT)/2)/cos(radians(30))
+ h = (float(FLAT) / 2) / cos(radians(30))
return h
+
def Get_Phillips_Bit_Height(Bit_Dia):
- Flat_Width_half = (Bit_Dia*(0.5/1.82))/2.0
+ Flat_Width_half = (Bit_Dia * (0.5 / 1.82)) / 2.0
Bit_Rad = Bit_Dia / 2.0
x = Bit_Rad - Flat_Width_half
- y = tan(radians(60))*x
+ y = tan(radians(60)) * x
return float(y)
-##########################################################################################
-##########################################################################################
-## Miscellaneous Utilities
-##########################################################################################
-##########################################################################################
+# ####################################################################
+# Miscellaneous Utilities
+# ####################################################################
# Returns a list of verts rotated by the given matrix. Used by SpinDup
def Rot_Mesh(verts, matrix):
@@ -173,271 +173,258 @@ def Rot_Mesh(verts, matrix):
# Returns a list of faces that has there index incremented by offset
-def Copy_Faces(faces,offset):
+def Copy_Faces(faces, offset):
return [[(i + offset) for i in f] for f in faces]
-# Much like Blenders built in SpinDup.
-def SpinDup(VERTS,FACES,DEGREE,DIVISIONS,AXIS):
- verts=[]
- faces=[]
+# Much like Blenders built in SpinDup
+def SpinDup(VERTS, FACES, DEGREE, DIVISIONS, AXIS):
+ verts = []
+ faces = []
if DIVISIONS == 0:
DIVISIONS = 1
- step = DEGREE/DIVISIONS # set step so pieces * step = degrees in arc
+ 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)))
+ 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)))
verts.extend(Rot)
- return verts,faces
-
+ 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])
+ 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
-def Mirror_Verts_Faces(VERTS,FACES,AXIS,FLIP_POINT =0):
+def Mirror_Verts_Faces(VERTS, FACES, AXIS, FLIP_POINT=0):
ret_vert = []
ret_face = []
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
+ fsub.append(f[i] + offset)
+ fsub.reverse() # flip the order to make norm point out
ret_face.append(fsub)
- return ret_vert,ret_face
-
+ return ret_vert, ret_face
# 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;
+def Build_Face_List_Quads(OFFSET, COLUM, ROW, FLIP=0):
+ Ret = []
+ RowStart = 0
for j in range(ROW):
for i in range(COLUM):
- Res1 = RowStart + i;
- Res2 = RowStart + i + (COLUM +1)
- Res3 = RowStart + i + (COLUM +1) +1
- Res4 = RowStart+i+1
+ Res1 = RowStart + i
+ Res2 = RowStart + i + (COLUM + 1)
+ Res3 = RowStart + i + (COLUM + 1) + 1
+ Res4 = RowStart + i + 1
if FLIP:
- Ret.append([OFFSET+Res1,OFFSET+Res2,OFFSET+Res3,OFFSET+Res4])
+ Ret.append([OFFSET + Res1, OFFSET + Res2, OFFSET + Res3, OFFSET + Res4])
else:
- Ret.append([OFFSET+Res4,OFFSET+Res3,OFFSET+Res2,OFFSET+Res1])
- RowStart += COLUM+1
+ Ret.append([OFFSET + Res4, OFFSET + Res3, OFFSET + Res2, OFFSET + Res1])
+ RowStart += COLUM + 1
return Ret
# Returns a list of faces that makes up a fill pattern for a
# circle
-def Fill_Ring_Face(OFFSET,NUM,FACE_DOWN = 0):
- Ret =[]
- Face = [1,2,0]
- TempFace = [0,0,0]
+def Fill_Ring_Face(OFFSET, NUM, FACE_DOWN=0):
+ Ret = []
+ Face = [1, 2, 0]
+ TempFace = [0, 0, 0]
# A = 0 # UNUSED
B = 1
C = 2
if NUM < 3:
return None
- for i in range(NUM-2):
- if (i%2):
- TempFace[0] = Face[C];
- TempFace[1] = Face[C] + 1;
- TempFace[2] = Face[B];
+ for i in range(NUM - 2):
+ if (i % 2):
+ TempFace[0] = Face[C]
+ TempFace[1] = Face[C] + 1
+ TempFace[2] = Face[B]
if FACE_DOWN:
- Ret.append([OFFSET+Face[2],OFFSET+Face[1],OFFSET+Face[0]])
+ Ret.append([OFFSET + Face[2], OFFSET + Face[1], OFFSET + Face[0]])
else:
- Ret.append([OFFSET+Face[0],OFFSET+Face[1],OFFSET+Face[2]])
+ Ret.append([OFFSET + Face[0], OFFSET + Face[1], OFFSET + Face[2]])
else:
- TempFace[0] =Face[C];
+ 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];
+ TempFace[1] = Face[C] - 1
+ TempFace[2] = Face[B]
if FACE_DOWN:
- Ret.append([OFFSET+Face[0],OFFSET+Face[1],OFFSET+Face[2]])
+ Ret.append([OFFSET + Face[0], OFFSET + Face[1], OFFSET + Face[2]])
else:
- Ret.append([OFFSET+Face[2],OFFSET+Face[1],OFFSET+Face[0]])
+ 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
-######################################################################################
-##########################################################################################
-##########################################################################################
-## Create Allen Bit
-##########################################################################################
-##########################################################################################
+# ####################################################################
+# Create Allen Bit
+# ####################################################################
-def Allen_Fill(OFFSET,FLIP= 0):
+def Allen_Fill(OFFSET, FLIP=0):
faces = []
- Lookup = [[19,1,0],
- [19,2,1],
- [19,3,2],
- [19,20,3],
- [20,4,3],
- [20,5,4],
- [20,6,5],
- [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],
- [22,18,17]
+ Lookup = [[19, 1, 0],
+ [19, 2, 1],
+ [19, 3, 2],
+ [19, 20, 3],
+ [20, 4, 3],
+ [20, 5, 4],
+ [20, 6, 5],
+ [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],
+ [22, 18, 17]
]
for i in Lookup:
if FLIP:
- faces.append([OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
+ faces.append([OFFSET + i[2], OFFSET + i[1], OFFSET + i[0]])
else:
- faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2]])
+ 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))
+ 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 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):
+def Create_Allen_Bit(FLAT_DISTANCE, HEIGHT):
verts = []
faces = []
DIV_COUNT = 36
- Flat_Radius = (float(FLAT_DISTANCE)/2.0)/cos(radians(30))
+ 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)
+ Outter_Radius_Height = Flat_Radius * (0.1 / 5.77)
FaceStart_Outside = len(verts)
- Deg_Step = 360.0 /float(DIV_COUNT)
+ Deg_Step = 360.0 / float(DIV_COUNT)
- for i in range(int(DIV_COUNT/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])
+ for i in range(int(DIV_COUNT / 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):
- x = sin(radians(i*Deg_Step))* Flat_Radius
- y = cos(radians(i*Deg_Step))* Flat_Radius
- verts.append([x,y,0-Outter_Radius_Height])
-
- faces.extend(Allen_Fill(FaceStart_Outside,0))
+ 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])
+ 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):
- x = sin(radians(i*Deg_Step))* Flat_Radius
- y = cos(radians(i*Deg_Step))* Flat_Radius
- verts.append([x,y,0-HEIGHT])
+ 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])
- faces.extend(Build_Face_List_Quads(FaceStart_Inside,3,1,True))
- faces.extend(Fill_Ring_Face(FaceStart_Bottom,4))
+ 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')
+ 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
-
+ return verts, faces, OUTTER_RADIUS * 2.0
-##########################################################################################
-##########################################################################################
-## Create Phillips Bit
-##########################################################################################
-##########################################################################################
+# ####################################################################
+# Create Phillips Bit
+# ####################################################################
-def Phillips_Fill(OFFSET,FLIP= 0):
+def Phillips_Fill(OFFSET, FLIP=0):
faces = []
- Lookup = [[0,1,10],
- [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]
-
-
+ Lookup = [[0, 1, 10],
+ [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]])
+ faces.append([OFFSET + i[2], OFFSET + i[1], OFFSET + i[0]])
else:
- faces.append([OFFSET+i[3],OFFSET+i[2],OFFSET+i[1],OFFSET+i[0]])
+ faces.append([OFFSET + i[3], OFFSET + i[2], OFFSET + i[1], OFFSET + i[0]])
else:
if len(i) == 3:
- faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2]])
+ faces.append([OFFSET + i[0], OFFSET + i[1], OFFSET + i[2]])
else:
- faces.append([OFFSET+i[0],OFFSET+i[1],OFFSET+i[2],OFFSET+i[3]])
+ faces.append([OFFSET + i[0], OFFSET + i[1], OFFSET + i[2], OFFSET + i[3]])
return faces
-
-def Create_Phillips_Bit(FLAT_DIA,FLAT_WIDTH,HEIGHT):
+def Create_Phillips_Bit(FLAT_DIA, FLAT_WIDTH, HEIGHT):
verts = []
faces = []
@@ -445,50 +432,46 @@ def Create_Phillips_Bit(FLAT_DIA,FLAT_WIDTH,HEIGHT):
FLAT_RADIUS = FLAT_DIA * 0.5
OUTTER_RADIUS = FLAT_RADIUS * 1.05
- Flat_Half = float(FLAT_WIDTH)/2.0
+ Flat_Half = float(FLAT_WIDTH) / 2.0
FaceStart_Outside = len(verts)
- Deg_Step = 360.0 /float(DIV_COUNT)
- for i in range(int(DIV_COUNT/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
- verts.append([Flat_Half,Flat_Half,0]) #12
- verts.append([FLAT_RADIUS,Flat_Half,0]) #13
- verts.append([FLAT_RADIUS,0,0]) #14
+ Deg_Step = 360.0 / float(DIV_COUNT)
+ for i in range(int(DIV_COUNT / 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
+ verts.append([Flat_Half, Flat_Half, 0]) # 12
+ 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, 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
+ verts.append([0, 0, 0 - HEIGHT]) # 18
- faces.extend(Phillips_Fill(FaceStart_Outside,True))
+ faces.extend(Phillips_Fill(FaceStart_Outside, True))
- Spin_Verts,Spin_Face = SpinDup(verts,faces,360,4,'z')
+ Spin_Verts, Spin_Face = SpinDup(verts, faces, 360, 4, 'z')
- return Spin_Verts,Spin_Face,OUTTER_RADIUS * 2
+ return Spin_Verts, Spin_Face, OUTTER_RADIUS * 2
-##########################################################################################
-##########################################################################################
-## Create Head Types
-##########################################################################################
-##########################################################################################
+# ####################################################################
+# Create Head Types
+# ####################################################################
def Max_Pan_Bit_Dia(HEAD_DIA):
HEAD_RADIUS = HEAD_DIA * 0.5
XRad = HEAD_RADIUS * 1.976
- return (sin(radians(10))*XRad) * 2.0
+ return (sin(radians(10)) * XRad) * 2.0
-def Create_Pan_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET,DIV_COUNT):
+def Create_Pan_Head(HOLE_DIA, HEAD_DIA, SHANK_DIA, HEIGHT, RAD1, RAD2, FACE_OFFSET, DIV_COUNT):
HOLE_RADIUS = HOLE_DIA * 0.5
HEAD_RADIUS = HEAD_DIA * 0.5
@@ -504,61 +487,58 @@ def Create_Pan_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET,DIV
EndZOffset = HEAD_RADIUS * 0.432
HEIGHT = HEAD_RADIUS * 0.59
-# Dome_Rad = 5.6
-# RAD_Offset = 4.9
-# OtherRad = 0.8
-# OtherRad_X_Offset = 4.2
-# OtherRad_Z_Offset = 2.52
-# XRad = 9.88
-# ZRad = 8.84
-# EndRad = 1.42
-# EndZOffset = 2.16
-# HEIGHT = 2.95
-
+ """
+ Dome_Rad = 5.6
+ RAD_Offset = 4.9
+ OtherRad = 0.8
+ OtherRad_X_Offset = 4.2
+ OtherRad_Z_Offset = 2.52
+ XRad = 9.88
+ ZRad = 8.84
+ EndRad = 1.42
+ EndZOffset = 2.16
+ HEIGHT = 2.95
+ """
FaceStart = FACE_OFFSET
- z = cos(radians(10))*ZRad
- verts.append([HOLE_RADIUS,0.0,(0.0-ZRad)+z])
- Start_Height = 0 - ((0.0-ZRad)+z)
+ z = cos(radians(10)) * ZRad
+ verts.append([HOLE_RADIUS, 0.0, (0.0 - ZRad) + z])
+ Start_Height = 0 - ((0.0 - ZRad) + z)
Row += 1
- #for i in range(0,30,10): was 0 to 30 more work needed to make this look good.
- for i in range(10,30,10):
- x = sin(radians(i))*XRad
- z = cos(radians(i))*ZRad
- verts.append([x,0.0,(0.0-ZRad)+z])
+ # for i in range(0,30,10): was 0 to 30 more work needed to make this look good.
+ for i in range(10, 30, 10):
+ x = sin(radians(i)) * XRad
+ z = cos(radians(i)) * ZRad
+ verts.append([x, 0.0, (0.0 - ZRad) + z])
Row += 1
- for i in range(20,140,10):
- x = sin(radians(i))*EndRad
- z = cos(radians(i))*EndRad
- if ((0.0 - EndZOffset)+z) < (0.0-HEIGHT):
- verts.append([(HEAD_RADIUS -EndRad)+x,0.0,0.0 - HEIGHT])
+ for i in range(20, 140, 10):
+ x = sin(radians(i)) * EndRad
+ z = cos(radians(i)) * EndRad
+ if ((0.0 - EndZOffset) + z) < (0.0 - HEIGHT):
+ verts.append([(HEAD_RADIUS - EndRad) + x, 0.0, 0.0 - HEIGHT])
else:
- verts.append([(HEAD_RADIUS -EndRad)+x,0.0,(0.0 - EndZOffset)+z])
+ verts.append([(HEAD_RADIUS - EndRad) + x, 0.0, (0.0 - EndZOffset) + z])
Row += 1
-
- verts.append([SHANK_RADIUS,0.0,(0.0-HEIGHT)])
+ verts.append([SHANK_RADIUS, 0.0, (0.0 - HEIGHT)])
Row += 1
- verts.append([SHANK_RADIUS,0.0,(0.0-HEIGHT)-Start_Height])
+ verts.append([SHANK_RADIUS, 0.0, (0.0 - HEIGHT) - Start_Height])
Row += 1
+ sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+ sVerts.extend(verts) # add the start verts to the Spin verts to complete the loop
- sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
- sVerts.extend(verts) #add the start verts to the Spin verts to complete the loop
-
- faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT))
+ faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT))
# Global_Head_Height = HEIGHT # UNUSED
-
- return Move_Verts_Up_Z(sVerts,Start_Height),faces,HEIGHT
-
+ return Move_Verts_Up_Z(sVerts, Start_Height), faces, HEIGHT
-def Create_Dome_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET,DIV_COUNT):
+def Create_Dome_Head(HOLE_DIA, HEAD_DIA, SHANK_DIA, HEIGHT, RAD1, RAD2, FACE_OFFSET, DIV_COUNT):
HOLE_RADIUS = HOLE_DIA * 0.5
HEAD_RADIUS = HEAD_DIA * 0.5
SHANK_RADIUS = SHANK_DIA * 0.5
@@ -567,106 +547,95 @@ def Create_Dome_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,FACE_OFFSET,DI
faces = []
Row = 0
# BEVEL = HEIGHT * 0.01 # UNUSED
- #Dome_Rad = HEAD_RADIUS * (1.0/1.75)
+ # Dome_Rad = HEAD_RADIUS * (1.0/1.75)
- Dome_Rad = HEAD_RADIUS * 1.12
- #Head_Height = HEAD_RADIUS * 0.78
+ Dome_Rad = HEAD_RADIUS * 1.12
+ # Head_Height = HEAD_RADIUS * 0.78
RAD_Offset = HEAD_RADIUS * 0.98
Dome_Height = HEAD_RADIUS * 0.64
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
-#
+ """
+ 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])
+ verts.append([HOLE_RADIUS, 0.0, 0.0])
Row += 1
-
- for i in range(0,60,10):
- x = sin(radians(i))*Dome_Rad
- z = cos(radians(i))*Dome_Rad
- if ((0.0-RAD_Offset)+z) <= 0:
- verts.append([x,0.0,(0.0-RAD_Offset)+z])
+ for i in range(0, 60, 10):
+ x = sin(radians(i)) * Dome_Rad
+ z = cos(radians(i)) * Dome_Rad
+ if ((0.0 - RAD_Offset) + z) <= 0:
+ verts.append([x, 0.0, (0.0 - RAD_Offset) + z])
Row += 1
-
- for i in range(60,160,10):
- x = sin(radians(i))*OtherRad
- z = cos(radians(i))*OtherRad
- z = (0.0-OtherRad_Z_Offset)+z
- if z < (0.0-Dome_Height):
- z = (0.0-Dome_Height)
- verts.append([OtherRad_X_Offset+x,0.0,z])
+ for i in range(60, 160, 10):
+ x = sin(radians(i)) * OtherRad
+ z = cos(radians(i)) * OtherRad
+ z = (0.0 - OtherRad_Z_Offset) + z
+ if z < (0.0 - Dome_Height):
+ 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)])
+ verts.append([SHANK_RADIUS, 0.0, (0.0 - Dome_Height)])
Row += 1
+ sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+ sVerts.extend(verts) # add the start verts to the Spin verts to complete the loop
- sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
- sVerts.extend(verts) #add the start verts to the Spin verts to complete the loop
-
- faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT))
+ faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT))
- return sVerts,faces,Dome_Height
+ return sVerts, faces, Dome_Height
-
-def Create_CounterSink_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,DIV_COUNT):
+def Create_CounterSink_Head(HOLE_DIA, HEAD_DIA, SHANK_DIA, HEIGHT, RAD1, DIV_COUNT):
HOLE_RADIUS = HOLE_DIA * 0.5
HEAD_RADIUS = HEAD_DIA * 0.5
SHANK_RADIUS = SHANK_DIA * 0.5
-
verts = []
faces = []
Row = 0
-# HEAD_RADIUS = (HEIGHT/tan(radians(60))) + SHANK_RADIUS
+ # HEAD_RADIUS = (HEIGHT/tan(radians(60))) + SHANK_RADIUS
HEIGHT = tan(radians(60)) * (HEAD_RADIUS - SHANK_RADIUS)
- #print (RAD1)
+ # print(RAD1)
FaceStart = len(verts)
- verts.append([HOLE_RADIUS,0.0,0.0])
+ 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])
+ # 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])
+ verts.append([SHANK_RADIUS, 0.0, 0.0 - HEIGHT])
Row += 1
+ sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+ sVerts.extend(verts) # add the start verts to the Spin verts to complete the loop
- sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
- sVerts.extend(verts) #add the start verts to the Spin verts to complete the loop
-
-
- faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT,1))
+ faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT, 1))
- return sVerts,faces,HEIGHT
+ return sVerts, faces, HEIGHT
-
-
-def Create_Cap_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,DIV_COUNT):
+def Create_Cap_Head(HOLE_DIA, HEAD_DIA, SHANK_DIA, HEIGHT, RAD1, RAD2, DIV_COUNT):
HOLE_RADIUS = HOLE_DIA * 0.5
HEAD_RADIUS = HEAD_DIA * 0.5
@@ -677,613 +646,580 @@ def Create_Cap_Head(HOLE_DIA,HEAD_DIA,SHANK_DIA,HEIGHT,RAD1,RAD2,DIV_COUNT):
Row = 0
BEVEL = HEIGHT * 0.01
-
FaceStart = len(verts)
- verts.append([HOLE_RADIUS,0.0,0.0])
+ 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])
+ # 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])
+ verts.append([HEAD_RADIUS, 0.0, 0.0 - HEIGHT + BEVEL])
Row += 1
- verts.append([HEAD_RADIUS-BEVEL,0.0,0.0-HEIGHT])
+ verts.append([HEAD_RADIUS - BEVEL, 0.0, 0.0 - HEIGHT])
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])
+ # 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_COUNT, 'z')
+ sVerts.extend(verts) # add the start verts to the Spin verts to complete the loop
- sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
- sVerts.extend(verts) #add the start verts to the Spin verts to complete the loop
-
-
- faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT))
+ faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT))
- return sVerts,faces,HEIGHT+RAD2
+ return sVerts, faces, HEIGHT + RAD2
-def Create_Hex_Head(FLAT,HOLE_DIA,SHANK_DIA,HEIGHT):
+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))
+ Half_Flat = FLAT / 2
+ TopBevelRadius = Half_Flat - (Half_Flat * (0.05 / 8))
+ Undercut_Height = (Half_Flat * (0.05 / 8))
+ Shank_Bevel = (Half_Flat * (0.05 / 8))
Flat_Height = HEIGHT - Undercut_Height - Shank_Bevel
- #Undercut_Height = 5
- SHANK_RADIUS = SHANK_DIA/2
- Row = 0;
-
- verts.append([0.0,0.0,0.0])
+ # 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])
+ # 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/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/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])
+ 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])
+ # bevel
+ x = sin(radians(0)) * TopBevelRadius
+ y = cos(radians(0)) * TopBevelRadius
+ vec1 = Vector([x, y, 0.0])
+ verts.append([x, y, 0.0])
+
+ x = sin(radians(60 / 6)) * TopBevelRadius
+ y = cos(radians(60 / 6)) * TopBevelRadius
+ vec2 = Vector([x, y, 0.0])
+ verts.append([x, y, 0.0])
+
+ x = sin(radians(60 / 3)) * TopBevelRadius
+ y = cos(radians(60 / 3)) * TopBevelRadius
+ vec3 = Vector([x, y, 0.0])
+ verts.append([x, y, 0.0])
+
+ x = sin(radians(60 / 2)) * TopBevelRadius
+ y = cos(radians(60 / 2)) * TopBevelRadius
+ vec4 = Vector([x, y, 0.0])
+ verts.append([x, y, 0.0])
Row += 1
- #Flats
-
- x = tan(radians(0))*Half_Flat
- dvec = vec1 - mathutils.Vector([x,Half_Flat,0.0])
- verts.append([x,Half_Flat,-dvec.length])
+ # Flats
+ x = tan(radians(0)) * Half_Flat
+ dvec = vec1 - Vector([x, Half_Flat, 0.0])
+ verts.append([x, Half_Flat, -dvec.length])
+ x = tan(radians(60 / 6)) * Half_Flat
+ dvec = vec2 - 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])
+ x = tan(radians(60 / 3)) * Half_Flat
+ dvec = vec3 - Vector([x, Half_Flat, 0.0])
Lowest_Point = -dvec.length
- verts.append([x,Half_Flat,-dvec.length])
-
+ verts.append([x, Half_Flat, -dvec.length])
- x = tan(radians(60/2))*Half_Flat
- dvec = vec4 - mathutils.Vector([x,Half_Flat,0.0])
+ x = tan(radians(60 / 2)) * Half_Flat
+ dvec = vec4 - Vector([x, Half_Flat, 0.0])
Lowest_Point = -dvec.length
- verts.append([x,Half_Flat,-dvec.length])
+ 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])
+ # 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 / 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 / 3)) * Half_Flat
+ verts.append([x, Half_Flat, Lowest_Point])
- x = tan(radians(60/2))*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
+ # down Bits
- x = tan(radians(0))*Half_Flat
- verts.append([x,Half_Flat,-Flat_Height])
+ 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 / 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 / 3)) * Half_Flat
+ verts.append([x, Half_Flat, -Flat_Height])
- x = tan(radians(60/2))*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
-
- 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])
+ # Under cut
+ x = sin(radians(0)) * Half_Flat
+ y = cos(radians(0)) * Half_Flat
+ vec1 = 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 = 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 = 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 = 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])
+ # Under cut down bit
+ x = sin(radians(0)) * Half_Flat
+ y = cos(radians(0)) * Half_Flat
+ vec1 = 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 = 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 = 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 = 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])
+ # Under cut to Shank BEVEL
+ x = sin(radians(0)) * (SHANK_RADIUS + Shank_Bevel)
+ y = cos(radians(0)) * (SHANK_RADIUS + Shank_Bevel)
+ vec1 = Vector([x, y, 0.0])
+ verts.append([x, y, -Flat_Height - Undercut_Height])
+
+ x = sin(radians(60 / 6)) * (SHANK_RADIUS + Shank_Bevel)
+ y = cos(radians(60 / 6)) * (SHANK_RADIUS + Shank_Bevel)
+ vec2 = Vector([x, y, 0.0])
+ verts.append([x, y, -Flat_Height - Undercut_Height])
+
+ x = sin(radians(60 / 3)) * (SHANK_RADIUS + Shank_Bevel)
+ y = cos(radians(60 / 3)) * (SHANK_RADIUS + Shank_Bevel)
+ vec3 = Vector([x, y, 0.0])
+ verts.append([x, y, -Flat_Height - Undercut_Height])
+
+ x = sin(radians(60 / 2)) * (SHANK_RADIUS + Shank_Bevel)
+ y = cos(radians(60 / 2)) * (SHANK_RADIUS + Shank_Bevel)
+ vec3 = Vector([x, y, 0.0])
+ verts.append([x, y, -Flat_Height - Undercut_Height])
Row += 1
- #under cut to Shank 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])
+ # Under cut to Shank BEVEL
+ x = sin(radians(0)) * SHANK_RADIUS
+ y = cos(radians(0)) * SHANK_RADIUS
+ vec1 = Vector([x, y, 0.0])
+ verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])
+
+ x = sin(radians(60 / 6)) * SHANK_RADIUS
+ y = cos(radians(60 / 6)) * SHANK_RADIUS
+ vec2 = Vector([x, y, 0.0])
+ verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])
+
+ x = sin(radians(60 / 3)) * SHANK_RADIUS
+ y = cos(radians(60 / 3)) * SHANK_RADIUS
+ vec3 = Vector([x, y, 0.0])
+ verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])
+
+ x = sin(radians(60 / 2)) * SHANK_RADIUS
+ y = cos(radians(60 / 2)) * SHANK_RADIUS
+ vec3 = Vector([x, y, 0.0])
+ verts.append([x, y, -Flat_Height - Undercut_Height - Shank_Bevel])
Row += 1
+ # Global_Head_Height = 0 - (-HEIGHT-0.1)
+ faces.extend(Build_Face_List_Quads(FaceStart, 3, 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')
+ 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')
+ Spin_Verts, Spin_Faces = SpinDup(verts, faces, 360, 6, 'z')
+ return Spin_Verts, Spin_Faces, 0 - (-HEIGHT)
- return Spin_Verts,Spin_Faces,0 - (-HEIGHT)
+# ####################################################################
+# Create External Thread
+# ####################################################################
-##########################################################################################
-##########################################################################################
-## Create External Thread
-##########################################################################################
-##########################################################################################
+def Thread_Start3(verts, INNER_RADIUS, OUTTER_RADIUS, PITCH, DIV_COUNT,
+ CREST_PERCENT, ROOT_PERCENT, Height_Offset):
-
-def Thread_Start3(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV_COUNT,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
-
-
- Ret_Row = 0;
+ Ret_Row = 0
# Half_Pitch = float(PITCH)/2 # UNUSED
Height_Start = Height_Offset - PITCH
- Height_Step = float(PITCH)/float(DIV_COUNT)
- Deg_Step = 360.0 /float(DIV_COUNT)
+ Height_Step = float(PITCH) / float(DIV_COUNT)
+ Deg_Step = 360.0 / float(DIV_COUNT)
- Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
- Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
- Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
+ 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_COUNT)
+ # thread start
+ Rank = float(OUTTER_RADIUS - INNER_RADIUS) / float(DIV_COUNT)
for j in range(4):
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- verts.append([x,y,z])
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ verts.append([x, y, z])
Height_Offset -= Crest_Height
Ret_Row += 1
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- verts.append([x,y,z ])
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ verts.append([x, y, z])
Height_Offset -= Crest_to_Root_Height
Ret_Row += 1
-
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*INNER_RADIUS
- y = cos(radians(i*Deg_Step))*INNER_RADIUS
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
if j == 0:
- x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- verts.append([x,y,z ])
+ x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ verts.append([x, y, z])
Height_Offset -= Root_Height
Ret_Row += 1
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*INNER_RADIUS
- y = cos(radians(i*Deg_Step))*INNER_RADIUS
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
if j == 0:
- x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- verts.append([x,y,z ])
+ x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ verts.append([x, y, z])
Height_Offset -= Root_to_Crest_Height
Ret_Row += 1
- return Ret_Row,Height_Offset
+ return Ret_Row, Height_Offset
-def Create_Shank_Verts(START_DIA,OUTTER_DIA,LENGTH,Z_LOCATION,DIV_COUNT):
+def Create_Shank_Verts(START_DIA, OUTTER_DIA, LENGTH, Z_LOCATION, DIV_COUNT):
verts = []
- START_RADIUS = START_DIA/2
- OUTTER_RADIUS = OUTTER_DIA/2
+ START_RADIUS = START_DIA / 2
+ OUTTER_RADIUS = OUTTER_DIA / 2
Opp = abs(START_RADIUS - OUTTER_RADIUS)
- Taper_Lentgh = Opp/tan(radians(31));
+ Taper_Lentgh = Opp / tan(radians(31))
if Taper_Lentgh > LENGTH:
Taper_Lentgh = 0
Stright_Length = LENGTH - Taper_Lentgh
- Deg_Step = 360.0 /float(DIV_COUNT)
+ Deg_Step = 360.0 / float(DIV_COUNT)
Row = 0
- Lowest_Z_Vert = 0;
+ Lowest_Z_Vert = 0
Height_Offset = Z_LOCATION
-
- #ring
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*START_RADIUS
- y = cos(radians(i*Deg_Step))*START_RADIUS
- z = Height_Offset - 0
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ # Ring
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * START_RADIUS
+ y = cos(radians(i * Deg_Step)) * START_RADIUS
+ z = Height_Offset - 0
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Stright_Length
Row += 1
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*START_RADIUS
- y = cos(radians(i*Deg_Step))*START_RADIUS
- z = Height_Offset - 0
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * START_RADIUS
+ y = cos(radians(i * Deg_Step)) * START_RADIUS
+ z = Height_Offset - 0
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Taper_Lentgh
Row += 1
-
- return verts,Row,Height_Offset
+ return verts, Row, Height_Offset
-def Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION,DIV_COUNT):
+def Create_Thread_Start_Verts(INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
+ ROOT_PERCENT, Z_LOCATION, DIV_COUNT):
verts = []
- INNER_RADIUS = INNER_DIA/2
- OUTTER_RADIUS = OUTTER_DIA/2
+ INNER_RADIUS = INNER_DIA / 2
+ OUTTER_RADIUS = OUTTER_DIA / 2
# Half_Pitch = float(PITCH)/2 # UNUSED
- Deg_Step = 360.0 /float(DIV_COUNT)
- Height_Step = float(PITCH)/float(DIV_COUNT)
+ Deg_Step = 360.0 / float(DIV_COUNT)
+ Height_Step = float(PITCH) / float(DIV_COUNT)
Row = 0
- Lowest_Z_Vert = 0;
+ Lowest_Z_Vert = 0
Height_Offset = Z_LOCATION
Height_Start = Height_Offset
- Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
- Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
- Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
+ Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
+ Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
+ Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height)) / 2.0
- Rank = float(OUTTER_RADIUS - INNER_RADIUS)/float(DIV_COUNT)
+ Rank = float(OUTTER_RADIUS - INNER_RADIUS) / float(DIV_COUNT)
Height_Offset = Z_LOCATION + PITCH
Cut_off = Z_LOCATION
-
for j in range(1):
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- z = Height_Offset - (Height_Step*i)
- if z > Cut_off : z = Cut_off
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ z = Height_Offset - (Height_Step * i)
+ if z > Cut_off:
+ z = Cut_off
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Crest_Height
Row += 1
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- z = Height_Offset - (Height_Step*i)
- if z > Cut_off : z = Cut_off
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ z = Height_Offset - (Height_Step * i)
+ if z > Cut_off:
+ z = Cut_off
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Crest_to_Root_Height
Row += 1
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- z = Height_Offset - (Height_Step*i)
- if z > Cut_off : z = Cut_off
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ z = Height_Offset - (Height_Step * i)
+ if z > Cut_off:
+ z = Cut_off
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Root_Height
Row += 1
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- z = Height_Offset - (Height_Step*i)
- if z > Cut_off : z = Cut_off
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ z = Height_Offset - (Height_Step * i)
+ if z > Cut_off:
+ z = Cut_off
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Root_to_Crest_Height
Row += 1
-
for j in range(2):
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Crest_Height
Row += 1
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- verts.append([x,y,z ])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Crest_to_Root_Height
Row += 1
-
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*INNER_RADIUS
- y = cos(radians(i*Deg_Step))*INNER_RADIUS
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
if j == 0:
- x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- verts.append([x,y,z ])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Root_Height
Row += 1
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*INNER_RADIUS
- y = cos(radians(i*Deg_Step))*INNER_RADIUS
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
if j == 0:
- x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- verts.append([x,y,z ])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Root_to_Crest_Height
Row += 1
-
- return verts,Row,Height_Offset
+ return verts, Row, Height_Offset
+def Create_Thread_Verts(INNER_DIA, OUTTER_DIA, PITCH, HEIGHT,
+ CREST_PERCENT, ROOT_PERCENT, Z_LOCATION, DIV_COUNT):
-def Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,HEIGHT,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION,DIV_COUNT):
verts = []
-
- INNER_RADIUS = INNER_DIA/2
- OUTTER_RADIUS = OUTTER_DIA/2
+ INNER_RADIUS = INNER_DIA / 2
+ OUTTER_RADIUS = OUTTER_DIA / 2
# Half_Pitch = float(PITCH)/2 # UNUSED
- Deg_Step = 360.0 /float(DIV_COUNT)
- Height_Step = float(PITCH)/float(DIV_COUNT)
+ Deg_Step = 360.0 / float(DIV_COUNT)
+ Height_Step = float(PITCH) / float(DIV_COUNT)
NUM_OF_START_THREADS = 4.0
NUM_OF_END_THREADS = 3.0
- Num = int((HEIGHT- ((NUM_OF_START_THREADS*PITCH) + (NUM_OF_END_THREADS*PITCH) ))/PITCH)
+ Num = int((HEIGHT - ((NUM_OF_START_THREADS * PITCH) + (NUM_OF_END_THREADS * PITCH))) / PITCH)
Row = 0
-
- Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
- Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
- Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
-
+ Crest_Height = float(PITCH) * float(CREST_PERCENT) / float(100)
+ Root_Height = float(PITCH) * float(ROOT_PERCENT) / float(100)
+ Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height)) / 2.0
Height_Offset = Z_LOCATION
- Lowest_Z_Vert = 0;
+ Lowest_Z_Vert = 0
for j in range(Num):
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- z = Height_Offset - (Height_Step*i)
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ z = Height_Offset - (Height_Step * i)
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Crest_Height
Row += 1
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- z = Height_Offset - (Height_Step*i)
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ z = Height_Offset - (Height_Step * i)
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Crest_to_Root_Height
Row += 1
-
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*INNER_RADIUS
- y = cos(radians(i*Deg_Step))*INNER_RADIUS
- z = Height_Offset - (Height_Step*i)
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
+ z = Height_Offset - (Height_Step * i)
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Root_Height
Row += 1
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*INNER_RADIUS
- y = cos(radians(i*Deg_Step))*INNER_RADIUS
- z = Height_Offset - (Height_Step*i)
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ for i in range(DIV_COUNT + 1):
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
+ z = Height_Offset - (Height_Step * i)
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Root_to_Crest_Height
Row += 1
- return verts,Row,Height_Offset
-
+ return verts, Row, Height_Offset
-def Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Z_LOCATION,DIV_COUNT):
+def Create_Thread_End_Verts(INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
+ ROOT_PERCENT, Z_LOCATION, DIV_COUNT):
verts = []
-
- INNER_RADIUS = INNER_DIA/2
- OUTTER_RADIUS = OUTTER_DIA/2
+ INNER_RADIUS = INNER_DIA / 2
+ OUTTER_RADIUS = OUTTER_DIA / 2
# Half_Pitch = float(PITCH)/2 # UNUSED
- Deg_Step = 360.0 /float(DIV_COUNT)
- Height_Step = float(PITCH)/float(DIV_COUNT)
+ Deg_Step = 360.0 / float(DIV_COUNT)
+ Height_Step = float(PITCH) / float(DIV_COUNT)
- Crest_Height = float(PITCH) * float(CREST_PERCENT)/float(100)
- Root_Height = float(PITCH) * float(ROOT_PERCENT)/float(100)
- Root_to_Crest_Height = Crest_to_Root_Height = (float(PITCH) - (Crest_Height + Root_Height))/2.0
+ 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
@@ -1294,74 +1230,72 @@ def Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCEN
Max_Height = Tapper_Height_Start - PITCH
- Lowest_Z_Vert = 0;
+ Lowest_Z_Vert = 0
# FaceStart = len(verts) # UNUSED
for j in range(4):
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
- z = max(z,Max_Height)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
+ z = max(z, Max_Height)
Tapper_Radius = OUTTER_RADIUS
if z < Tapper_Height_Start:
Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
- x = sin(radians(i*Deg_Step))*(Tapper_Radius)
- y = cos(radians(i*Deg_Step))*(Tapper_Radius)
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
+ y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Crest_Height
Row += 1
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
- z = max(z,Max_Height)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
+ z = max(z, Max_Height)
Tapper_Radius = OUTTER_RADIUS
if z < Tapper_Height_Start:
Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
- x = sin(radians(i*Deg_Step))*(Tapper_Radius)
- y = cos(radians(i*Deg_Step))*(Tapper_Radius)
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
+ y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Crest_to_Root_Height
Row += 1
-
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
- z = max(z,Max_Height)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
+ z = max(z, Max_Height)
Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
if Tapper_Radius > INNER_RADIUS:
Tapper_Radius = INNER_RADIUS
- x = sin(radians(i*Deg_Step))*(Tapper_Radius)
- y = cos(radians(i*Deg_Step))*(Tapper_Radius)
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ x = sin(radians(i * Deg_Step)) * (Tapper_Radius)
+ y = cos(radians(i * Deg_Step)) * (Tapper_Radius)
+ verts.append([x, y, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Height_Offset -= Root_Height
Row += 1
- for i in range(DIV_COUNT+1):
- z = Height_Offset - (Height_Step*i)
- z = max(z,Max_Height)
+ for i in range(DIV_COUNT + 1):
+ z = Height_Offset - (Height_Step * i)
+ z = max(z, Max_Height)
Tapper_Radius = OUTTER_RADIUS - (Tapper_Height_Start - z)
if Tapper_Radius > INNER_RADIUS:
Tapper_Radius = INNER_RADIUS
- x = sin(radians(i*Deg_Step))*(Tapper_Radius)
- y = cos(radians(i*Deg_Step))*(Tapper_Radius)
- verts.append([x,y,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ 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
-
-
+ return verts, Row, Height_Offset, Lowest_Z_Vert
-def Create_External_Thread(SHANK_DIA,SHANK_LENGTH,INNER_DIA,OUTTER_DIA,PITCH,LENGTH,CREST_PERCENT,ROOT_PERCENT,DIV_COUNT):
+def Create_External_Thread(SHANK_DIA, SHANK_LENGTH, INNER_DIA, OUTTER_DIA,
+ PITCH, LENGTH, CREST_PERCENT, ROOT_PERCENT, DIV_COUNT):
verts = []
faces = []
@@ -1370,202 +1304,193 @@ def Create_External_Thread(SHANK_DIA,SHANK_LENGTH,INNER_DIA,OUTTER_DIA,PITCH,LEN
# Thread_Len = 0 # UNUSED
Face_Start = len(verts)
- Offset = 0.0;
+ Offset = 0.0
-
- Shank_Verts,Shank_Row,Offset = Create_Shank_Verts(SHANK_DIA,OUTTER_DIA,SHANK_LENGTH,Offset,DIV_COUNT)
+ Shank_Verts, Shank_Row, Offset = Create_Shank_Verts(
+ SHANK_DIA, OUTTER_DIA, SHANK_LENGTH,
+ Offset, DIV_COUNT
+ )
Total_Row += Shank_Row
- Thread_Start_Verts,Thread_Start_Row,Offset = Create_Thread_Start_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Offset,DIV_COUNT)
+ Thread_Start_Verts, Thread_Start_Row, Offset = Create_Thread_Start_Verts(
+ INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
+ ROOT_PERCENT, Offset, DIV_COUNT
+ )
Total_Row += Thread_Start_Row
-
- Thread_Verts,Thread_Row,Offset = Create_Thread_Verts(INNER_DIA,OUTTER_DIA,PITCH,LENGTH,CREST_PERCENT,ROOT_PERCENT,Offset,DIV_COUNT)
+ Thread_Verts, Thread_Row, Offset = Create_Thread_Verts(
+ INNER_DIA, OUTTER_DIA, PITCH, LENGTH,
+ CREST_PERCENT, ROOT_PERCENT, Offset, DIV_COUNT
+ )
Total_Row += Thread_Row
-
- Thread_End_Verts,Thread_End_Row,Offset,Lowest_Z_Vert = Create_Thread_End_Verts(INNER_DIA,OUTTER_DIA,PITCH,CREST_PERCENT,ROOT_PERCENT,Offset,DIV_COUNT )
+ Thread_End_Verts, Thread_End_Row, Offset, Lowest_Z_Vert = Create_Thread_End_Verts(
+ INNER_DIA, OUTTER_DIA, PITCH, CREST_PERCENT,
+ ROOT_PERCENT, Offset, DIV_COUNT
+ )
Total_Row += Thread_End_Row
-
verts.extend(Shank_Verts)
verts.extend(Thread_Start_Verts)
verts.extend(Thread_Verts)
verts.extend(Thread_End_Verts)
- faces.extend(Build_Face_List_Quads(Face_Start,DIV_COUNT,Total_Row -1,0))
- faces.extend(Fill_Ring_Face(len(verts)-DIV_COUNT,DIV_COUNT,1))
+ faces.extend(Build_Face_List_Quads(Face_Start, DIV_COUNT, Total_Row - 1, 0))
+ faces.extend(Fill_Ring_Face(len(verts) - DIV_COUNT, DIV_COUNT, 1))
- return verts,faces,0.0 - Lowest_Z_Vert
+ return verts, faces, 0.0 - Lowest_Z_Vert
-##########################################################################################
-##########################################################################################
-## Create Nut
-##########################################################################################
-##########################################################################################
+# ####################################################################
+# Create Nut
+# ####################################################################
-def add_Hex_Nut(FLAT,HOLE_DIA,HEIGHT):
+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
+ Half_Flat = FLAT / 2
+ Half_Height = HEIGHT / 2
TopBevelRadius = Half_Flat - 0.05
- Global_NutRad = TopBevelRadius
-
- Row = 0;
- Lowest_Z_Vert = 0.0;
+ Global_NutRad = TopBevelRadius
- verts.append([0.0,0.0,0.0])
+ 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])
+ # 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
- #bevel
+ x = sin(radians(0)) * TopBevelRadius
+ y = cos(radians(0)) * TopBevelRadius
+ vec1 = Vector([x, y, 0.0])
+ verts.append([x, y, 0.0])
- x = sin(radians(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 = Vector([x, y, 0.0])
+ verts.append([x, y, 0.0])
+ x = sin(radians(60 / 3)) * TopBevelRadius
+ y = cos(radians(60 / 3)) * TopBevelRadius
+ vec3 = Vector([x, y, 0.0])
+ verts.append([x, y, 0.0])
- x = sin(radians(60/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])
+ x = sin(radians(60 / 2)) * TopBevelRadius
+ y = cos(radians(60 / 2)) * TopBevelRadius
+ vec4 = Vector([x, y, 0.0])
+ verts.append([x, y, 0.0])
Row += 1
- #Flats
-
- x = tan(radians(0))*Half_Flat
- dvec = vec1 - mathutils.Vector([x,Half_Flat,0.0])
- verts.append([x,Half_Flat,-dvec.length])
- Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
+ # Flats
+ x = tan(radians(0)) * Half_Flat
+ dvec = vec1 - Vector([x, Half_Flat, 0.0])
+ verts.append([x, Half_Flat, -dvec.length])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)
+ x = tan(radians(60 / 6)) * Half_Flat
+ dvec = vec2 - Vector([x, Half_Flat, 0.0])
+ verts.append([x, Half_Flat, -dvec.length])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)
- x = tan(radians(60/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])
+ x = tan(radians(60 / 3)) * Half_Flat
+ dvec = vec3 - Vector([x, Half_Flat, 0.0])
Lowest_Point = -dvec.length
- verts.append([x,Half_Flat,-dvec.length])
- Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
+ verts.append([x, Half_Flat, -dvec.length])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, -dvec.length)
- x = tan(radians(60/2))*Half_Flat
- dvec = vec4 - mathutils.Vector([x,Half_Flat,0.0])
+ x = tan(radians(60 / 2)) * Half_Flat
+ dvec = vec4 - Vector([x, Half_Flat, 0.0])
Lowest_Point = -dvec.length
- verts.append([x,Half_Flat,-dvec.length])
- Lowest_Z_Vert = min(Lowest_Z_Vert,-dvec.length)
+ 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])
-
+ # 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 / 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)
+ 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
+ # down Bits
- x = tan(radians(0))*Half_Flat
- verts.append([x,Half_Flat,-Half_Height])
+ 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 / 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 / 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)
+ 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))
+ 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)
+ 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')
+ 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
+ S_verts, S_faces = SpinDup(verts, faces, 360, 6, 'z')
+ # return verts, faces, TopBevelRadius
+ return S_verts, S_faces, TopBevelRadius
-def add_Nylon_Head(OUTSIDE_RADIUS,Z_LOCATION,DIV_COUNT):
+def add_Nylon_Head(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
verts = []
faces = []
Row = 0
- INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.25/4.75))
- EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4/4.75))
- RAD1 = (OUTSIDE_RADIUS * (0.5/4.75))
- OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0/4.75))
-
+ INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.25 / 4.75))
+ EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4 / 4.75))
+ RAD1 = (OUTSIDE_RADIUS * (0.5 / 4.75))
+ OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0 / 4.75))
FaceStart = len(verts)
@@ -1575,51 +1500,48 @@ def add_Nylon_Head(OUTSIDE_RADIUS,Z_LOCATION,DIV_COUNT):
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)
+ 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)
+ 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)
+ 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
- verts.append([x,0.0,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ verts.append([x, 0.0, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Row += 1
- sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
- sVerts.extend(verts) #add the start verts to the Spin verts to complete the loop
+ sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+ sVerts.extend(verts) # add the start verts to the Spin verts to complete the loop
- faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT))
+ faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT))
- return Move_Verts_Up_Z(sVerts,0),faces,Lowest_Z_Vert
+ return Move_Verts_Up_Z(sVerts, 0), faces, Lowest_Z_Vert
-
-def add_Nylon_Part(OUTSIDE_RADIUS,Z_LOCATION,DIV_COUNT):
+def add_Nylon_Part(OUTSIDE_RADIUS, Z_LOCATION, DIV_COUNT):
verts = []
faces = []
Row = 0
- INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.5/4.75))
- EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4/4.75))
+ INNER_HOLE = OUTSIDE_RADIUS - (OUTSIDE_RADIUS * (1.5 / 4.75))
+ EDGE_THICKNESS = (OUTSIDE_RADIUS * (0.4 / 4.75))
# RAD1 = (OUTSIDE_RADIUS * (0.5/4.75)) # UNUSED
- OVER_ALL_HEIGTH = (OUTSIDE_RADIUS * (2.0/4.75))
+ 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))
+ PART_INNER_HOLE = (OUTSIDE_RADIUS * (2.5 / 4.75))
FaceStart = len(verts)
@@ -1627,275 +1549,269 @@ def add_Nylon_Part(OUTSIDE_RADIUS,Z_LOCATION,DIV_COUNT):
Height_Offset = Z_LOCATION
Lowest_Z_Vert = 0
-
x = INNER_HOLE + EDGE_THICKNESS
z = Height_Offset
- verts.append([x,0.0,z])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ 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)
+ 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)
+ 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])
- Lowest_Z_Vert = min(Lowest_Z_Vert,z)
+ verts.append([x, 0.0, z])
+ Lowest_Z_Vert = min(Lowest_Z_Vert, z)
Row += 1
+ sVerts, sFaces = SpinDup(verts, faces, 360, DIV_COUNT, 'z')
+ sVerts.extend(verts) # add the start verts to the Spin verts to complete the loop
- sVerts,sFaces = SpinDup(verts,faces,360,DIV_COUNT,'z')
- sVerts.extend(verts) #add the start verts to the Spin verts to complete the loop
-
- faces.extend(Build_Face_List_Quads(FaceStart,Row-1,DIV_COUNT,1))
+ faces.extend(Build_Face_List_Quads(FaceStart, Row - 1, DIV_COUNT, 1))
- return sVerts,faces,0 - Lowest_Z_Vert
+ return sVerts, faces, 0 - Lowest_Z_Vert
-##########################################################################################
-##########################################################################################
-## Create Internal Thread
-##########################################################################################
-##########################################################################################
+# ####################################################################
+# Create Internal Thread
+# ####################################################################
+def Create_Internal_Thread_Start_Verts(verts, INNER_RADIUS, OUTTER_RADIUS, PITCH, DIV,
+ CREST_PERCENT, ROOT_PERCENT, Height_Offset):
-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
- #at the correct place (Height_Start)
+ Ret_Row = 0
+ # Move the offset up so that the verts start at
+ # at the correct place (Height_Start)
+ Height_Offset = Height_Offset + PITCH
# Half_Pitch = float(PITCH)/2 # UNUSED
Height_Start = Height_Offset - PITCH
- Height_Step = float(PITCH)/float(DIV)
- Deg_Step = 360.0 /float(DIV)
+ 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
+ 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?!
- 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)
+ for i in range(DIV + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- verts.append([x,y,z])
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ verts.append([x, y, z])
Height_Offset -= Crest_Height
Ret_Row += 1
- for i in range(DIV+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- verts.append([x,y,z ])
+ 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)
+ for i in range(DIV + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*INNER_RADIUS
- y = cos(radians(i*Deg_Step))*INNER_RADIUS
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
if j == 0:
- x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- verts.append([x,y,z ])
+ x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ verts.append([x, y, z])
Height_Offset -= Root_Height
Ret_Row += 1
- for i in range(DIV+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV + 1):
+ z = Height_Offset - (Height_Step * i)
if z > Height_Start:
z = Height_Start
- x = sin(radians(i*Deg_Step))*INNER_RADIUS
- y = cos(radians(i*Deg_Step))*INNER_RADIUS
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
if j == 0:
- x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS - (i*Rank))
- verts.append([x,y,z ])
+ x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS - (i * Rank))
+ verts.append([x, y, z])
Height_Offset -= Root_to_Crest_Height
Ret_Row += 1
- return Ret_Row,Height_Offset
+ return Ret_Row, Height_Offset
-def Create_Internal_Thread_End_Verts(verts,INNER_RADIUS,OUTTER_RADIUS,PITCH,DIV,CREST_PERCENT,ROOT_PERCENT,Height_Offset):
+def Create_Internal_Thread_End_Verts(verts, INNER_RADIUS, OUTTER_RADIUS, PITCH,
+ DIV, CREST_PERCENT, ROOT_PERCENT, Height_Offset):
-
- Ret_Row = 0;
+ Ret_Row = 0
# Half_Pitch = float(PITCH)/2 # UNUSED
- #Height_End = Height_Offset - PITCH - PITCH - PITCH- PITCH - PITCH- PITCH
+ # Height_End = Height_Offset - PITCH - PITCH - PITCH- PITCH - PITCH- 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
+ # 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)
+ 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)
+ for i in range(DIV + 1):
+ 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])
+ x = sin(radians(i * Deg_Step)) * OUTTER_RADIUS
+ y = cos(radians(i * Deg_Step)) * OUTTER_RADIUS
+ verts.append([x, y, z])
Height_Offset -= Crest_Height
Ret_Row += 1
-
- for i in range(DIV+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV + 1):
+ 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 ])
+ 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)
+ for i in range(DIV + 1):
+ 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
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
if j == Num:
- x = sin(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
- y = cos(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
+ x = sin(radians(i * Deg_Step)) * (INNER_RADIUS + (i * Rank))
+ y = cos(radians(i * Deg_Step)) * (INNER_RADIUS + (i * Rank))
if j > Num:
- x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS)
- y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS )
+ x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS)
+ y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS)
- verts.append([x,y,z ])
+ verts.append([x, y, z])
Height_Offset -= Root_Height
Ret_Row += 1
-
- for i in range(DIV+1):
- z = Height_Offset - (Height_Step*i)
+ for i in range(DIV + 1):
+ 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
+ x = sin(radians(i * Deg_Step)) * INNER_RADIUS
+ y = cos(radians(i * Deg_Step)) * INNER_RADIUS
if j == Num:
- x = sin(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
- y = cos(radians(i*Deg_Step))*(INNER_RADIUS + (i*Rank))
+ x = sin(radians(i * Deg_Step)) * (INNER_RADIUS + (i * Rank))
+ y = cos(radians(i * Deg_Step)) * (INNER_RADIUS + (i * Rank))
if j > Num:
- x = sin(radians(i*Deg_Step))*(OUTTER_RADIUS )
- y = cos(radians(i*Deg_Step))*(OUTTER_RADIUS )
+ x = sin(radians(i * Deg_Step)) * (OUTTER_RADIUS)
+ y = cos(radians(i * Deg_Step)) * (OUTTER_RADIUS)
- verts.append([x,y,z ])
+ 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
- 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,DIV_COUNT):
+def Create_Internal_Thread(INNER_DIA, OUTTER_DIA, PITCH, HEIGHT,
+ CREST_PERCENT, ROOT_PERCENT, INTERNAL, DIV_COUNT):
verts = []
faces = []
+ INNER_RADIUS = INNER_DIA / 2
+ OUTTER_RADIUS = OUTTER_DIA / 2
- INNER_RADIUS = INNER_DIA/2
- OUTTER_RADIUS = OUTTER_DIA/2
-
- # Half_Pitch = float(PITCH)/2 # UNUSED
- Deg_Step = 360.0 /float(DIV_COUNT)
- Height_Step = float(PITCH)/float(DIV_COUNT)
+ # Half_Pitch = float(PITCH) / 2 # UNUSED
+ Deg_Step = 360.0 / float(DIV_COUNT)
+ Height_Step = float(PITCH) / float(DIV_COUNT)
- 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
+ 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_COUNT,CREST_PERCENT,ROOT_PERCENT,Height_Offset)
+ Row_Inc, Height_Offset = Create_Internal_Thread_Start_Verts(
+ verts, INNER_RADIUS, OUTTER_RADIUS, PITCH,
+ DIV_COUNT, CREST_PERCENT, ROOT_PERCENT,
+ Height_Offset
+ )
Row += Row_Inc
for j in range(Num):
- for i in range(DIV_COUNT+1):
- x = sin(radians(i*Deg_Step))*OUTTER_RADIUS
- y = cos(radians(i*Deg_Step))*OUTTER_RADIUS
- verts.append([x,y,Height_Offset - (Height_Step*i) ])
+ for i in range(DIV_COUNT + 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_COUNT+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) ])
+ for i in range(DIV_COUNT + 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_COUNT+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) ])
+ for i in range(DIV_COUNT + 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_COUNT+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) ])
+ for i in range(DIV_COUNT + 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_COUNT,CREST_PERCENT,ROOT_PERCENT,Height_Offset)
+ Row_Inc, Height_Offset = Create_Internal_Thread_End_Verts(
+ verts, INNER_RADIUS, OUTTER_RADIUS,
+ PITCH, DIV_COUNT, CREST_PERCENT,
+ ROOT_PERCENT, Height_Offset
+ )
Row += Row_Inc
- faces.extend(Build_Face_List_Quads(FaceStart,DIV_COUNT,Row -1,INTERNAL))
+ faces.extend(Build_Face_List_Quads(FaceStart, DIV_COUNT, Row - 1, INTERNAL))
- return verts,faces,0 - Height_Offset
+ return verts, faces, 0 - Height_Offset
def Nut_Mesh(props, context):
@@ -1903,122 +1819,164 @@ def Nut_Mesh(props, context):
verts = []
faces = []
Head_Verts = []
- Head_Faces= []
- #sc = context.scene
+ Head_Faces = []
+ # 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,props.bf_Div_Count)
+ 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, props.bf_Div_Count
+ )
verts.extend(Thread_Verts)
- faces.extend(Copy_Faces(Thread_Faces,Face_Start))
+ 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)
+ 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))
+ 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,props.bf_Div_Count)
+ Nylon_Head_Verts, Nylon_Head_faces, LowZ = add_Nylon_Head(
+ Lock_Nut_Rad, 0 - New_Nut_Height,
+ props.bf_Div_Count
+ )
verts.extend((Nylon_Head_Verts))
- faces.extend(Copy_Faces(Nylon_Head_faces,Face_Start))
+ 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,props.bf_Div_Count)
+ Nylon_Verts, Nylon_faces, Temp_LowZ = add_Nylon_Part(
+ Lock_Nut_Rad, 0 - New_Nut_Height,
+ props.bf_Div_Count
+ )
verts.extend((Nylon_Verts))
- faces.extend(Copy_Faces(Nylon_faces,Face_Start))
+ faces.extend(Copy_Faces(Nylon_faces, Face_Start))
-
- return Move_Verts_Up_Z(verts,0 - LowZ),faces
-
-
-
-##########################################################################################
-##########################################################################################
-##########################################################################################
-## Create Bolt
-##########################################################################################
-##########################################################################################
+ return Move_Verts_Up_Z(verts, 0 - LowZ), faces
+# ####################################################################
+# Create Bolt
+# ####################################################################
def Bolt_Mesh(props, context):
-
verts = []
faces = []
Bit_Verts = []
Bit_Faces = []
Bit_Dia = 0.001
Head_Verts = []
- Head_Faces= []
+ Head_Faces = []
Head_Height = 0.0
- #sc = context.scene
+ # sc = context.scene
- 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
+ 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)
-
- #bit Mesh
+ # 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)
+
+ # 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)
+ 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':
- 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)
-
+ 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':
+ 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':
- 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),props.DIV_COUNT)
-
- 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,props.bf_Div_Count)
+ 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),
+ props.bf_Div_Count
+ )
+ 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, props.bf_Div_Count
+ )
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,props.bf_Div_Count)
-
+ 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,
+ props.bf_Div_Count
+ )
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),props.bf_Div_Count)
-#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))
-
+ 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),
+ props.bf_Div_Count
+ )
+ """
+ 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)
+ )
+ """
Face_Start = len(verts)
- verts.extend(Move_Verts_Up_Z(Bit_Verts,Head_Height))
- faces.extend(Copy_Faces(Bit_Faces,Face_Start))
+ verts.extend(Move_Verts_Up_Z(Bit_Verts, Head_Height))
+ faces.extend(Copy_Faces(Bit_Faces, Face_Start))
Face_Start = len(verts)
- verts.extend(Move_Verts_Up_Z(Head_Verts,Head_Height))
- faces.extend(Copy_Faces(Head_Faces,Face_Start))
+ verts.extend(Move_Verts_Up_Z(Head_Verts, Head_Height))
+ faces.extend(Copy_Faces(Head_Faces, Face_Start))
Face_Start = len(verts)
- 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,props.bf_Div_Count)
+ 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, props.bf_Div_Count
+ )
- verts.extend(Move_Verts_Up_Z(Thread_Verts,00))
- faces.extend(Copy_Faces(Thread_Faces,Face_Start))
+ 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
- return Move_Verts_Up_Z(verts,Thread_Height),faces
# calculates the matrix for the new object
# depending on user pref
def align_matrix(context):
loc = Matrix.Translation(context.scene.cursor_location)
obj_align = context.user_preferences.edit.object_align
- if (context.space_data.type == 'VIEW_3D'
- and obj_align == 'VIEW'):
+ if (context.space_data.type == 'VIEW_3D' and obj_align == 'VIEW'):
rot = context.space_data.region_3d.view_matrix.to_3x3().inverted().to_4x4()
else:
rot = Matrix()
@@ -2076,7 +2034,6 @@ def create_mesh_object(context, verts, edges, faces, name, edit, align_matrix):
# Assign new mesh datablock.
ob_new.data = mesh
-
else:
# Create new object
ob_new = bpy.data.objects.new(name, mesh)
@@ -2121,28 +2078,25 @@ def Create_New_Mesh(props, context, align_matrix):
verts = []
faces = []
# sMeshName ='' # UNUSED
- sObjName =''
+ sObjName = ''
if props.bf_Model_Type == 'bf_Model_Bolt':
- #print('Create 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')
+ # 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)
+ verts = Scale_Mesh_Verts(verts, GLOBAL_SCALE)
- obj = create_mesh_object(context, verts, [], faces,sObjName,
- props.edit, align_matrix)
+ obj = create_mesh_object(context, verts, [], faces, sObjName,
+ props.edit, align_matrix)
return obj
-
-