def test_bspline_surface_loadsave():
surf_save = BSpline.Surface()
surf_save.degree_u = S_DEGREE_U
surf_save.degree_v = S_DEGREE_V
surf_save.ctrlpts_size_u = 3
surf_save.ctrlpts_size_v = 3
surf_save.ctrlpts = S_CTRLPTS
surf_save.knotvector_u = S_KV_U
surf_save.knotvector_v = S_KV_V
surf_save.save(FILE_NAME)
surf_load = BSpline.Surface()
surf_load.load(FILE_NAME)
# Remove save file
os.remove(FILE_NAME)
assert surf_save.degree_u == surf_load.degree_u
assert surf_save.degree_v == surf_load.degree_v
assert surf_save.knotvector_u == surf_load.knotvector_u
assert surf_save.knotvector_v == surf_load.knotvector_v
assert surf_save.ctrlpts == surf_load.ctrlpts
assert surf_save.ctrlpts_size_u == surf_load.ctrlpts_size_u
assert surf_save.ctrlpts_size_v == surf_load.ctrlpts_size_v
assert surf_save.dimension == surf_load.dimension
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 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 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 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 spline_surf():
""" Creates a B-spline surface instance """
# Create a surface instance
surf = BSpline.Surface()
# Set degrees
surf.degree_u = 3
surf.degree_v = 3
ctrlpts = [[-25.0, -25.0, -10.0], [-25.0, -15.0, -5.0], [-25.0, -5.0, 0.0],
[-25.0, 5.0, 0.0], [-25.0, 15.0, -5.0], [-25.0, 25.0, -10.0],
[-15.0, -25.0, -8.0], [-15.0, -15.0, -4.0], [-15.0, -5.0, -4.0],
[-15.0, 5.0, -4.0], [-15.0, 15.0, -4.0], [-15.0, 25.0, -8.0],
[-5.0, -25.0, -5.0], [-5.0, -15.0, -3.0], [-5.0, -5.0, -8.0],
[-5.0, 5.0, -8.0], [-5.0, 15.0, -3.0], [-5.0, 25.0, -5.0],
[5.0, -25.0, -3.0], [5.0, -15.0, -2.0], [5.0, -5.0, -8.0],
[5.0, 5.0, -8.0], [5.0, 15.0, -2.0], [5.0, 25.0, -3.0],
[15.0, -25.0, -8.0], [15.0, -15.0, -4.0], [15.0, -5.0, -4.0],
[15.0, 5.0, -4.0], [15.0, 15.0, -4.0], [15.0, 25.0, -8.0],
[25.0, -25.0, -10.0], [25.0, -15.0, -5.0], [25.0, -5.0, 2.0],
[25.0, 5.0, 2.0], [25.0, 15.0, -5.0], [25.0, 25.0, -10.0]]
# Set control points
surf.set_ctrlpts(ctrlpts, 6, 6)
# Set knot vectors
surf.knotvector_u = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0]
surf.knotvector_v = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0]
return surf
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 test_convert_surface():
surf_bs = BSpline.Surface()
surf_bs.degree_u = S_DEGREE_U
surf_bs.degree_v = S_DEGREE_V
surf_bs.ctrlpts_size_u = 3
surf_bs.ctrlpts_size_v = 3
surf_bs.ctrlpts = S_CTRLPTS
surf_bs.knotvector_u = S_KV_U
surf_bs.knotvector_v = S_KV_V
surf_nurbs = convert.bspline_to_nurbs(surf_bs)
surf_nurbs.sample_size = SAMPLE_SIZE
# Expected weights vector
res_weights = [1.0 for _ in range(3*3)]
# Expected output
res = [[0.0, 0.0, 0.0], [0.0, 0.5, -0.1875], [0.0, 1.0, -0.75], [0.0, 1.5, -1.6875],
[0.0, 2.0, -3.0], [0.5, 0.0, 2.25], [0.5, 0.5, 1.171875], [0.5, 1.0, 0.1875],
[0.5, 1.5, -0.703125], [0.5, 2.0, -1.5], [1.0, 0.0, 3.0], [1.0, 0.5, 1.6875],
[1.0, 1.0, 0.75], [1.0, 1.5, 0.1875], [1.0, 2.0, 0.0], [1.5, 0.0, 2.25],
[1.5, 0.5, 1.359375], [1.5, 1.0, 0.9375], [1.5, 1.5, 0.984375], [1.5, 2.0, 1.5],
[2.0, 0.0, 0.0], [2.0, 0.5, 0.1875], [2.0, 1.0, 0.75], [2.0, 1.5, 1.6875], [2.0, 2.0, 3.0]]
assert not surf_bs.rational
assert surf_nurbs.rational
assert surf_nurbs.evalpts == res
assert surf_nurbs.weights == res_weights
def build_geomdl(cls,
degree_u,
degree_v,
knotvector_u,
knotvector_v,
control_points,
weights,
normalize_knots=False):
def convert_row(verts_row, weights_row):
return [(x * w, y * w, z * w, w)
for (x, y, z), w in zip(verts_row, weights_row)]
if weights is None:
surf = BSpline.Surface(normalize_kv=normalize_knots)
else:
surf = NURBS.Surface(normalize_kv=normalize_knots)
surf.degree_u = degree_u
surf.degree_v = degree_v
if weights is None:
ctrlpts = control_points
else:
ctrlpts = list(map(convert_row, control_points, weights))
surf.ctrlpts2d = ctrlpts
surf.knotvector_u = knotvector_u
surf.knotvector_v = knotvector_v
result = SvGeomdlSurface(surf)
result.u_bounds = surf.knotvector_u[0], surf.knotvector_u[-1]
result.v_bounds = surf.knotvector_v[0], surf.knotvector_v[-1]
return result
def surface_fit(self, terrain_grid: np.ndarray, grid_resolution: int,
u_degree: int, v_degree: int, delta: float):
# Create a BSpline surface instance
surf = BSpline.Surface()
# Set evaluation delta
surf.delta = delta
# Set up the surface
surf.degree_u = u_degree
surf.degree_v = v_degree
control_points = terrain_grid.tolist()
surf.set_ctrlpts(control_points, grid_resolution, grid_resolution)
surf.knotvector_u = utilities.generate_knot_vector(
surf.degree_u, grid_resolution)
surf.knotvector_v = utilities.generate_knot_vector(
surf.degree_v, grid_resolution)
# Evaluate surface points
surf.evaluate()
return surf
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 main():
# Fix file path
os.chdir(os.path.dirname(os.path.realpath(__file__)))
# Create a BSpline surface instance
surf = BSpline.Surface()
# Set degrees
surf.degree_u = 3
surf.degree_v = 3
# Set control points
surf.set_ctrlpts(
*exchange.import_txt("ex_surface01.cpt", two_dimensional=True))
# Set knot vectors
surf.knotvector_u = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
surf.knotvector_v = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
# Set evaluation delta
surf.delta = 0.025
# Evaluate surface points
surf.evaluate()
# Import and use Matplotlib's colormaps
from matplotlib import cm
# Plot the control point grid and the evaluated surface
vis_comp = vis.VisSurface()
surf.vis = vis_comp
surf.render(colormap=cm.cool)
# Good to have something here to put a breakpoint
pass
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 bspline_surface():
""" Creates a B-Spline surface instance """
# Create a surface instance
surf = BSpline.Surface()
# Set degrees
surf.degree_u = 3
surf.degree_v = 3
# Set control points
surf.ctrlpts_size_u = 6
surf.ctrlpts_size_v = 6
surf.ctrlpts = [[-25.0, -25.0, -10.0], [-25.0, -15.0, -5.0], [-25.0, -5.0, 0.0], [-25.0, 5.0, 0.0],
[-25.0, 15.0, -5.0], [-25.0, 25.0, -10.0], [-15.0, -25.0, -8.0], [-15.0, -15.0, -4.0],
[-15.0, -5.0, -4.0], [-15.0, 5.0, -4.0], [-15.0, 15.0, -4.0], [-15.0, 25.0, -8.0],
[-5.0, -25.0, -5.0], [-5.0, -15.0, -3.0], [-5.0, -5.0, -8.0], [-5.0, 5.0, -8.0],
[-5.0, 15.0, -3.0], [-5.0, 25.0, -5.0], [5.0, -25.0, -3.0], [5.0, -15.0, -2.0],
[5.0, -5.0, -8.0], [5.0, 5.0, -8.0], [5.0, 15.0, -2.0], [5.0, 25.0, -3.0],
[15.0, -25.0, -8.0], [15.0, -15.0, -4.0], [15.0, -5.0, -4.0], [15.0, 5.0, -4.0],
[15.0, 15.0, -4.0], [15.0, 25.0, -8.0], [25.0, -25.0, -10.0], [25.0, -15.0, -5.0],
[25.0, -5.0, 2.0], [25.0, 5.0, 2.0], [25.0, 15.0, -5.0], [25.0, 25.0, -10.0]]
# Set knot vectors
surf.knotvector_u = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0]
surf.knotvector_v = [0.0, 0.0, 0.0, 0.0, 0.33, 0.66, 1.0, 1.0, 1.0, 1.0]
# Set sample size
surf.sample_size = SAMPLE_SIZE
# Return the instance
return surf
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 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 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 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 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 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 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 bs_surface2():
surf = BSpline.Surface()
ctrlpts = [[1.0, 1.0, 10.0], [1.0, 2.0, 11.0], [1.0, 3.0, 12.0],
[2.0, 1.0, 13.0], [2.0, 2.0, 14.0], [2.0, 3.0, 15.0],
[3.0, 1.0, 16.0], [3.0, 2.0, 17.0], [3.0, 3.0, 18.0],
[4.0, 1.0, 19.0], [4.0, 2.0, 20.0], [4.0, 3.0, 21.0]]
surf.ctrlpts_size_v = 3
surf.ctrlpts_size_u = 4
surf.degree_u = 2
surf.degree_v = 2
surf.ctrlpts = ctrlpts
return surf
def bspline_surface():
""" Creates a B-Spline surface instance """
surf = BSpline.Surface()
surf.degree_u = 2
surf.degree_v = 2
surf.ctrlpts_size_u = 3
surf.ctrlpts_size_v = 3
surf.ctrlpts = [[0, 0, 0], [0, 1, 0], [0, 2, -3], [1, 0, 6], [1, 1, 0],
[1, 2, 0], [2, 0, 0], [2, 1, 0], [2, 2, 3]]
surf.knotvector_u = [0, 0, 0, 1, 1, 1]
surf.knotvector_v = [0, 0, 0, 1, 1, 1]
return surf
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)
