Welcome to mirror list, hosted at ThFree Co, Russian Federation.

add_curve_spirals.py « add_curve_extra_objects - git.blender.org/blender-addons.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
blob: 11d86eb7d02d86ca9334a5d2789df2e86c351f73 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
'''bl_info = {
    "name": "Spirals",
    "description": "Make spirals",
    "author": "Alejandro Omar Chocano Vasquez",
    "version": (1, 2),
    "blender": (2, 62, 0),
    "location": "View3D > Add > Curve",
    "warning": "", # used for warning icon and text in addons panel
    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.4/Py/"
                "Scripts/Object/Spirals",
    "tracker_url": "http://alexvaqp.googlepages.com?"
                   "func=detail&aid=<number>",
    "category": "Add Curve",
}
'''
import bpy, time
from bpy.props import *
from math import sin, cos, pi, exp
from bpy_extras.object_utils import AddObjectHelper, object_data_add

#make normal spiral
#-----------------------------------------------------------------------------
def make_spiral(props, context):                  #archemedian and logarithmic can be plottet in zylindrical coordinates
    #if props.spiral_type != 1 and props.spiral_type != 2:
    #    return None

    #INPUT: turns->degree->max_phi, steps, direction
    #Initialise Polar Coordinate Enviroment
    #-------------------------------
    props.degree = 360*props.turns                #If you want to make the slider for degree
    steps = props.steps * props.turns             #props.steps[per turn] -> steps[for the whole spiral]
    props.z_scale = props.dif_z * props.turns
    
    max_phi  = pi*props.degree/180                #max angle in radian
    step_phi = max_phi/steps                      #angle in radians between two vertices
    if props.spiral_direction == 1:
        step_phi *= -1                            #flip direction
        max_phi *= -1
    step_z   = props.z_scale/(steps-1)            #z increase in one step
    
    verts = []
    verts.extend([props.radius,0,0,1])
    
    cur_phi = 0
    cur_z   = 0
    #-------------------------------

    #Archemedean: dif_radius, radius
    cur_rad = props.radius
    step_rad = props.dif_radius/(steps * 360/props.degree)        #radius increase per angle for archemedean spiral| (steps * 360/props.degree)...Steps needed for 360 deg
    #Logarithmic: radius, B_force, ang_div, dif_z
    
    #print("max_phi:",max_phi,"step_phi:",step_phi,"step_rad:",step_rad,"step_z:",step_z)
    while abs(cur_phi) <= abs(max_phi):
        cur_phi += step_phi
        cur_z   += step_z
        
        #-------------------------------
        if props.spiral_type == 1:
            cur_rad += step_rad
        if props.spiral_type == 2:
            #r = a*e^{|theta| * b}
            cur_rad = props.radius * pow(props.B_force, abs(cur_phi)) 
        #-------------------------------
    
        px = cur_rad * cos(cur_phi)
        py = cur_rad * sin(cur_phi)
        verts.extend( [px,py,cur_z,1] )

    return verts


#make Spheric spiral
#-----------------------------------------------------------------------------
def make_spiral_spheric(props, context):
    #INPUT: turns, steps[per turn], radius
    #use spherical Coordinates
    step_phi = (2*pi) / props.steps               #Step of angle in radians for one turn
    steps = props.steps * props.turns             #props.steps[per turn] -> steps[for the whole spiral]
    
    max_phi  = 2*pi*props.turns                   #max angle in radian
    step_phi = max_phi/steps                      #angle in radians between two vertices
    if props.spiral_direction == 1:               #flip direction
        step_phi *= -1
        max_phi *= -1
    step_theta = pi / (steps-1)                   #theta increase in one step (pi == 180 deg)

    verts = []
    verts.extend([0,0,-props.radius,1])           #First vertex at south pole

    #cur_rad = props.radius = CONST

    cur_phi = 0
    cur_theta = -pi/2                             #Beginning at south pole

    while abs(cur_phi) <= abs(max_phi):
        #Coordinate Transformation sphere->rect
        px = props.radius * cos(cur_theta) * cos(cur_phi)
        py = props.radius * cos(cur_theta) * sin(cur_phi)
        pz = props.radius * sin(cur_theta)

        verts.extend([px,py,pz,1])
        cur_theta += step_theta
        cur_phi += step_phi

    return verts

#make torus spiral
#-----------------------------------------------------------------------------

def make_spiral_torus(props, context):
    #INPUT: turns, steps, inner_radius, curves_number, mul_height, dif_inner_radius, cycles
    max_phi  = 2*pi*props.turns * props.cycles    #max angle in radian
    step_phi = 2*pi/props.steps                   #Step of angle in radians between two vertices
    if props.spiral_direction == 1:               #flip direction
        step_phi *= -1
        max_phi *= -1
    step_theta = (2*pi / props.turns) / props.steps
    step_rad = props.dif_radius / (props.steps * props.turns)
    step_inner_rad = props.dif_inner_radius / props.steps
    step_z = props.dif_z / (props.steps * props.turns)

    verts = []
    
    cur_phi = 0                                   #Inner Ring Radius Angle
    cur_theta = 0                                 #Ring Radius Angle
    cur_rad = props.radius
    cur_inner_rad = props.inner_radius
    cur_z = 0
    n_cycle = 0
    
    while abs(cur_phi) <= abs(max_phi):
        #Torus Coordinates -> Rect
        px = ( cur_rad + cur_inner_rad * cos(cur_phi) ) * cos(props.curves_number * cur_theta)
        py = ( cur_rad + cur_inner_rad * cos(cur_phi) ) * sin(props.curves_number * cur_theta)
        pz = cur_inner_rad * sin(cur_phi) + cur_z

        verts.extend([px,py,pz,1])

        if props.touch == True and cur_phi >= n_cycle * 2*pi:
            step_z = ( (n_cycle+1) * props.dif_inner_radius + props.inner_radius ) * 2 / (props.steps * props.turns)
            n_cycle += 1

        cur_theta += step_theta
        cur_phi += step_phi
        cur_rad += step_rad
        cur_inner_rad += step_inner_rad
        cur_z += step_z

    return verts
