From 24e1555434cc2284f3c908875d04ba78e5959edd Mon Sep 17 00:00:00 2001
From: lijenstina <lijenstina@gmail.com>
Date: Sun, 9 Apr 2017 04:52:03 +0200
Subject: [PATCH] BoltFactory: Cleanup, Remove star imports
Bumped version to 0.3.2
Fix star imports
Replace the star import of the createMesh
with importlib reload in init
Pep8 cleanup
Fix crash with the Cap head type -
props.DIV_COUNT was non existing
---
add_mesh_BoltFactory/Boltfactory.py | 374 ++---
add_mesh_BoltFactory/__init__.py | 18 +-
add_mesh_BoltFactory/createMesh.py | 2124 +++++++++++++--------------
3 files changed, 1258 insertions(+), 1258 deletions(-)
diff --git a/add_mesh_BoltFactory/Boltfactory.py b/add_mesh_BoltFactory/Boltfactory.py
index be0ba617d..89af117cc 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 16dd9a9c1..8c94ec35b 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 58470c016..fcdefdc14 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
-
-
--
GitLab