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 test_generate_knot_vector5(): # testing auto-generated unclamped knot vector degree = 3 num_ctrlpts = 5 result = [0.0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0] autogen_kv = knotvector.generate(degree, num_ctrlpts, clamped=False) assert autogen_kv == result
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 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 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 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
def process(self): if not any(socket.is_linked for socket in self.outputs): return curves_out = [] is_first = True for curve1, curve2, factor1, factor2 in self.get_inputs(): _, t_max_1 = curve1.get_u_bounds() t_min_2, _ = curve2.get_u_bounds() curve1_end = curve1.evaluate(t_max_1) curve2_begin = curve2.evaluate(t_min_2) tangent_1_end = curve1.tangent(t_max_1) tangent_2_begin = curve2.tangent(t_min_2) tangent1 = factor1 * tangent_1_end / np.linalg.norm(tangent_1_end) tangent2 = factor2 * tangent_2_begin / np.linalg.norm(tangent_2_begin) new_curve = BSpline.Curve() new_curve.degree = 3 ctrlpts = [ curve1_end.tolist(), (curve1_end + tangent1).tolist(), (curve2_begin - tangent2).tolist(), curve2_begin.tolist() ] new_curve.ctrlpts = ctrlpts new_curve.knotvector = knotvector.generate(new_curve.degree, 4) nurbs_curve = SvExGeomdlCurve(new_curve) if self.mode == 'N' and not self.cyclic and self.output_src and is_first: curves_out.append(curve1) curves_out.append(nurbs_curve) if self.mode == 'N' and self.output_src: curves_out.append(curve2) is_first = False self.outputs['Curve'].sv_set(curves_out)
def splinei_circle(WIDTH,HEIGHT,RADIUS,MAX_SPLINE_WIDTH=120): curve = BSpline.Curve() curve.degree = 3 curve.delta = 0.00005 #lpoints = linespread(WIDTH,HEIGHT,MAX_SPLINE_WIDTH) pnum=50 RADIUS=1000 WOBBLE=40 lpoints=circlespread(WIDTH,HEIGHT,RADIUS,WOBBLE,MAX_SPLINE_WIDTH,pnum) #print(lpoints) curve.degree = 3 curve.ctrlpts = lpoints curve.knotvector = knotvector.generate(3, len(curve.ctrlpts)) curve_points = curve.evalpts #print(len(curve_points)) yield curve_points while True: for p in lpoints: p[1] += int((random() - 0.5) * (60) ) p[0] += int((random() - 0.5) * (60) ) p[2] += int((random() - 0.5) * (30) ) curve.ctrlpts = lpoints curve_points = curve.evalpts yield curve_points
def test_generate_knot_vector4(): degree = 4 num_ctrlpts = 12 autogen_kv = knotvector.generate(degree, num_ctrlpts) result = [0.0, 0.0, 0.0, 0.0, 0.0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875, 1.0, 1.0, 1.0, 1.0, 1.0] assert autogen_kv == result
def test_generate_knot_vector3(): with pytest.raises(ValueError): degree = 0 num_ctrlpts = 0 knotvector.generate(degree, num_ctrlpts)
def test_generate_knot_vector3(): with pytest.raises(ValueError): degree = 0 num_ctrlpts = 0 knotvector.generate(degree, num_ctrlpts)
# [2, 0, 0], [2, 1, 1], [2, 2, 0],[2, 0, 0], [2, 1, 1] # ] # control_points = [[0, 0, 0], [0, 1, 1],[0, 2, 0], # [1, 0, 0], [1, 1, 1],[1, 2, 0], # [2, 0, 0], [2, 1, 1],[2, 2, 0], # [0, 0, 0], [0, 1, 1],[0, 2, 0], # [1, 0, 0], [1, 1, 1],[1, 2, 0] # ] surf.set_ctrlpts(control_points, 3, 3) # Set knot vectors #surf.knotvector_u = [0, 0, 0, 0, 1, 1, 1, 1] #surf.knotvector_v = [0, 0, 0, 1, 1, 1] surf.knotvector_u = generate(surf.degree_u,surf.ctrlpts_size_u,clamped=True) surf.knotvector_v = generate(surf.degree_v,surf.ctrlpts_size_v,clamped=False) print(surf.knotvector_u) surf.evaluate( start_u = surf.knotvector_u[surf.degree_u], stop_u = surf.knotvector_u[surf.ctrlpts_size_u], start_v = surf.knotvector_v[surf.degree_v], stop_v = surf.knotvector_v[surf.ctrlpts_size_v]) # Set evaluation delta (control the number of surface points) surf.delta = 0.05 # Get surface points (the surface will be automatically evaluated) surface_points = surf.evalpts
def make_surface(self, face, degree_u, degree_v, vertices, planes, vert_weights, tangent_weights, face_weight, edge_weights_dict, edge_planes_dict): """ V0 ------ [E01] --- [E0C] --- [E02] --- V1 | | | | | | | | | | | | | | | [E11] --- [F1] ---- [E0F] --- [F2] --- [E21] | | | | | | | | | | | | | | | [E1C] --- [E1F] --- [CC] --- [E2F] --- [E2C] | | | | | | | | | | | | | | | [E12] --- [F3] ---- [E3F] --- [F4] --- [E22] | | | | | | | | | | | | | | | V3 ------ [E31] --- [E3C] --- [E32] --- V2 """ tangent_weights = [w / 3.0 for w in tangent_weights] vertices = [Vector(v) for v in vertices] def mk_edge_point(i, j): return (vertices[j] - vertices[i]) * tangent_weights[i] + vertices[i] def mk_face_corner_point(i, j, k): dv1 = (vertices[j] - vertices[i]) * tangent_weights[i] dv2 = (vertices[k] - vertices[i]) * tangent_weights[i] #m = face_weight return planes[i].projection_of_point(vertices[i] + dv1 + dv2) # edge planes e0p = edge_planes_dict[(face[0], face[1])] e1p = edge_planes_dict[(face[0], face[3])] e2p = edge_planes_dict[(face[1], face[2])] e3p = edge_planes_dict[(face[2], face[3])] def mk_edge_center_point(ep1, ep2): return (ep1 + ep2) / 2.0 def mk_face_edge_point(edge_plane, edge_point, edge_vec, vec1, vec2): length = (vec1.length + vec2.length) / 2.0 vec = edge_plane.normal.cross(edge_vec) #print("EV: %s, N: %s, L: %s, Res: %s" % (edge_vec, edge_plane.normal, length, vec)) vec = length * vec.normalized() return edge_point + vec e01 = planes[0].projection_of_point(mk_edge_point(0, 1)) e02 = planes[1].projection_of_point(mk_edge_point(1, 0)) e11 = planes[0].projection_of_point(mk_edge_point(0, 3)) e21 = planes[1].projection_of_point(mk_edge_point(1, 2)) f1 = mk_face_corner_point(0, 1, 3) f2 = mk_face_corner_point(1, 0, 2) e12 = planes[3].projection_of_point(mk_edge_point(3, 0)) e31 = planes[3].projection_of_point(mk_edge_point(3, 2)) e32 = planes[2].projection_of_point(mk_edge_point(2, 3)) e22 = planes[2].projection_of_point(mk_edge_point(2, 1)) f3 = mk_face_corner_point(3, 0, 2) f4 = mk_face_corner_point(2, 3, 1) e0c = mk_edge_center_point(e01, e02) e1c = mk_edge_center_point(e11, e12) e2c = mk_edge_center_point(e21, e22) e3c = mk_edge_center_point(e31, e32) e0f = mk_face_edge_point(e0p, e0c, (vertices[1] - vertices[0]), (f1 - e01), (f2 - e02)) e1f = mk_face_edge_point(e1p, e1c, (vertices[0] - vertices[3]), (f3 - e12), (f1 - e11)) e2f = mk_face_edge_point(e2p, e2c, (vertices[2] - vertices[1]), (f2 - e21), (f4 - e22)) e3f = mk_face_edge_point(e3p, e3c, (vertices[3] - vertices[2]), (f3 - e31), (f4 - e32)) cc = center([f1, e0f, f2, e2f, f4, e3f, f3, e1f]) control_points = [ vertices[0], e01, e0c, e02, vertices[1], e11, f1, e0f, f2, e21, e1c, e1f, cc, e2f, e2c, e12, f3, e3f, f4, e22, vertices[3], e31, e3c, e32, vertices[2] ] # edge point weights e0w = edge_weights_dict[(face[0], face[1])] e1w = edge_weights_dict[(face[0], face[3])] e2w = edge_weights_dict[(face[1], face[2])] e3w = edge_weights_dict[(face[2], face[3])] weights = [ vert_weights[0], e0w, e0w, e0w, vert_weights[1], e1w, face_weight, face_weight, face_weight, e2w, e1w, face_weight, face_weight, face_weight, e2w, e1w, face_weight, face_weight, face_weight, e2w, vert_weights[3], e3w, e3w, e3w, vert_weights[2] ] surface = NURBS.Surface() surface.degree_u = degree_u surface.degree_v = degree_v surface.ctrlpts_size_u = 5 surface.ctrlpts_size_v = 5 surface.ctrlpts = control_points surface.weights = weights surface.knotvector_u = knotvector.generate(surface.degree_u, 5) surface.knotvector_v = knotvector.generate(surface.degree_v, 5) new_surf = SvExGeomdlSurface(surface) return new_surf, control_points, weights
def process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['ControlPoints'].sv_get() has_weights = self.inputs['Weights'].is_linked weights_s = self.inputs['Weights'].sv_get(default = [[1.0]]) knots_s = self.inputs['Knots'].sv_get(default = [[]]) degree_s = self.inputs['Degree'].sv_get() curves_out = [] knots_out = [] for vertices, weights, knots, degree in zip_long_repeat(vertices_s, weights_s, knots_s, degree_s): if isinstance(degree, (tuple, list)): degree = degree[0] n_source = len(vertices) fullList(weights, n_source) if self.knot_mode == 'AUTO' and self.is_cyclic: vertices = vertices + vertices[:degree+1] weights = weights + weights[:degree+1] n_total = len(vertices) # Create a 3-dimensional B-spline Curve if self.surface_mode == 'NURBS': curve = NURBS.Curve(normalize_kv = self.normalize_knots) else: curve = BSpline.Curve(normalize_kv = self.normalize_knots) # Set degree curve.degree = degree # Set control points (weights vector will be 1 by default) # Use curve.ctrlptsw is if you are using homogeneous points as Pw curve.ctrlpts = vertices if has_weights and self.surface_mode == 'NURBS': curve.weights = weights # Set knot vector if self.knot_mode == 'AUTO': if self.is_cyclic: self.debug("N: %s, degree: %s", n_total, degree) knots = list(range(n_total + degree + 1)) else: knots = knotvector.generate(curve.degree, n_total) self.debug('Auto knots: %s', knots) curve.knotvector = knots else: self.debug('Manual knots: %s', knots) #if not knotvector.check(curve.degree, knots, len(curve.ctrlpts)): # raise Exception("Explicitly provided knot vector is incorrect!") curve.knotvector = knots new_curve = SvExGeomdlCurve(curve) if self.is_cyclic: u_min = curve.knotvector[degree] u_max = curve.knotvector[-degree-2] new_curve.u_bounds = u_min, u_max else: u_min = min(curve.knotvector) u_max = max(curve.knotvector) new_curve.u_bounds = (u_min, u_max) curves_out.append(new_curve) knots_out.append(curve.knotvector) self.outputs['Curve'].sv_set(curves_out) self.outputs['Knots'].sv_set(knots_out)
from geomdl import BSpline from geomdl import multi from geomdl import knotvector # Create the curve instance #1 crv1 = BSpline.Curve() # Set degree crv1.degree = 2 # Set control points crv1.ctrlpts = [[1, 0, 0], [1, 1, 0], [0, 1, 0]] # Generate a uniform knot vector crv1.knotvector = knotvector.generate(crv1.degree, crv1.ctrlpts_size) # Create the curve instance #2 crv2 = BSpline.Curve() # Set degree crv2.degree = 3 # Set control points crv2.ctrlpts = [[1, 0, 0], [1, 1, 0], [2, 1, 0], [1, 1, 0]] # Generate a uniform knot vector crv2.knotvector = knotvector.generate(crv2.degree, crv2.ctrlpts_size) # Create a curve container mcrv = multi.CurveContainer(crv1, crv2)
from geomdl import BSpline from geomdl.knotvector import generate import geomdl.visualization.VisMPL as VisMPL # Create a 3-dimensional B-spline Curve curve = BSpline.Curve() # Set degree curve.degree = 3 # Set control points curve.ctrlpts = [[1, 2], [1, 0], [0, -3], [3, 2]] curve.ctrlpts.extend([curve.ctrlpts[i] for i in range(curve.degree)]) print(curve.ctrlpts) # Set knot vector #curve.knotvector = [0, 0, 0, 0, 1, 1, 1, 1] curve.knotvector = generate(curve.degree, len(curve.ctrlpts), clamped=False) # Set evaluation delta (controls the number of curve points) curve.delta = 0.01 # Get curve points (the curve will be automatically evaluated) curve_points = curve.evalpts curve.vis = VisMPL.VisCurve2D() curve.render()
def test_check_knot_vector4(): degree = 4 num_ctrlpts = 12 autogen_kv = knotvector.generate(degree, num_ctrlpts) check_result = knotvector.check(degree=degree, num_ctrlpts=num_ctrlpts, knot_vector=autogen_kv) assert check_result
surf1.knotvector = ((0, 0, 1, 1), (0, 0, 1, 1)) # Create another surface from the initial one (surface 2) surf2 = operations.rotate(surf1, 90, axis=1) operations.translate(surf2, (0.5, 0, 1), inplace=True) # Create another surface from the initial one (surface 3) surf3 = operations.rotate(surf1, 45, axis=0) operations.translate(surf3, (1, 0.25, 0.5), inplace=True) # Create trim curves trim1 = BSpline.Curve() trim1.degree = 1 trim1.ctrlpts = ((1, 0), (0.95, 0.5), (1, 1), (0, 1), (0.05, 0.5), (0, 0), (1, 0)) trim1.knotvector = knotvector.generate(trim1.degree, trim1.ctrlpts_size) trim1.delta = 0.001 trim1.opt = ['reversed', 1] # operations.scale(trim1, 0.5, inplace=True) trim2 = deepcopy(trim1) trim2.opt = ['reversed', 0] # Add trim to surface 1 surf1.trims = [trim1] # Add trim to surface 3 surf3.trims = [trim2] # Visualize all surfaces mult = multi.SurfaceContainer(surf1, surf2, surf3)