def sinusoidal_cylinder(): N = 11 M = 2 eps = 0.1 # eps2 = 0.1 z = np.linspace(0, 1, N) theta = np.linspace(0, 1, N) # ED configuration rho_ed = 30 h_ed = 80 r_ed = [] drdt_ed = [] drdz_ed = [] # Deformed Configuration rho_es = 20 h_es = 60 r_es = [] drdt_es = [] drdz_es = [] # eps2*np.sin( 2 * np.pi * theta[j] ) ) for i in range(0, len(z)): for j in range(0, len(theta)): cylinder_ed = Cylinder( rho_ed * ((1 + eps * np.sin(M * 2 * np.pi * z[i]))), h_ed, theta[j], z[i]) r_ed.append(cylinder_ed.cylinder2cart()) drdt_ed.append(cylinder_ed.partial_theta()) drdz_ed.append(cylinder_ed.partial_z_sin(M, eps)) cylinder_es = Cylinder( rho_es * ((1 + eps * np.sin(M * 2 * np.pi * z[i]))), h_es, theta[j], z[i]) r_es.append(cylinder_es.cylinder2cart()) drdt_es.append(cylinder_es.partial_theta()) drdz_es.append(cylinder_es.partial_z_sin(M, eps)) pts_ed = r_ed pts_es = r_es size_u = N size_v = N degree_u = 3 degree_v = 3 # Do global surface approximation surf_ed = fitting.approximate_surface(pts_ed, size_u, size_v, degree_u, degree_v) surf_ed = convert.bspline_to_nurbs(surf_ed) # Do global surface approximation surf_es = fitting.approximate_surface(pts_es, size_u, size_v, degree_u, degree_v) surf_es = convert.bspline_to_nurbs(surf_es) return surf_ed, surf_es, drdt_ed, drdz_ed, drdt_es, drdz_es
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 fit_Standard_RV(N, M, sampled_data): # set up the fitting parameters p_ctrlpts = sampled_data size_u = M + 1 size_v = N + 1 degree_u = 3 degree_v = 3 # Do global surface approximation standard_RV_NURBS_surf = fitting.interpolate_surface( p_ctrlpts, size_u, size_v, degree_u, degree_v) standard_RV_NURBS_surf = convert.bspline_to_nurbs(standard_RV_NURBS_surf) return standard_RV_NURBS_surf
def set_curves(self): degree = 2 num_cp = 2 CP, U = F.curve_fit2D(self.points, np.ones((len(self.points), 1)), None, None, None, num_cp, degree) B_cur = BSpline.Curve() B_cur.degree = degree B_cur.ctrlpts = CP B_cur.knotvector = U B_cur.evaluate() B_cur.delta = 0.01 N_cur = convert.bspline_to_nurbs(B_cur) # Set evaluation delta N_cur.delta = 0.01 N_cur.evaluate() return N_cur, B_cur
def test_convert_curve(): curve_bs = BSpline.Curve() curve_bs.degree = C_DEGREE curve_bs.ctrlpts = C_CTRLPTS curve_bs.knotvector = C_KV curve_bs.sample_size = SAMPLE_SIZE curve_nurbs = convert.bspline_to_nurbs(curve_bs) curve_nurbs.sample_size = SAMPLE_SIZE # Expected weights vector res_weights = [1.0 for _ in range(len(C_CTRLPTS))] # Expected evaluation result 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 not curve_bs.rational assert curve_nurbs.rational assert curve_nurbs.evalpts == res assert curve_nurbs.weights == res_weights
def nurbs_surf(spline_surf): surf = convert.bspline_to_nurbs(spline_surf) return surf
fig = plt.figure(dpi = 175) ax = plt.axes(projection = '3d') plt.style.use('dark_background') ax.scatter(toroid[:,0],toroid[:,1],toroid[:,2], color = 'blue',marker = 'o') ax.plot(caxis[:,0],caxis[:,1],caxis[:,2],color = 'red') ax.axis("off") p_ctrlpts = toroid size_u = N size_v = N degree_u = 3 degree_v = 3 # Do global surface approximation surf = fitting.approximate_surface(p_ctrlpts, size_u, size_v, degree_u, degree_v) surf = convert.bspline_to_nurbs(surf) # Extract curves from the approximated surface surf_curves = construct.extract_curves(surf) plot_extras = [ dict( points=surf_curves['u'][0].evalpts, name="u", color="red", size=10 ), dict( points=surf_curves['v'][0].evalpts, name="v", color="black", size=10
caxis = np.array(caxis) caxis_def = np.array(caxis_def) p_ctrlpts = toroid size_u = N size_v = N degree_u = 3 degree_v = 3 # Do global surface approximation surf = fitting.approximate_surface(p_ctrlpts, size_u, size_v, degree_u, degree_v) surf_def = fitting.approximate_surface(toroid_def, size_u, size_v, degree_u, degree_v) surf = convert.bspline_to_nurbs(surf) surf_def = convert.bspline_to_nurbs(surf_def) # toroid_pcl = np.array(surf.evalpts) # toroid_cpts = np.array(surf.ctrlpts) uv = np.linspace(0, 1, N) nurbs_fit_G = compute_metric_tensor(surf, uv) nurbs_fit_G_def = compute_metric_tensor(surf_def, uv) E = [] F = 0 * np.ones((len(uv))) G = [] E_def = [] G_def = [] for i in range(0, len(uv)): E.append((R + r * np.cos(2 * np.pi * uv[i]))**2)
def nurbs_curve(spline_curve): curve = convert.bspline_to_nurbs(spline_curve) curve.weights = [0.5, 1.0, 0.75, 1.0, 0.25, 1.0] return curve
cylinder_es = Cylinder(R_es,h_es,theta[j],z[i]) r_es.append(cylinder_es.cylinder2cart()) drdt_es.append(cylinder_es.partial_theta()) drdz_es.append(cylinder_es.partial_z()) # print(len(drdt_ed)) pts_ed = r_ed size_u = 20 size_v = 20 degree_u = 3 degree_v = 3 # Do global surface approximation surf_ed = fitting.approximate_surface(pts_ed, size_u, size_v, degree_u, degree_v) surf_ed = convert.bspline_to_nurbs(surf_ed) surf_ed.delta = 0.025 surf_ed.vis = vis.VisSurface() evalpts_ed = np.array(surf_ed.evalpts) pts_es = r_es # Do global surface approximation surf_es = fitting.approximate_surface(pts_es, size_u, size_v, degree_u, degree_v) surf_es = convert.bspline_to_nurbs(surf_es) surf_es.delta = 0.025 surf_es.vis = vis.VisSurface() evalpts_es = np.array(surf_es.evalpts)
def fit_StandardRV(): # load data rm_file = "N2_RV_P4_rm" points = np.loadtxt(rm_file + ".csv", delimiter=',') # split data into slices N = 15 slice(N, points) slices = [] temp = [] layers = [] bins = slice.bins for j in range(0, len(slice.slices)): temp.append( cylinder(slice.slices[j][:, 0], slice.slices[j][:, 1], bins[j] * np.ones(len(slice.slices[j][:, 2])))) temp = np.array(temp) # store all slices into layers array for i in range(0, len(temp)): for j in range(0, len(temp[i][0])): layers.append( [temp[:, 0][i][j], temp[:, 1][i][j], temp[:, 2][i][j]]) # segment the layers into angled segments layers = np.array(layers) M = N segments = split_into_angles(M, layers) # find average points at each segment and slice temp1 = [] data = [] # fig = plt.figure() # ax = plt.axes(projection= "3d") segment = [] for i in range(0, len(segments)): segment.append( np.array([segments[i][0], segments[i][1], segments[i][2]]).T) for j in range(0, len(bins)): temp1.append(segment[i][segment[i][:, 2] == bins[j]]) chunks = np.array(temp1) # ax.scatter(chunks[0][:,0],chunks[0][:,1],chunks[0][:,2]) # fig = plt.figure() # ax = plt.axes(projection= "3d") # xbar = [] # ybar = [] # zbar = [] # for j in range(0,len(chunks)): # xbar.append(chunks[j][:,0].mean()) # ybar.append(chunks[j][:,1].mean()) # zbar.append(chunks[j][:,2].max()) # for i in range(0,(N+1)): # xbar.append(chunks[i][:,0].mean()) # ybar.append(chunks[i][:,1].mean()) # zbar.append(chunks[i][:,2].max()) # X = np.array([xbar,ybar,zbar]).T cylData = [] for j in range(0, len(chunks)): cylData.append( cylinder(chunks[j][:, 0], chunks[j][:, 1], chunks[j][:, 2])) cartData = [] for i in range(0, len(cylData)): cartData.append( cart(cylData[i][0].max(), cylData[i][1].max(), cylData[i][2].max())) for i in range(0, (N + 1)): cartData.append( cart(cylData[i][0].max(), cylData[i][1].max(), cylData[i][2].max())) X = np.array(cartData) test = [] # np.savetxt("sampled_"+ rm_file + ".csv",X,delimiter = ',') reg_file = "N2_RV_P0" xyz = np.loadtxt(reg_file + ".dat") xyz = preProcess(xyz) # X = np.loadtxt('sampled_' + reg_file + ".csv",delimiter = ',') # X = preProcess(X) # this orders the points from least to greatest height (z values) for i in range(0, len(bins)): test.append(X[X[:, 2] == bins[i]]) for j in range(0, len(test)): for ii in range(0, len(test[i])): data.append([test[j][ii][0], test[j][ii][1], test[j][ii][2]]) data = np.array(data) # ax.scatter(xbar,ybar,zbar) print(len(X)) # set up the fitting parameters p_ctrlpts = X size_u = N + 1 size_v = M + 1 degree_u = 3 degree_v = 3 # Do global surface approximation surf = fitting.interpolate_surface(p_ctrlpts, size_u, size_v, degree_u, degree_v) surf = convert.bspline_to_nurbs(surf) print("surf", type(surf)) # Extract curves from the approximated surface surf_curves = construct.extract_curves(surf) plot_extras = [ dict(points=surf_curves['u'][0].evalpts, name="u", color="red", size=10), dict(points=surf_curves['v'][0].evalpts, name="v", color="black", size=10) ] surf.delta = 0.025 # surf.vis = vis.VisSurface() # surf.render(extras=plot_extras) # exchange.export_obj(surf, rm_file + "_fit.obj") # exchange.export_obj(surf, reg_file + "_fit.obj") # visualize data samples, original RV data, and fitted surface eval_surf = np.array(surf.evalpts) # eval_surf = preProcess(eval_surf) # fig = plt.figure() # ax = plt.axes(projection="3d") # ax.scatter(eval_surf[:,0],eval_surf[:,1],eval_surf[:,2], color = 'r') # # ax.scatter3D(points[:, 0],points[:, 1],points[:, 2]) # ax.scatter3D(xyz[:, 0],xyz[:, 1],xyz[:, 2]) # ax.scatter(X[:,0],X[:,1],X[:,2]) # ax.scatter(X[:,0],X[:,1],X[:,2]) cpts = np.array(surf.ctrlpts) # np.savetxt('cpts_'+rm_file,cpts, delimiter = ' ') # np.savetxt('cpts_'+ reg_file + ".csv",cpts, delimiter = ',') # fig = plt.figure() # ax = plt.axes(projection = "3d") # ax.scatter(X[:,0],X[:,1],X[:,2]) # ax.scatter(cpts[:,0],cpts[:,1],cpts[:,2]) # plt.show() return surf
# 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) # Import Matplotlib visualization module from geomdl.visualization import VisMPL # Set the visualization component of the curve container mcrv.vis = VisMPL.VisCurve3D() # Plot the curves in the curve container mcrv.render() ''' Convert non-rational to rational curve Generates a B-Spline (non-rational) curve and converts it into a NURBS (rational) curve. ''' from geomdl import convert # Import convert module # B-Spline to NURBS crv_rat = convert.bspline_to_nurbs(crv)
def helix(): # create starting parameters for helix M = 20 t = np.linspace(0, 2 * np.pi / 3, M) a = 30 b = 30 s = [] C = a**2 + b**2 for i in range(0, len(t)): s.append(np.sqrt(C) * t[i]) r = [] T = [] N = [] B = [] for i in range(0, len(s)): # generate a helical axis first r.append([ a * np.cos(s[i] / np.sqrt(C)), a * np.sin(s[i] / np.sqrt(C)), b * s[i] / np.sqrt(C) ]) # create the tangential, normal, and binormal vectors T.append([ -a / np.sqrt(C) * np.sin(s[i] / np.sqrt(C)), a / np.sqrt(C) * np.cos(s[i] / np.sqrt(C)), b / np.sqrt(C) ]) N.append([-np.cos(s[i] / np.sqrt(C)), -np.sin(s[i] / np.sqrt(C)), 0]) B.append(np.cross(T, N)) # store them as numpy arrays for convenience r = np.array(r) Ts = np.array(T) Ns = np.array(N) Bs = np.array(B[0]) # scatter the T, N, and B vectors fig = plt.figure() ax = plt.axes(projection="3d") # these scatter points serves as a check to make sure that the T, N , B vectors work # ax.plot(r[:,0],r[:,1],r[:,2],color = 'r') # ax.scatter(r[5,0]+Ts[5,0],r[5,1]+Ts[5,1],r[5,2]+Ts[5,2],color = 'b') # ax.scatter(r[5,0],r[5,1],r[5,2],color = 'k') # ax.scatter(r[5,0]-Ts[5,0],r[5,1]-Ts[5,1],r[5,2]-Ts[5,2],color = 'g') # ax.scatter(Bs[:,0],Bs[:,1],Bs[:,2],color = 'g') # ax.scatter(Ns[:,0],Ns[:,1],Ns[:,2],color = 'b') helix = [] phi = np.linspace(0, 2 * np.pi, M) d = 10 for i in range(0, len(s)): for j in range(0, len(phi)): helix.append([ d * Bs[i, 0] * np.cos(phi[j]) + d * Ns[i, 0] * np.sin(phi[j]) + r[i, 0], d * Bs[i, 1] * np.cos(phi[j]) + d * Ns[i, 1] * np.sin(phi[j]) + r[i, 1], d * Bs[i, 2] * np.cos(phi[j]) + d * Ns[i, 2] * np.sin(phi[j]) + r[i, 2] ]) helix = np.array(helix) np.savetxt("helical_cylinder.csv", helix, delimiter=',') ax.scatter(helix[:, 0], helix[:, 1], helix[:, 2]) ax.set_title("Helical Tube Point Cloud") ax.set_xlabel('x') ax.set_ylabel('y') ax.set_zlabel('z') plt.show() p_ctrlpts = helix size_u = M size_v = M degree_u = 3 degree_v = 3 # Do global surface approximation surf = fitting.approximate_surface(p_ctrlpts, size_u, size_v, degree_u, degree_v) surf = convert.bspline_to_nurbs(surf) # Extract curves from the approximated surface surf_curves = construct.extract_curves(surf) plot_extras = [ dict(points=surf_curves['u'][0].evalpts, name="u", color="red", size=10), dict(points=surf_curves['v'][0].evalpts, name="v", color="black", size=10) ] tube_pcl = np.array(surf.evalpts) tube_cpts = np.array(surf.ctrlpts) # np.savetxt("cpts_bezier.dat",r,delimiter = ',') # from matplotlib import cm surf.delta = 0.02 surf.vis = vis.VisSurface() surf.render(extras=plot_extras) exchange.export_obj(surf, "helix.stl") np.savetxt("RV_tube.dat", tube_pcl, delimiter=' ') # np.savetxt("tube_cpts.dat",tube_cpts,delimiter = ' ') np.savetxt("tube_cpts.csv", tube_cpts, delimiter=',') # crv = BSpline.Curve() # crv.degree = 3 # crv.ctrlpts = exchange.import_txt("cpts_tube.dat") # crv.knotvector = knotvector.generate(crv.degree, crv.ctrlpts_size) # # Set the visualization component of the curve # crv.vis = vis.VisCurve3D() # # Plot the curve # crv.render() return surf