From f1cc87aae6ff01154b63bbecf6cea18930a8157f Mon Sep 17 00:00:00 2001 From: Brendon Murphy Date: Sun, 23 May 2010 04:22:09 +0000 Subject: addons/add_curve_torus_knots.py script introduced to trunk. the script makes use of mfoxdoggs revision 28923. the script shows up in the add/curve menu. --- add_curve_torus_knots.py | 487 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 487 insertions(+) create mode 100644 add_curve_torus_knots.py diff --git a/add_curve_torus_knots.py b/add_curve_torus_knots.py new file mode 100644 index 00000000..bf1516a4 --- /dev/null +++ b/add_curve_torus_knots.py @@ -0,0 +1,487 @@ +# ##### BEGIN GPL LICENSE BLOCK ##### +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +# +# ##### END GPL LICENSE BLOCK ##### +bl_addon_info = { + 'name': 'Add Curve: Torus Knots', + 'author': 'testscreenings', + 'version': '0.1', + 'blender': (2, 5, 2), + 'location': 'Add Curve Menu', + 'url': '', + 'description': 'adds many types of knots', + 'url': 'http://wiki.blender.org/index.php/Extensions:2.5/Py/' \ + 'Scripts/Curve/Torus_Knot', + 'category': 'Add Curve'} +##------------------------------------------------------------ +#### import modules +import bpy +from bpy.props import * +from mathutils import * +from math import * + +##------------------------------------------------------------ +# calculates the matrix for the new object +# depending on user pref +def align_matrix(context): + loc = TranslationMatrix(context.scene.cursor_location) + obj_align = context.user_preferences.edit.object_align + if (context.space_data.type == 'VIEW_3D' + and obj_align == 'VIEW'): + rot = context.space_data.region_3d.view_matrix.rotation_part().invert().resize4x4() + else: + rot = Matrix() + align_matrix = loc * rot + return align_matrix + +##------------------------------------------------------------ +#### Curve creation functions +# sets bezierhandles to auto +def setBezierHandles(obj, mode = 'AUTOMATIC'): + scene = bpy.context.scene + if obj.type != 'CURVE': + return + scene.objects.active = obj + bpy.ops.object.mode_set(mode='EDIT', toggle=True) + bpy.ops.curve.select_all(action='SELECT') + bpy.ops.curve.handle_type_set(type=mode) + bpy.ops.object.mode_set(mode='OBJECT', toggle=True) + +# get array of vertcoordinates acording to splinetype +def vertsToPoints(Verts, splineType): + # main vars + vertArray = [] + + # array for BEZIER spline output (V3) + if splineType == 'BEZIER': + for v in Verts: + vertArray += v + + # array for nonBEZIER output (V4) + else: + for v in Verts: + vertArray += v + if splineType == 'NURBS': + vertArray.append(1) #for nurbs w=1 + else: #for poly w=0 + vertArray.append(0) + return vertArray + +# create new CurveObject from vertarray and splineType +def createCurve(vertArray, GEO, options, curveOptions, align_matrix): + # options to vars + splineType = options[0] # output splineType 'POLY' 'NURBS' 'BEZIER' + name = options[1] # KnotType as name + + # create curve + scene = bpy.context.scene + newCurve = bpy.data.curves.new(name, type = 'CURVE') # curvedatablock + newSpline = newCurve.splines.new(type = splineType) # spline + + # create spline from vertarray + if splineType == 'BEZIER': + newSpline.bezier_points.add(int(len(vertArray)*0.33)) + newSpline.bezier_points.foreach_set('co', vertArray) + else: + newSpline.points.add(int(len(vertArray)*0.25 - 1)) + newSpline.points.foreach_set('co', vertArray) + newSpline.endpoint_u = True + + # set curveOptions + shape = curveOptions[0] + cyclic_u = curveOptions[1] + endp_u = curveOptions[2] + order_u = curveOptions[3] + handleType = curveOptions[4] + + newCurve.dimensions = shape + newSpline.cyclic_u = cyclic_u + newSpline.endpoint_u = endp_u + newSpline.order_u = order_u + + # GEO Options + surf = GEO[0] + bDepth = GEO[1] + bRes = GEO[2] + extrude = GEO[3] + width = GEO[4] + res = GEO[5] + + if surf: + newCurve.bevel_depth = bDepth + newCurve.bevel_resolution = bRes + newCurve.front = False + newCurve.back = False + newCurve.extrude = extrude + newCurve.width = width + newCurve.resolution_u = res + + # create object with newCurve + new_obj = bpy.data.objects.new(name, newCurve) # object + scene.objects.link(new_obj) # place in active scene + new_obj.selected = True # set as selected + scene.objects.active = new_obj # set as active + new_obj.matrix = align_matrix # apply matrix + + # set bezierhandles + if splineType == 'BEZIER': + setBezierHandles(new_obj, handleType) + + return + +######################################################################## +####################### Knot Definitions ############################### +######################################################################## + +#### TORUS KNOT +def Torus_Knot_Curve(p=2, q=3, w=1, res=24, formula=0, h=1, u=1 ,v=1, rounds=2): + newPoints = [] + angle = (2.0/360.0)*360*rounds + #angle = 360/pi + step = angle/(res-1) + scale = h + height = w + + if formula == 0: + for i in range(res-1): + t = ( i*step*pi) + + x = (2 * scale + cos((q*t)/p*v)) * cos(t * u) + y = (2 * scale + cos((q*t)/p*v)) * sin(t * u) + z = sin(q*t/p) * height + + newPoints.append([x,y,z]) + + if formula == 1: + for i in range(res-1): + t = ( i*step) + + x = ((2*w + cos((q*t)/p)) * cos(t*p)) * sin(t/p) + y = ((2*w + cos((q*t)/p)) * sin(t*p)) * sin(t/p) + z = sin(q*t/p) + + newPoints.append([x,y,z]) + + if formula == 2: + for i in range(res-1): + t = ( i*step) + beta = t*pi + + r = 0.8 + 1.6 * sin(q * beta/p) + theta = 2 * beta + phi = 0.6 * pi * sin(q * beta/p) + + x = r * cos(phi) * cos(theta) + y = r * cos(phi) * sin(theta) + z = r * sin(phi) + + newPoints.append([x,y,z]) + + + #newPoints = [[-1,-1,0], [-1,1,0], [1,1,0], [1,-1,0]] + return newPoints + +##------------------------------------------------------------ +# Main Function +def main(context, param, GEO, options, curveOptions, align_matrix): + # deselect all objects + bpy.ops.object.select_all(action='DESELECT') + + # options + knotType = options[1] + splineType = options[0] + + + # get verts + if knotType == 'Torus_Knot': + verts = Torus_Knot_Curve(param[0], param[1], param[2], param[3], param[4], + param[5], param[6], param[7], param[8]) + + # turn verts into array + vertArray = vertsToPoints(verts, splineType) + + # create object + createCurve(vertArray, GEO, options, curveOptions, align_matrix) + + return + +class torus_knot_plus(bpy.types.Operator): + '''''' + bl_idname = "torus_knot_plus" + bl_label = "Torus Knot +" + bl_options = {'REGISTER', 'UNDO'} + bl_description = "adds many types of knots" + + # align_matrix for the invoke + align_matrix = Matrix() + + #### general options + KnotTypes = [ + ('Torus_Knot', 'Torus Knot', 'Torus_Knot') + ] + KnotType = EnumProperty(name="Type", + description="Form of Curve to create", + items=KnotTypes) + SplineTypes = [ + ('NURBS', 'Nurbs', 'NURBS'), + ('POLY', 'Poly', 'POLY'), + ('BEZIER', 'Bezier', 'BEZIER')] + outputType = EnumProperty(name="Output splines", + description="Type of splines to output", + items=SplineTypes) + + #### GEO Options + geo_surf = BoolProperty(name="Surface", + default=True) + geo_bDepth = FloatProperty(name="bevel", + default=0.08, + min=0, soft_min=0) + geo_bRes = IntProperty(name="bevel res", + default=2, + min=0, soft_min=0, + max=4, soft_max=4) + geo_extrude = FloatProperty(name="extrude", + default=0.0, + min=0, soft_min=0) + geo_width = FloatProperty(name="width", + default=1.0, + min=0, soft_min=0) + geo_res = IntProperty(name="resolution", + default=12, + min=1, soft_min=1) + + #### Curve Options + shapeItems = [ + ('3D', '3D', '3D'), + ('2D', '2D', '2D')] + shape = EnumProperty(name="2D / 3D", + items=shapeItems, + description="2D or 3D Curve") + cyclic_u = BoolProperty(name="Cyclic", + default=True, + description="make curve closed") + endp_u = BoolProperty(name="endpoint_u", + default=True, + description="stretch to endpoints") + order_u = IntProperty(name="order_u", + default=4, + min=2, soft_min=2, + max=6, soft_max=6, + description="Order of nurbs spline") + bezHandles = [ + ('VECTOR', 'Vector', 'VECTOR'), + ('AUTOMATIC', 'Auto', 'AUTOMATIC')] + handleType = EnumProperty(name="Handle type", + description="bezier handles type", + items=bezHandles) + + #### Parameters + torus_res = IntProperty(name="Resoulution", + default=200, + min=3, soft_min=3, + description='Resolution') + torus_p = IntProperty(name="p", + default=2, + min=1, soft_min=1, + #max=1, soft_max=1, + description="p") + torus_q = IntProperty(name="q", + default=3, + min=1, soft_min=1, + #max=1, soft_max=1, + description="q") + torus_w = FloatProperty(name="height", + default=1, + #min=0, soft_min=0, + #max=1, soft_max=1, + description="height") + torus_h = FloatProperty(name="scale", + default=1, + #min=0, soft_min=0, + #max=1, soft_max=1, + description="scale") + torus_u = IntProperty(name="u", + default=1, + min=1, soft_min=1, + #max=1, soft_max=1, + description="u") + torus_v = IntProperty(name="v", + default=1, + min=1, soft_min=1, + #max=1, soft_max=1, + description="v") + torus_formula = IntProperty(name="Variation", + default=0, + min=0, soft_min=0, + max=10, soft_max=10) + torus_rounds = IntProperty(name="rounds", + default=2, + min=1, soft_min=1, + #max=1, soft_max=1, + description="rounds") + + ##### DRAW ##### + def draw(self, context): + props = self.properties + layout = self.layout + + # general options + col = layout.column() + #col.prop(props, 'KnotType') waits for more knottypes + col.label(text=props.KnotType+" Parameters") + + # Parameters per KnotType + box = layout.box() + if props.KnotType == 'Torus_Knot': + #box.prop(props, 'torus_formula') + box.prop(props, 'torus_res') + box.prop(props, 'torus_p') + box.prop(props, 'torus_q') + box.prop(props, 'torus_u') + box.prop(props, 'torus_v') + box.prop(props, 'torus_rounds') + box.prop(props, 'torus_w') + box.prop(props, 'torus_h') + + # Output Type + col = layout.column() + #col.label(text="Output Curve Type") + #row = layout.row() + #row.prop(props, 'outputType', expand=True) + #col = layout.column() + #col.label(text="Curve Options") + + # Curve options + #box = layout.box() + #if props.outputType == 'NURBS': + #box.row().prop(props, 'shape', expand=True) + #box.prop(props, 'cyclic_u') + #box.prop(props, 'endp_u') + #box.prop(props, 'order_u') + + #if props.outputType == 'POLY': + #box.row().prop(props, 'shape', expand=True) + #box.prop(props, 'cyclic_u') + + if props.outputType == 'BEZIER': + #box.row().prop(props, 'shape', expand=True) + col.row().prop(props, 'handleType', expand=True) + #box.prop(props, 'cyclic_u') + + # surface Options + col = layout.column() + col.label(text="Geometry Options") + box = layout.box() + box.prop(props, 'geo_surf') + box.prop(props, 'geo_bDepth') + box.prop(props, 'geo_bRes') + box.prop(props, 'geo_extrude') + box.prop(props, 'geo_width') + box.prop(props, 'geo_res') + + ##### POLL ##### + def poll(self, context): + return context.scene != None + + ##### EXECUTE ##### + def execute(self, context): + # turn off undo + undo = bpy.context.user_preferences.edit.global_undo + bpy.context.user_preferences.edit.global_undo = False + + props = self.properties + + # Parameters + param = [ + props.torus_p, #0 + props.torus_q, #1 + props.torus_w, #2 + props.torus_res, #3 + props.torus_formula, #4 + props.torus_h, #5 + props.torus_u, #6 + props.torus_v, #7 + props.torus_rounds #8 + ] + + # GEO Options + GEO = [ + props.geo_surf, #0 + props.geo_bDepth, #1 + props.geo_bRes, #2 + props.geo_extrude, #3 + props.geo_width, #4 + props.geo_res #5 + ] + + # Options + options = [ + # general properties + props.outputType, #0 + props.KnotType #1 + ] + + # Curve options + curveOptions = [ + props.shape, #0 + props.cyclic_u, #1 + props.endp_u, #2 + props.order_u, #4 + props.handleType #5 + ] + + # main function + main(context, param, GEO, options, curveOptions, self.align_matrix) + + # restore pre operator undo state + bpy.context.user_preferences.edit.global_undo = undo + + return {'FINISHED'} + + ##### INVOKE ##### + def invoke(self, context, event): + # store creation_matrix + self.align_matrix = align_matrix(context) + self.execute(context) + + return {'FINISHED'} + +################################################################################ +##### REGISTER ##### + +torus_knot_plus_button = (lambda self, context: self.layout.operator + (torus_knot_plus.bl_idname, text="Torus Knot +", icon="PLUGIN")) + +classes = [ +torus_knot_plus + ] + +def register(): + register = bpy.types.register + for cls in classes: + register(cls) + + bpy.types.INFO_MT_curve_add.append(torus_knot_plus_button) + +def unregister(): + unregister = bpy.types.unregister + for cls in classes: + unregister(cls) + + bpy.types.INFO_MT_curve_add.remove(torus_knot_plus_button) + +if __name__ == "__main__": + register() \ No newline at end of file -- cgit v1.2.3