#-----------------------------------------------------------------------------

def draw_curve(props, context):
    if props.spiral_type == 1:
        verts = make_spiral(props, context)
    if props.spiral_type == 2:
        verts = make_spiral(props, context)
    if props.spiral_type == 3:
        verts = make_spiral_spheric(props, context)
    if props.spiral_type == 4:
        verts = make_spiral_torus(props, context)
    
    curve_data = bpy.data.curves.new(name='Spiral', type='CURVE')
    curve_data.dimensions = '3D'
    
    if props.curve_type == 0:
        spline = curve_data.splines.new(type='POLY')
    elif props.curve_type == 1:
        spline = curve_data.splines.new(type='NURBS')
    
    spline.points.add( len(verts)*0.25-1 )                          #Add only one quarter of points as elements in verts, because verts looks like: "x,y,z,?,x,y,z,?,x,..."
    spline.points.foreach_set('co', verts)
#    new_obj = object_data_add(bpy.context, curve_data)
    new_obj = object_data_add(context, curve_data)   

class spirals(bpy.types.Operator):
    bl_idname = "curve.spirals"
    bl_label = "Spirals"
    bl_options = {'REGISTER','UNDO', 'PRESET'}            #UNDO needed for operator redo and therefore also to let the addobjecthelp appear!!!
    bl_description = "adds different types of spirals"

    spiral_type = IntProperty(default=1, min=1, max=4, description="1:archemedian, 2:logarithmic, 3:spheric, 4:torus")
    curve_type = IntProperty(default=0, min=0, max=1, description="0:Poly, 1:Nurb")
    spiral_direction = IntProperty(default=0, min=0, max=1, description="0:counter-clockwise, 1:clockwise")
    
    turns = IntProperty(default=1, min=1, max=1000, description="Length of Spiral in 360 deg")
    steps = IntProperty(default=24, min=2, max=1000, description="Number of Vertices per turn")

    
    radius = FloatProperty(default=1.00, min=0.00, max=100.00, description="radius for first turn")
    dif_z = FloatProperty(default=0, min=-10.00, max=100.00, description="increase in z axis per turn")            #needed for 1 and 2 spiral_type
    #ARCHMEDEAN variables
    dif_radius = FloatProperty(default=0.00, min=-50.00, max=50.00, description="radius increment in each turn")        #step between turns(one turn equals 360 deg)
    #LOG variables 
    B_force = FloatProperty(default=1.00, min=0.00, max=30.00, description="factor of exponent")
    #TORUS variables
    inner_radius = FloatProperty(default=0.20, min=0.00, max=100, description="Inner Radius of Torus")
    dif_inner_radius = FloatProperty(default=0, min=-10, max=100, description="Increase of inner Radius per Cycle")
    dif_radius = FloatProperty(default=0, min=-10, max=100, description="Increase of Torus Radius per Cycle")
    cycles = FloatProperty(default=1, min=0.00, max=1000, description="Number of Cycles")
    curves_number = IntProperty(default=1, min=1, max=400, description="Number of curves of spiral")
    touch = BoolProperty(default=False, description="No empty spaces between cycles")

    def draw(self, context):                #Function used by Blender to draw the menu
        layout = self.layout
        layout.prop(self, 'spiral_type', text="Spiral Type")
        layout.prop(self, 'curve_type', text="Curve Type")
        layout.prop(self, 'spiral_direction', text="Spiral Direction")
        
        layout.label(text="Spiral Parameters:")
        layout.prop(self, 'turns', text = "Turns")
        layout.prop(self, 'steps', text = "Steps")

        box = layout.box()
        if self.spiral_type == 1:
            box.prop(self, 'dif_radius', text = "Radius Growth")
            box.prop(self, 'radius', text = "Radius")
            box.prop(self, 'dif_z', text = "Height")
        if self.spiral_type == 2:
            box.prop(self, 'radius', text = "Radius")
            box.prop(self, 'B_force', text = "Expansion Force")
            box.prop(self, 'dif_z', text = "Height")
        if self.spiral_type == 3:
            box.prop(self, 'radius', text = "Radius")
        if self.spiral_type == 4:
            box.prop(self, 'cycles', text = "Number of Cycles")
            if self.dif_inner_radius == 0 and self.dif_z == 0:
                self.cycles = 1
            box.prop(self, 'radius', text = "Radius")
            if self.dif_z == 0:
                box.prop(self, 'dif_z', text = "Height per Cycle")
            else:
                box2 = box.box()
                box2.prop(self, 'dif_z', text = "Height per Cycle")
                box2.prop(self, 'touch', text = "Make Snail")
            box.prop(self, 'inner_radius', text = "Inner Radius")
            box.prop(self, 'curves_number', text = "Curves Number")
            box.prop(self, 'dif_radius', text = "Increase of Torus Radius")
            box.prop(self, 'dif_inner_radius', text = "Increase of Inner Radius")

    @classmethod
    def poll(cls, context):                            #method called by blender to check if the operator can be run
        return context.scene != None
    def execute(self, context):
        time_start = time.time()
        draw_curve(self, context)
        print("Drawing Spiral Finished: %.4f sec", time.time() - time_start)
        return {'FINISHED'}