jeremiahlamontagne
commented
9 years ago I have never written in python (I do mostly web design and php) but I am willing to give this a try, pointers/hand holding would be appreciated. After a quick google search I came accross the following code from http://blender.stackexchange.com/questions/8465/in-python-given-x-value-on-2d-bezier-curve-return-y-value
import bpy
import numpy as np
''' ***a bezier object/function needs to be defined based on the argument parameter values '''
def main():
'''Here's an example usage of these functions'''
x = 5.0 '''***this value is the frame number variable'''
bez_obj = bpy.data.objects['BezierCurve']
print('The y-value is', getYfromXforBezierObject(bez_obj, x))
def getYfromXforBezierObject(bez_obj, x):
'''Given a Bezier object which, when projected on to xy-plane, is a
well-behaved function (i.e. each x-value has only one associated y-value),
this returns the y-value for a given x-value
The higher resolution your curve is, the more accurate the resultant y-value
will be.'''
#find appropriate segment
segment_i = determineBezSegment(bez_obj, x)
if len(bez_obj.data.splines) > 1:
print("WARNING: your Bezier object has multiple splines!")
spline = bez_obj.data.splines[0]
#get the four points that control the cubic bezier segment
P0 = spline.bezier_points[segment_i].co[:2]
P1 = spline.bezier_points[segment_i].handle_right[:2]
P2 = spline.bezier_points[segment_i+1].handle_left[:2]
P3 = spline.bezier_points[segment_i+1].co[:2]
y = getYfromXforBezSegment(P0, P1, P2, P3, x)
return y
def determineBezSegment(bez_obj, x):
'''Given a Bezier object and an x-value, determine which of the cubic
segments corresponds to that x-value.
A return value of 0 would represent the first segment.'''
print(bez_obj.data)
bez_points = bez_obj.data.splines[0].bezier_points
if len(bez_obj.data.splines) > 1:
print("WARNING: your Bezier object has multiple splines!")
#loop through all segments and find which one contains x
for segment_i in range(len(bez_points)-1):
start_point = bez_points[segment_i]
end_point = bez_points[segment_i+1]
#break if this segment contains x
if start_point.co[0] <= x < end_point.co[0]:
break
#check if no segment was found
else:
print("WARNING: no segment found for given x-value and Bezier object")
return None
return segment_i
def getYfromXforBezSegment(P0, P1, P2, P3, x):
'''For a cubic Bezier segment described by the 2-tuples P0, ..., P3, return
the y-value associated with the given x-value.
Ex: getXfromYforCubicBez((0,0), (1,1), (2,1), (2,2), 3.2)'''
#First, get the t-value associated with x-value, where t is the
#parameterization of the Bezier curve and ranges from 0 to 1.
#We need the coefficients of the polynomial describing cubic Bezier
#(cubic polynomial in t)
coefficients = [-P0[0] + 3*P1[0] - 3*P2[0] + P3[0],
3*P0[0] - 6*P1[0] + 3*P2[0],
-3*P0[0] + 3*P1[0],
P0[0] - x]
#find roots of this polynomial to determine the parameter t
roots = np.roots(coefficients)
#find the root which is between 0 and 1, and is also real
correct_root = None
for root in roots:
if np.isreal(root) and 0 <= root <= 1:
correct_root = root
#check to make sure a valid root was found
if correct_root is None:
print('Error, no valid root found. Are you sure your Bezier curve '
'represents a valid function when projected into the xy-plane?')
param_t = correct_root
#from our value for the t parameter, find the corresponding y-value using formula for
#cubic Bezier curves
y = (1-param_t)**3*P0[1] + 3*(1-param_t)**2*param_t*P1[1] + 3*(1-param_t)*param_t**2*P2[1] + param_t**3*P3[1]
assert np.isreal(y)
# typecast y from np.complex128 to float64
y = y.real
return y
if __name__ == '__main__':
main()If I understand correctly then the x axis variable in the bezier would be the frame number and the y axis range would be the difference between the beginning and ending argument values.
To implement this the following arguments would need to be added(the start values could just be the original arguments): octave start/end octavescale start/end itterations start/end jitter start/end zoom start/end blend start/end 1 or more cubic bezier arguments (one if you wanted one curve to rule them all i.e. octaves and iterations would follow the same curve)
Or maybe the better way would be to implement parameters in the existing arguments so for instance octaves would have optional additional parameters of: value1(already implemented) value2(ending value), x1, x1, y1, y2 (these are the parameters that define the bezier curve and maybe should be p0, p1, p2, p3 to match the above code)
We already have the x value which is the frame number and the Y range will be the difference between value1 and value2.
the above function returns y which is the new argument value for whatever given frame we are on.
Please advise on the next best step for implementing this in your code:)
graphific
First, thank you for this useful tool! Just a request to be able to have begining and ending parameters for the following arguments: [-oct OCTAVES] [-octs OCTAVESCALE] [-itr ITERATIONS] [-j JITTER] [-z ZOOM] [-s STEPSIZE] [-b BLEND]
A linear transition would be excellent, a transition defined by a cubic bezier would be even better. Thank you for your consideration!