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)
