def spline_curve_kv_norm2(): """ Creates a spline Curve without knot vector normalization """ curve = BSpline.Curve(normalize_kv=False) curve.degree = 3 curve.ctrlpts = [[5.0, 5.0], [10.0, 10.0], [20.0, 15.0], [35.0, 15.0], [45.0, 10.0], [50.0, 5.0]] curve.knotvector = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0] return curve
def spline_curve(): """ Creates a spline Curve """ curve = BSpline.Curve() curve.degree = 3 curve.ctrlpts = [[5.0, 5.0], [10.0, 10.0], [20.0, 15.0], [35.0, 15.0], [45.0, 10.0], [50.0, 5.0]] curve.knotvector = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0] return curve
def dowork(self,ch, method, properties, body): data=json.loads(body) points=data['points'] RADIUS=data['RADIUS'] WIDTH=data['WIDTH'] HEIGHT=data['HEIGHT'] SPREAD=data['SPREAD'] curve = BSpline.Curve() curve.degree = 3 curve.delta = 0.005 lpoints = points curve.ctrlpts = lpoints curve.knotvector = knotvector.generate(3, len(curve.ctrlpts)) curve_points = curve.evalpts temppixels = np.full((WIDTH, HEIGHT), 0.0) sl=SpreadLines(temppixels,255) sl.drawline(curve_points) print(sl.img_data.max()) data={} data['WIDTH']=WIDTH data['HEIGHT']=HEIGHT data['pixels']=temppixels.tolist() message=json.dumps(data) self.channel.basic_publish(exchange='',routing_key='feronia_result',body=message) ch.basic_ack(delivery_tag = method.delivery_tag)
def build_geomdl(cls, degree, knotvector, control_points, weights=None, normalize_knots=False): if weights is not None: curve = NURBS.Curve(normalize_kv=normalize_knots) else: curve = BSpline.Curve(normalize_kv=normalize_knots) curve.degree = degree if isinstance(control_points, np.ndarray): control_points = control_points.tolist() curve.ctrlpts = control_points if weights is not None: if isinstance(weights, np.ndarray): weights = weights.tolist() curve.weights = weights if isinstance(knotvector, np.ndarray): knotvector = knotvector.tolist() curve.knotvector = knotvector result = SvGeomdlCurve(curve) result.u_bounds = curve.knotvector[0], curve.knotvector[-1] return result
def get_norms(surf, timestep_limit): # create a 2D bezier curve curve = BSpline.Curve() curve.degree = 3 ctrl_points = [[np.random.uniform(0, 0.2), np.random.uniform(0, 0.2)], [np.random.uniform(0, 0.5), np.random.uniform(0, 0.5)], [np.random.uniform(0.25, 0.75), np.random.uniform(0.25, 0.75)], [np.random.uniform(0.5, 0.75), np.random.uniform(0.5, 0.75)], [np.random.uniform(0.8, 1), np.random.uniform(0.8, 1.0)]] curve.set_ctrlpts(ctrl_points) curve.knotvector = utilities.generate_knot_vector(curve.degree, len(curve.ctrlpts)) curve.sample_size = timestep_limit curve.evaluate() points_c = curve.evalpts norms = normal(surf, points_c) angles = [] # pitch, yaw traj = [] # x,y,z for i in range(len(norms)): nu = np.array(norms[i][1]) yaw = 180.0*np.arctan2(np.abs(nu[1]), np.abs(nu[0]))/np.pi ca = np.linalg.norm(nu[0:2]) pitch = 180.0*np.arctan2(nu[2], ca)/np.pi angles.append([pitch, yaw]) point = np.array(norms[i][0]) traj.append(np.array([point[0], point[1], point[2], pitch, yaw])) return traj, norms, curve
def draw(size): data = [] data = np.ones((size, size), np.uint16) * 65535 for _ in range(2): pnum = randint(15, 100) a = random() * TWOPI + linspace(0, TWOPI, pnum) points = column_stack((cos(a), sin(a))) * (1500 + random() * 100) curve = BSpline.Curve() curve.degree = 3 # lpoints=list(list([i[0]+randint(-WOBBLE,WOBBLE),i[1]+randint(-WOBBLE,WOBBLE)]) for i in points) # curve.ctrlpts=lpoints # print(curve.ctrlpts) curve.delta = 0.00001 # curve_points=curve.evalpts # for t in curve_points: # data[int(round(t[0]+size/2)),int(round(t[1]+size/2))]=65535 # print(int(round(t[0]+size/2)),int(round(t[1]+size/2))) for decay in range(DECAYLENGTH): # print(crange[decay]) lpoints = list( list([ i[0] + randint(-WOBBLE, WOBBLE), i[1] + randint(-WOBBLE, WOBBLE) ]) for i in points) curve.ctrlpts = lpoints curve.knotvector = knotvector.generate(3, len(curve.ctrlpts)) curve_points = curve.evalpts for t in curve_points: data[int(round(t[0] + size / 2)), int(round(t[1] + size / 2))] += int(crange[decay]) return data
def bspline_curve3d(): """ Creates a B-Spline 3-dimensional curve instance """ curve = BSpline.Curve() curve.degree = 2 curve.ctrlpts = [[1, 1, 0], [2, 1, -1], [2, 2, 0]] curve.knotvector = [0, 0, 0, 1, 1, 1] return curve
def gen_kernel(num_spline_dots=6, curve_degree=5, kernel_size=(19, 19)): curve = BSpline.Curve() knot_dots = [] knot_dots = [] small_kernel_size = (int(np.round(kernel_size[0] / 1.5)), int(np.round(kernel_size[1] / 1.5))) for i in range(num_spline_dots): knot_dots += [[ np.random.randint(0, small_kernel_size[0]), np.random.randint(0, small_kernel_size[1]) ]] curve.degree = curve_degree curve.ctrlpts = knot_dots curve.knotvector = generate_knot_vector(curve.degree, len(curve.ctrlpts)) curve.delta = 0.005 curve.evaluate() pts = np.array(curve.evalpts) pts[:, 0] -= (pts[:, 0].min() - 2) pts[:, 1] -= (pts[:, 1].min() - 2) k_dim = int(np.ceil(pts.max())) + 2 k = kern_from_grid(pts, k_dim) cm_k = np.round(calculate_center_mass(k), 0).astype(int) dim_k_c = 2 * max(list(np.array(k.shape) - cm_k) + list(cm_k)) if dim_k_c % 2 == 0: dim_k_c += 1 k = expand(k, (dim_k_c, dim_k_c)) k /= np.sum(k) return k
def swing_leg_planning(): curve = BSpline.Curve() curve.ctrlpts = ( (-0.2, 0), (-0.3, -0.03), (0., 0.3), (0.3, 0.), (0.2, 0.)) # 控制点 curve.delta = 0.01 # 数据间隔 curve.degree = 4 # degree应该小于控制点数量 curve.knotvector = utilities.generate_knot_vector(curve.degree, len(curve.ctrlpts)) curve.evaluate() x = [] dx = [] y = [] dy = [] t_list = np.linspace(0, 1, 101) for t in t_list: tmp = curve.derivatives(t, order=1) x.append(tmp[0][0]) dx.append(tmp[1][0]) y.append(tmp[0][1]) dy.append(tmp[1][1]) plt.plot(x, y) plt.xlim((-0.3, 0.3)) plt.ylim((-0.1, 0.5)) plt.grid() plt.show()
def bspline_curve3d(): """ Creates a 3-dimensional B-Spline curve instance """ # Create a curve instance curve = BSpline.Curve() # Set curve degree curve.degree = 4 # Set control points curve.ctrlpts = [[5.0, 15.0, 0.0], [10.0, 25.0, 5.0], [20.0, 20.0, 10.0], [15.0, -5.0, 15.0], [7.5, 10.0, 20.0], [12.5, 15.0, 25.0], [15.0, 0.0, 30.0], [5.0, -10.0, 35.0], [10.0, 15.0, 40.0], [5.0, 15.0, 30.0]] # Set knot vector curve.knotvector = [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0, 1.0, 1.0, 1.0, 1.0 ] # Set sample size curve.sample_size = SAMPLE_SIZE # Return the instance return curve
def geomdl_method(degree, ctrl_points): """Generate by geomdl package""" print(util.Section('B-Spline using geomdl Package')) # construct curve = BSpline.Curve() curve.degree = degree curve.ctrlpts = ctrl_points curve.knotvector = utilities.generate_knot_vector(degree, len(ctrl_points)) curve.evaluate(step=0.01) print( f'knots length = {len(curve.knotvector)}, knots = {curve.knotvector}') print(f'c(0) = {curve.evaluate_single(0)}') print(f'c(0.5) = {curve.evaluate_single(0.5)}') print(f'c(0.6) = {curve.evaluate_single(0.6)}') print(f'c(1.0) = {curve.evaluate_single(1.0)}') # plot ctrl_plot_points = np.array(ctrl_points) curve_points = np.array(curve.evalpts) fig = plt.figure('B-Spline using geomdl Package') ax = fig.add_subplot(111) ax.plot(ctrl_plot_points[:, 0], ctrl_plot_points[:, 1], 'g.-.', label='Control Points') ax.plot(curve_points[:, 0], curve_points[:, 1], 'b', label='BSpline Curve') ax.grid(True) ax.set_title('B-Spline using geomdl Package') ax.legend(loc='best') plt.show(block=False)
def spline2mask(crl, width, height, delta=.05, new_shape=None): c, r, l = crl if type(crl) == list else crl.tolist() cps = [] for i in range(len(c)): ip = (i + 1) % len(c) cps.append([c[i], r[i], l[ip], c[ip]]) connecs = [] for i in range(len(cps)): curve = BSpline.Curve() curve.degree = 3 curve.ctrlpts = cps[i] curve.knotvector = utilities.generate_knot_vector( curve.degree, len(curve.ctrlpts)) # print('delta',delta) curve.delta = delta curve.evaluate() connecs.append(curve.evalpts) polygon = np.array(connecs).flatten().tolist() img = Image.new('L', (height, width), 255) ImageDraw.Draw(img).polygon(polygon, outline=0, fill=0) if new_shape is None: new_shape = (height, width) mask = np.array(img.resize(new_shape, Image.NEAREST)) #print(mask.shape, width, height, downscale,int(width//downscale), int(height//downscale)) return mask == False
def interpolate_Bspline(stepsBtwFrame, currentPos, nextPos, liftHeight, draw=False): # This function returns a list of 2-D trajectory points. Need to use IK to convert to joint angles afterwards # The return looks like [[0,0], [0,0], [0,0], [0,0], ... [0,0]] length=stepsBtwFrame # next = [x, z] # curr = [x, z] x_offset = 5 # Top control point height above liftheight z_offset = 30 # End control point position outside leg stroke # Pick up leg and make a full curve down to a upper position of wall halfZstroke = (nextPos[1] - currentPos[1]) / 2.0 # half stroke halfZstroke_and_offset = halfZstroke + z_offset # half stroke plus offset outside the stroke ctrlPoint = [ [0.0, -halfZstroke_and_offset / 2.5], [liftHeight, -halfZstroke], [liftHeight + x_offset, 0.0], [liftHeight, 2 * halfZstroke] ] # there was one more point: [self.liftHeight/2, 0.0, halfZstroke_and_offset/3.0] nurbs = BSpline.Curve() # Set unweighted control points allPts = [currentPos] for i in range(len(ctrlPoint)): allPts.append(ctrlPoint[i]) allPts.append(nextPos) nurbs.degree = 2 # Degree of the curve, order = degree+1 nurbs.ctrlpts = allPts # Auto-generate knot vector nurbs.knotvector = utilities.generate_knot_vector(nurbs.degree, len(nurbs.ctrlpts)) # depending on how long the looping time is and how smooth you want the trajectory to be, # this value should be carefully tuned nurbs.sample_size = stepsBtwFrame + 1 # The total # of points that goes to pts = nurbs._curve_points nurbs.evaluate() # need to put start and stop points pts = nurbs.evalpts #[1:(stepsBtwFrame+1)] if draw == True: ##################### For climbing between 2 walls ##################### plt.plot([nurbs.evalpts[i][0] for i in range(nurbs.sample_size)], [nurbs.evalpts[i][1] for i in range(nurbs.sample_size)]) plt.xlabel("x") plt.ylabel("z") #plt.xlim([-200, 10]) #plt.ylim([-200, 200]) plt.show(block=True) return pts
def test_bspline_curve_loadsave(): curve_save = BSpline.Curve() curve_save.degree = C_DEGREE curve_save.ctrlpts = C_CTRLPTS3D curve_save.knotvector = C_KV curve_save.save(FILE_NAME) curve_load = BSpline.Curve() curve_load.load(FILE_NAME) # Remove save file os.remove(FILE_NAME) assert curve_save.degree == curve_load.degree assert curve_save.knotvector == curve_load.knotvector assert curve_save.ctrlpts == curve_load.ctrlpts assert curve_save.dimension == curve_load.dimension
def gen_kern_seq(num_spline_dots=12, kernel_size=(19, 38)): curve_degree = num_spline_dots - 1 curve = BSpline.Curve() small_kernel_size = (int(np.round(kernel_size[0] / 1.5)) - 1, int(np.round(kernel_size[1] / 1.5)) - 1) phi = np.random.rand() * 2 * np.pi knot_dots = [[ small_kernel_size[0] * np.cos(phi), small_kernel_size[1] * np.sin(phi) ]] for i in range(1, num_spline_dots - 1): knot_dots += [[ np.random.randint(0, small_kernel_size[0]), np.random.randint(0, small_kernel_size[1]) ]] phi = np.random.rand() * 2 * np.pi knot_dots += [[ small_kernel_size[0] * np.cos(phi), small_kernel_size[1] * np.sin(phi) ]] curve.degree = curve_degree curve.ctrlpts = knot_dots curve.knotvector = generate_knot_vector(curve.degree, len(curve.ctrlpts)) curve1, curve2 = split_curve(curve, np.random.rand() * 0.2 + 0.4) curve1.delta = 0.005 curve2.delta = 0.005 curve1.evaluate() curve2.evaluate() pts_1 = np.array(curve1.evalpts) pts_1[:, 0] -= (pts_1[:, 0].min() - 2) pts_1[:, 1] -= (pts_1[:, 1].min() - 2) pts_2 = np.array(curve2.evalpts) pts_2[:, 0] -= (pts_2[:, 0].min() - 2) pts_2[:, 1] -= (pts_2[:, 1].min() - 2) k_dim = int(max(np.ceil(pts_1.max()), np.ceil(pts_2.max()))) + 2 k1 = kern_from_grid(pts_1, k_dim + 1) k2 = kern_from_grid(pts_2, k_dim + 1) cm_k1 = np.round(calculate_center_mass(k1), 0).astype(int) dim_k1_c = 2 * max(list(np.array(k1.shape) - cm_k1) + list(cm_k1)) cm_k2 = np.round(calculate_center_mass(k2), 0).astype(int) dim_k2_c = 2 * max(list(np.array(k2.shape) - cm_k2) + list(cm_k2)) dim_final = max(dim_k1_c, dim_k2_c) if dim_final % 2 == 0: dim_final += 1 k1 = expand(k1, (dim_final, dim_final)) k2 = expand(k2, (dim_final, dim_final)) k1 /= k1.sum() k2 /= k2.sum() return k1, k2
def generate_bspline(degree, control_points, knots, delta=0.005): curve = BSpline.Curve() curve.degree = degree curve.ctrlpts = control_points curve.knotvector = knots curve.delta = delta curve_points = curve.evalpts curve_points = np.asarray(curve_points) return curve, curve_points
def render_to_tolerance(self, tolerance): curve = BSpline.Curve() curve.degree = self.degree curve.ctrlpts = self.control.tolist() curve.knotvector = self.knots.tolist() curve.sample_size = max( 2, math.ceil(self.length_upper_bound() / tolerance)) return burin.types.BSpline(curve, tolerance)
def test_bspline_curve3d_evaluate(): curve = BSpline.Curve() curve.degree = C_DEGREE curve.ctrlpts = C_CTRLPTS3D curve.knotvector = C_KV curve.sample_size = SAMPLE_SIZE # Expected output res = [[1.0, 1.0, 0.0], [1.4375, 1.0625, -0.375], [1.75, 1.25, -0.5], [1.9375, 1.5625, -0.375], [2.0, 2.0, 0.0]] assert curve.evalpts == res
def nurbs(suc, pre, n=400): assert len(suc) == len(pre) xs = np.linspace(0, 1, len(suc) + 2).tolist() pts = np.array([xs[::-1] + xs[1:], [0] + suc[::-1] + [0] + pre + [0]]).transpose().tolist() crv = BSpline.Curve() crv.degree = 2 crv.ctrlpts = pts crv.knotvector = knotvector.generate(crv.degree, crv.ctrlpts_size) airfoil = np.array([crv.evaluate_single(t) for t in np.linspace(0, 1, n)]) return airfoil[:, 0], airfoil[:, 1]
def getQuadBezier(P0, P1, P2, Degree=2, nSample=50): """ 返回一个QuadBezier对象, P0 P1 P2为控制点,Degree大于2可能报错,nSample为采样数目 """ curve = BSpline.Curve() curve.ctrlpts = [P0, P1, P2] curve.degree = Degree curve.knotvector = utilities.generate_knot_vector(curve.degree, len(curve.ctrlpts)) curve.sample_size = nSample return curve
def resample_coords_smooth(coords, sample_size=120, degree=3): """Resamples an array of coordinates while smoothing out the new values with a b-spline.""" #Prevents code from breaking when the stroke contains too few values. while coords.shape[0] < degree + 1: coords = np.concatenate((coords, np.expand_dims(coords[-1], axis=0)), axis=0) curve = BSpline.Curve() curve.degree = degree curve.ctrlpts = coords.tolist() curve.knotvector = generate_knot_vector(degree, len(curve.ctrlpts)) curve.sample_size = sample_size return np.array(curve.evalpts)
def __init__(self, robot_id, plane_id): self.sys_t = 0 # 系统时间 self.l0 = 1.0 # 腿长 self.para = [20.0, -9.8, 1.0] # [m, g, l0]机器人参数 self.status = 'air' self.contact_status = [0, 0] self.robot_id = robot_id self.plane_id = plane_id self.dic_vel_jac = {} # 由速度索引的控制雅可比矩阵 # self.dic_air_time = {} # 速度索引半周期 # self.dic_sup_time = {} # 速度索引的支撑时间 self.pair_table = np.array([]) # -----------本周期相关变量------------------ self.start_time = 0 # 本周起的起始时间 self.this_x = np.array([]) # 起始顶点状态 self.des_v = 0 # 参考速度 self.des_pair = [] # 理想pair self.des_air_time = 0 self.des_sup_time = 0 self.this_pair = [] # 本周期的仿真pair self.this_du = np.array([]) # 无系数du self.this_u = np.array([]) # 本周期控制量 self.this_T_half = 0 # 本半周期时间间隔 self.this_t = 0 # 本周期时间 self.this_curve_l = BSpline.Curve() self.this_curve_r = BSpline.Curve() self.a_begin = np.array([]) # 离地点速度方向 self.p_begin = np.array([]) self.a_end = np.array([]) # 着地点速度方向 self.p_end = np.array([]) self.status_change = True # 初始默认有一个状态转换 self.cycle_cnt = 1 # 半周期计数 # 支撑阶段相关数据 self.path_gen = [] # 质心路径生成器 self.t_sup_max = 0 self.t_sup_begin = 0 # 支撑相初始时间
def test_bspline_curve_loadsave(bspline_curve3d): fname = FILE_NAME + ".pickle" bspline_curve3d.save(fname) curve_load = BSpline.Curve() curve_load.load(fname) # Remove save file os.remove(fname) assert bspline_curve3d.degree == curve_load.degree assert bspline_curve3d.knotvector == curve_load.knotvector assert bspline_curve3d.ctrlpts == curve_load.ctrlpts assert bspline_curve3d.dimension == curve_load.dimension
def bs_curve(): """ Creates a 3rd order 2D B-spline Curve instance """ # Create a curve instance curve = BSpline.Curve() # Set curve degree curve.degree = 3 # Set control points curve.ctrlpts = [[5.0, 5.0], [10.0, 10.0], [20.0, 15.0], [35.0, 15.0], [45.0, 10.0], [50.0, 5.0]] # Set knot vector curve.knotvector = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0] return curve
def curve_test(): print("Running curve test...") # Create the curve instance crv = BSpline.Curve() # Set degree crv.degree = 1 # Set control points crv.ctrlpts = [[0, 0], [1, 1]] # Set knot vector crv.knotvector = [0, 0, 1, 1] # Get curve points points = crv.evalpts #assign every 10th pt to a list, as well as start and finish focus_pts = [] focus_pts.append(points[0]) k = 0 for pt in points: if ((k % 10) == 0): focus_pts.append(pt) #print(pt) focus_pts.append(points[len(points) - 1]) print(focus_pts) #my_pos should be fed by encoder readings, not by speculation of success my_pos = focus_pts[0] theta = 0 for pt in focus_points: if (pt != my_pos): gamma = math.atan2((pt[1] - my_pos[1]) / (pt[0] - my_pos[0])) e_theta = theta - gamma e_dist = math.sqrt((pt[0] - my_pos[0])**2 + (pt[1] - my_pos[1])**2) #Now do the acceleration thing... base_power_set = [50, 50] #or fake it in my case power_offsets = get_power_set(e_theta, e_dist) power_command = [ base_power_set[0] + power_offsets[0], base_power_set[1] + power_offsets[1] ] #roboclaw.ForwardM2(address, power_command[0]) #roboclaw.ForwardM1(address, power_command[1]) return 1
def create(self, ctrlpts_path): #Create the curve instance crv = BSpline.Curve() #Set the degree crv.degree = self.degree crv.delta = 0.005 #Set control points crv.ctrlpts = exchange.import_txt(ctrlpts_path, separator=" ") #Generate a uniform knotvector crv.knotvector = knotvector.generate(crv.degree, crv.ctrlpts_size) #Get curve points and saving into a file self.bspline_points = np.array(crv.evalpts)
def Knotvector(CONTROL, degree): """Génère un vecteur de noeud uniforme en fonction des points de controle et du degré d'approximation""" #Creation de la courbe crv = BSpline.Curve() #Degre de la courbe crv.degree = degree #Initialisation des points de controles crv.ctrlpts = CONTROL.tolist() #Generation des knots crv.knotvector = knotvector.generate(crv.degree, crv.ctrlpts_size) return crv.knotvector
def splinei_lines(WIDTH,HEIGHT,MAX_SPLINE_WIDTH=120): curve = BSpline.Curve() curve.degree = 3 curve.delta = 0.00005 lpoints = linespread(WIDTH,HEIGHT,MAX_SPLINE_WIDTH) curve.ctrlpts = lpoints curve.knotvector = knotvector.generate(3, len(curve.ctrlpts)) curve_points = curve.evalpts yield curve_points while True: for p in lpoints: p[1] += ((random() - 0.5) * (25) * (sin((p[0]) * (pi / WIDTH)) ** 2)) p[0] += ((random() - 0.5) * (5) * (sin((p[0]) * (pi / WIDTH)) ** 2)) p[2] += ((random() - 0.5) * (10) * (sin((p[0]) * (pi / WIDTH)) ** 2)) curve.ctrlpts = lpoints curve_points = curve.evalpts yield curve_points
def BSplines_RoutinePython(CONTROL, KNOT, degree, t, dimension=2): """ Retourne un tableau numpy des coordonnées de la Bspline. Ses dérivées 1, 2 et 3. CONTROL est un tableau numpy des coordonnees des pts de controles et knot est une liste issu de Knotvector. Cette méthode utilise la fonction evaluation de NURBS Python""" #Creation de la courbe crv = BSpline.Curve() #Degre de la courbe crv.degree = degree #Initialisation des points de controles crv.ctrlpts = CONTROL.tolist() #Les noeuds crv.knotvector = KNOT if dimension == 2: BSPLINE = np.zeros((len(t), 2)) DER1 = np.zeros((len(t), 2)) DER2 = np.zeros((len(t), 2)) DER3 = np.zeros((len(t), 2)) for i in range(len(t)): DER = crv.derivatives(t[i], order=3) BSPLINE[i, :] = DER[0] DER1[i, :] = DER[1] DER2[i, :] = DER[2] DER3[i, :] = DER[3] if dimension == 3: BSPLINE = np.zeros((len(t), 3)) DER1 = np.zeros((len(t), 3)) DER2 = np.zeros((len(t), 3)) DER3 = np.zeros((len(t), 3)) for i in range(len(t)): DER = crv.derivatives(t[i], order=3) BSPLINE[i, :] = DER[0] DER1[i, :] = DER[1] DER2[i, :] = DER[2] DER3[i, :] = DER[3] return BSPLINE, DER1, DER2, DER3
def splinei(): curve = BSpline.Curve() curve.degree = 3 curve.delta = 0.000005 lpoints = linespread() curve.ctrlpts = lpoints curve.knotvector = knotvector.generate(3, len(curve.ctrlpts)) curve_points = curve.evalpts yield curve_points while True: for p in lpoints: p[1] += int((random() - 0.5) * (25) * (sin( (p[0]) * (pi / WIDTH))**2)) p[0] += int((random() - 0.5) * (5) * (sin( (p[0]) * (pi / WIDTH))**2)) curve.ctrlpts = lpoints curve_points = curve.evalpts yield curve_points