Example #1
0
    def test_basis_function(self):
        "Test basis functions values"
        v1s = []
        for t in self.ts:
            v1 = basis_function_one(self.degree, self.knotvector, self.span, t)
            v1s.append(v1)
        v1s = np.array(v1s)

        functions = SvNurbsBasisFunctions(self.knotvector)
        v2s = functions.function(self.span, self.degree)(self.ts)

        self.assert_numpy_arrays_equal(v1s, v2s, precision=8)
Example #2
0
    def test_basis_function_3436(self):
        "Test basis functions values outside of bounds"
        v1s = []
        ts = np.array([1.61803397])
        for t in ts:
            v1 = basis_function_one(self.degree, self.knotvector, self.span, t)
            v1s.append(v1)
        v1s = np.array(v1s)

        functions = SvNurbsBasisFunctions(self.knotvector)
        v2s = functions.function(self.span, self.degree)(ts)

        self.assert_numpy_arrays_equal(v1s, v2s, precision=8)
Example #3
0
def test_basis_function_one():
	degree = 2
	knot_vector = [0, 0, 0, 1, 2, 3, 4, 4, 5, 5, 5]
	span = 4
	knot = 5.0 / 2.0
	
	# Values from basis_function
	to_check = [helpers.basis_function_one(degree, knot_vector, span - _, knot) for _ in range(degree, -1, -1)]
	result = helpers.basis_function(degree, knot_vector, span, knot)

	assert abs(to_check[0] - result[0]) < GEOMDL_DELTA
	assert abs(to_check[1] - result[1]) < GEOMDL_DELTA
	assert abs(to_check[2] - result[2]) < GEOMDL_DELTA
Example #4
0
def test_basis_function_one():
    degree = 2
    knot_vector = [0, 0, 0, 1, 2, 3, 4, 4, 5, 5, 5]
    span = 4
    knot = 5.0 / 2.0

    # Values from basis_function
    to_check = [
        helpers.basis_function_one(degree, knot_vector, span - _, knot)
        for _ in range(degree, -1, -1)
    ]
    result = helpers.basis_function(degree, knot_vector, span, knot)

    assert abs(to_check[0] - result[0]) < GEOMDL_DELTA
    assert abs(to_check[1] - result[1]) < GEOMDL_DELTA
    assert abs(to_check[2] - result[2]) < GEOMDL_DELTA
def Basis_Function_Der(degree, knotvector, i, para, ordre):

    nb_control = len(knotvector) - degree - 1

    if (ordre == 0):
        return helpers.basis_function_one(degree, knotvector, i, para)

    if (ordre == 1):
        if (para == 1.0):
            return -helpers.basis_function_ders_one(
                degree, knotvector, nb_control - 1 - i, 0, ordre)[ordre]
        else:
            return helpers.basis_function_ders_one(degree, knotvector, i, para,
                                                   ordre)[ordre]

    if (ordre == 2):
        if (para == 1.0):
            return helpers.basis_function_ders_one(degree, knotvector,
                                                   nb_control - 1 - i, 0,
                                                   ordre)[ordre]
        else:
            return helpers.basis_function_ders_one(degree, knotvector, i, para,
                                                   ordre)[ordre]
Example #6
0
        radius[0] * math.cos(u) * math.cos(v),
        radius[1] * math.cos(v) * math.sin(u), radius[2] * math.sin(v)
    ] for u in np.linspace(0, 2 * math.pi, num=n_sp)
     for v in np.linspace(-math.pi / 2 + 0.01, math.pi / 2 - 0.01, num=n_sp)])
u = np.linspace(0, 1, n_sp)
v = np.linspace(0, 1, n_sp)

# fig = plt.figure()
# ax = Axes3D(fig)
# ax.plot(sp[:,0],sp[:,1],sp[:,2],'o',markersize=2)
# plt.show()

knot = generate(degree, n_cp)

A = np.array([[
    basis_function_one(degree, knot, k, u[i]) *
    basis_function_one(degree, knot, l, v[j]) for k in range(n_cp)
    for l in range(n_cp)
] for i in range(n_sp) for j in range(n_sp)])
print(A.shape)

invATA = np.linalg.inv(np.dot(A.T, A))
cp = np.dot(np.dot(invATA, A.T), sp).tolist()

print(cp)

surf = BSpline.Surface()
surf.degree_u = degree
surf.degree_v = degree

surf.set_ctrlpts(cp, n_cp, n_cp)
Example #7
0
n_cp = 10
radius_x = 5
radius_y = 10
n_sp = 100
degree = 3

sp = np.array([[radius_x * math.cos(t), radius_y * math.sin(t)]
               for t in np.linspace(0, 2 * math.pi, n_sp)])
t = np.linspace(0, 1, n_sp)

# plt.scatter(sp[:,0], sp[:,1])
# plt.show()

n_knot = n_cp + degree + 1
# knot = np.linspace(0,1, n_knot).tolist()
knot = generate(degree, n_cp)

A = np.array([[basis_function_one(degree, knot, j, t[i]) for j in range(n_cp)]
              for i in range(n_sp)])
print(A.shape)

invATA = np.linalg.inv(np.dot(A.T, A))
cp = np.dot(np.dot(invATA, A.T), sp).tolist()

crv = BSpline.Curve()
crv.degree = degree
crv.ctrlpts = cp

crv.knotvector = knot
crv.vis = VisMPL.VisCurve2D()
crv.render()