def plot(self): myplot = bp.Plotting((bp.PlottingPlotly())) myplot.plot_surface_3d(self.surfapprox.surfz, poles=False) myplot.plot_surface_3d(self.surfapprox2.surfz, poles=False) #myplot.scatter_3d(X, Y, Z) myplot.show() # view
def test_surface_intersection(self): control_points = [60, 60] sapp = SurfApprox(control_points) app = sapp.approx myplot = bp.Plotting((bp.PlottingPlotly())) myplot.plot_surface_3d(sapp.surfz, poles=False) #myplot.scatter_3d(app._xy_points[:, 0], app._xy_points[:, 1], app._z_points) myplot.show() # view
def plot_cmp(a_grid, b_grid): plt = bs_plot.Plotting() plt.scatter_3d(a_grid[:, :, 0], a_grid[:, :, 1], a_grid[:, :, 2]) plt.scatter_3d(b_grid[:, :, 0], b_grid[:, :, 1], b_grid[:, :, 2]) plt.show() diff = b_grid - a_grid plt.scatter_3d(a_grid[:, :, 0], a_grid[:, :, 1], diff[:, :, 0]) plt.scatter_3d(a_grid[:, :, 0], a_grid[:, :, 1], diff[:, :, 1]) plt.scatter_3d(a_grid[:, :, 0], a_grid[:, :, 1], diff[:, :, 2]) plt.show()
def verify_approximation(func, surf): # Verification. # Evaluate approximation and the function on the same grid. nu = 4 * surf.u_basis.size nv = 4 * surf.v_basis.size V_grid, U_grid = np.meshgrid(np.linspace(0.0, 1.0, nu), np.linspace(0.0, 1.0, nv)) xy_probe = np.stack([U_grid.ravel(), V_grid.ravel()], axis=1) # xyz_approx = surf.eval_xy_array(xy_probe).reshape(-1, 3) # z_func_eval = np.array([func([u, v]) for u, v in xy_probe], dtype=float) xyz_func = np.concatenate((xy_probe, z_func_eval[:, None]), axis=1).reshape(-1, 3) #plot_cmp(xyz_approx, xyz_func) plt = bs_plot.Plotting() plt.plot_surface_3d(surf.make_full_surface(), (nu, nv), poles=False) plt.scatter_3d(xyz_func[:,0], xyz_func[:,1], xyz_func[:,2]) plt.show()
def test_surface_intersection(plane_coefficients1, control_points_1, length1): #plane_coefficients1 print(plane_coefficients1, control_points_1, length1) #plane_coefficients1 = np.array([-1, 1, -1, 7]) plane_coefficients2 = np.array([2, -1, -1, 3]) def cosx(x): return math.cos(3 * x) length2 = [5, 7] control_points_2 = [10, 11] samples = [200, 200] sapp2 = SurfApprox(plane_coefficients2, length2, samples, control_points_2, cosx) myplot = bp.Plotting((bp.PlottingPlotly())) myplot.plot_surface_3d(sapp2.surfz, poles=False) myplot.show() # view
def test_hull_and_box(self): points = np.random.randn(1000000, 2) print() start = time.perf_counter() for i in range(1): hull = bs_approx.convex_hull_2d(points) end = time.perf_counter() print("\nConvex hull of 1M points: {} s".format(end - start)) start = time.perf_counter() for i in range(10): quad = bs_approx.min_bounding_rect(hull) end = time.perf_counter() print("Min area bounding box: {} s".format(end - start)) return plt = bs_plot.Plotting() plt.scatter_2d(points[:, 0], points[:, 1]) plt.plot_2d(hull[:, 0], hull[:, 1]) box_lines = np.concatenate((quad, quad[0:1, :]), axis=0) plt.plot_2d(box_lines[:, 0], box_lines[:, 1]) plt.show()
from bgem.bspline import bspline as bs, bspline_plot as bp import numpy as np import math import matplotlib.pyplot as plt plotting = bp.Plotting() #plotting = bp.Plotting(bp.PlottingMatplot()) class TestSplineBasis: def test_find_knot_interval(self): """ test methods: - make_equidistant - find_knot_interval """ eq_basis = bs.SplineBasis.make_equidistant(2, 100) assert eq_basis.find_knot_interval(0.0) == 0 assert eq_basis.find_knot_interval(0.001) == 0 assert eq_basis.find_knot_interval(0.01) == 1 assert eq_basis.find_knot_interval(0.011) == 1 assert eq_basis.find_knot_interval(0.5001) == 50 assert eq_basis.find_knot_interval(1.0 - 0.011) == 98 assert eq_basis.find_knot_interval(1.0 - 0.01) == 99 assert eq_basis.find_knot_interval(1.0 - 0.001) == 99 assert eq_basis.find_knot_interval(1.0) == 99 knots = np.array([ 0, 0, 0, 0.1880192, 0.24545785, 0.51219762, 0.82239001, 1., 1., 1. ])
def test_plot_3d(self): self.plotting_3d(bp.Plotting(bp.PlottingMatplot())) self.plotting_3d(bp.Plotting(bp.PlottingPlotly()))
def plot_extrude(self): #fig1 = plt.figure() #ax1 = fig1.gca(projection='3d') def function(x): return math.sin(x[0]*4) * math.cos(x[1] * 4) def function2(x): return math.cos(x[0]*4) * math.sin(x[1] * 4) def function3(x): return (-x[0] + x[1] + 4 + 3 + math.cos(3 * x[0])) def function4(x): return (2 * x[0] - x[1] + 3 + math.cos(3 * x[0])) u1_int = 4 v1_int = 4 u2_int = 4 v2_int = 4 u_basis = bs.SplineBasis.make_equidistant(2, u1_int) #10 v_basis = bs.SplineBasis.make_equidistant(2, v1_int) #15 u2_basis = bs.SplineBasis.make_equidistant(2, u2_int) #10 v2_basis = bs.SplineBasis.make_equidistant(2, v2_int) #15 poles = bs.make_function_grid(function, u1_int + 2, v1_int + 2) #12, 17 surface_extrude = bs.Surface((u_basis, v_basis), poles) myplot = bp.Plotting((bp.PlottingPlotly())) #myplot.plot_surface_3d(surface_extrude, poles = False) poles2 = bs.make_function_grid(function2, u2_int + 2, v2_int + 2) #12, 17 surface_extrude2 = bs.Surface((u2_basis, v2_basis), poles2) #myplot.plot_surface_3d(surface_extrude2, poles=False) m = 100 fc = np.zeros([m * m, 3]) fc2 = np.empty([m * m, 3]) a = 5 b = 7 #print(fc) for i in range(m): for j in range(m): #print([i,j]) x = i / m * a y = j / m * b z = function3([x, y]) z2 = function4([x, y]) fc[i + j * m, :] = [x, y, z] fc2[i + j * m, :] = [x, y, z2] #print(fc) #gs = bs.GridSurface(fc.reshape(-1, 3)) #gs.transform(xy_mat, z_mat) #approx = bsa.SurfaceApprox.approx_from_grid_surface(gs) approx = bsa.SurfaceApprox(fc) approx2 = bsa.SurfaceApprox(fc2) surfz = approx.compute_approximation(nuv=np.array([11, 26])) surfz2 = approx2.compute_approximation(nuv=np.array([20, 16])) #surfz = approx.compute_approximation(nuv=np.array([3, 5])) #surfz2 = approx2.compute_approximation(nuv=np.array([2, 4])) surfzf = surfz.make_full_surface() surfzf2 = surfz2.make_full_surface() myplot.plot_surface_3d(surfzf, poles=False) myplot.plot_surface_3d(surfzf2, poles=False) #return surface_extrude, surface_extrude2, myplot return surfzf, surfzf2, myplot