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 process(self): if not any(socket.is_linked for socket in self.outputs): return vertices_s = self.inputs['Vertices'].sv_get() u_size_s = self.inputs['USize'].sv_get() degree_u_s = self.inputs['DegreeU'].sv_get() degree_v_s = self.inputs['DegreeV'].sv_get() points_cnt_u_s = self.inputs['PointsCntU'].sv_get() points_cnt_v_s = self.inputs['PointsCntV'].sv_get() if self.input_mode == '1D': vertices_s = ensure_nesting_level(vertices_s, 3) else: vertices_s = ensure_nesting_level(vertices_s, 4) surfaces_out = [] points_out = [] knots_u_out = [] knots_v_out = [] for vertices, degree_u, degree_v, points_cnt_u, points_cnt_v, u_size in zip_long_repeat(vertices_s, degree_u_s, degree_v_s, points_cnt_u_s, points_cnt_v_s, u_size_s): if isinstance(degree_u, (tuple, list)): degree_u = degree_u[0] if isinstance(degree_v, (tuple, list)): degree_v = degree_v[0] if isinstance(u_size, (tuple, list)): u_size = u_size[0] if isinstance(points_cnt_u, (tuple, list)): points_cnt_u = points_cnt_u[0] if isinstance(points_cnt_v, (tuple, list)): points_cnt_v = points_cnt_v[0] if self.input_mode == '1D': n_u = u_size n_v = len(vertices) // n_u else: n_u = len(vertices[0]) for i, verts_i in enumerate(vertices): if len(verts_i) != n_u: raise Exception("Number of vertices in row #{} is not the same as in the first ({} != {})!".format(i, n_u, len(verts_i))) vertices = sum(vertices, []) n_v = len(vertices) // n_u kwargs = dict(centripetal = self.centripetal) if self.has_points_cnt: kwargs['ctrlpts_size_u'] = points_cnt_u kwargs['ctrlpts_size_v'] = points_cnt_v surf = fitting.approximate_surface(vertices, n_u, n_v, degree_u, degree_v, **kwargs) points_out.append(surf.ctrlpts2d) knots_u_out.append(surf.knotvector_u) knots_v_out.append(surf.knotvector_v) surf = SvGeomdlSurface(surf) surfaces_out.append(surf) self.outputs['Surface'].sv_set(surfaces_out) self.outputs['ControlPoints'].sv_set(points_out) self.outputs['KnotsU'].sv_set(knots_u_out) self.outputs['KnotsV'].sv_set(knots_v_out)
def cul_contour_pca(img, init, rect_size, P, div=40, N_limit=24, dif_limit=0.001, increasing_limit=0.01, c=0.95, ctrlpts_size=8, w=0.95, mindim=6, maxdim=20, step=5): prev_separability = 0 for i in range(N_limit): evalpts = evalpts_uv(init, div, 0.00001) mean_separability, updated_evalpts = update_evalpts( evalpts, img, rect_size.astype(np.int64), div, w) print(mean_separability) if mean_separability - prev_separability < dif_limit: break init = approximate_surface(updated_evalpts.tolist(), div, div, 3, 3, ctrlpts_size_u=ctrlpts_size, ctrlpts_size_v=ctrlpts_size) if math.fabs(mean_separability - prev_separability ) < increasing_limit and ctrlpts_size < maxdim: ctrlpts_size = ctrlpts_size + 1 print(ctrlpts_size) prev_separability = mean_separability if i % step == step - 1: print('pca') init = projection_surf(P[init.ctrlpts_size_u - mindim], init) prev_separability = 0 print(rect_size.astype(np.int64)) rect_size = np.array( [rs * c if 1 <= rs * c else 1 for rs in rect_size]) return init
def make_ellipsoid_surf(center, radius, psize=20, qsize=8): points = np.array([[ 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=psize) for v in np.linspace( -math.pi / 2 + 0.01, math.pi / 2 - 0.01, num=psize)]) points += center return approximate_surface(points.tolist(), psize, psize, 3, 3, ctrlpts_size_u=qsize, ctrlpts_size_v=qsize)
def cul_contour(img, init, rect_size, div=20, N_limit=30, dif_limit=0.001, dif_abs=True, increasing_limit=0.01, ctrlpts_increasing=False, c=0.95, ctrlpts_size=8, w=0.95): prev_separability = 0 for _ in range(N_limit): evalpts = evalpts_uv(init, div, 0.00001) mean_separability, updated_evalpts = update_evalpts( evalpts, img, rect_size.astype(np.int64), div, w) print(mean_separability) if dif_abs: if math.fabs(mean_separability - prev_separability) < dif_limit: break else: if mean_separability - prev_separability < dif_limit: break init = approximate_surface(updated_evalpts.tolist(), div, div, 3, 3, ctrlpts_size_u=ctrlpts_size, ctrlpts_size_v=ctrlpts_size) if ctrlpts_increasing: if math.fabs(mean_separability - prev_separability) < increasing_limit: ctrlpts_size = ctrlpts_size + 1 print(ctrlpts_size) prev_separability = mean_separability print(rect_size.astype(np.int64)) rect_size = np.array( [rs * c if 1 <= rs * c else 1 for rs in rect_size]) return init
def optimize_open_spline(reconstructed_points, input_points_): """ Assuming that initial point cloud size is greater than or equal to 400. """ out = reconstructed_points[0] out = out.data.cpu().numpy() out = out.reshape((30, 30, 3)) out = out.reshape((900, 3)) input = input_points_[0] N = input.shape[0] input = up_sample_points_torch_in_range(input, 1200, 1300) input = input.data.cpu().numpy() dist = np.linalg.norm(np.expand_dims(out, 1) - np.expand_dims(input, 0), axis=2) rids, cids = solve_dense(dist) matched = input[cids] size_u = 30 size_v = 30 degree_u = 2 degree_v = 2 # Do global surface approximation try: surf = geomdl_fitting.approximate_surface( matched.tolist(), size_u, size_v, degree_u, degree_v, ctrlpts_size_u=10, ctrlpts_size_v=10, ) except: print("open spline, smaller than 400") return reconstructed_points regular_parameters = draw_surf.regular_parameterization(30, 30) optimized_points = surf.evaluate_list(regular_parameters) optimized_points = torch.from_numpy( np.array(optimized_points).astype(np.float32)).cuda() optimized_points = torch.unsqueeze(optimized_points, 0) return optimized_points
def optimize_close_spline(reconstructed_points, input_points_): """ Assuming that initial point cloud size is greater than or equal to 400. """ out = reconstructed_points[0] out = out.data.cpu().numpy() out = out.reshape((31, 30, 3)) out = out[np.arange(0, 31, 1.5).astype( np.int32)][:, np.arange(0, 30, 1.5).astype(np.int32).tolist()] out = out.reshape((20 * 21, 3)) input = input_points_[0] N = input.shape[0] input = up_sample_points_torch_in_range(input, 2000, 2100) # L = np.random.choice(np.arange(N), 30 * 31, replace=False) input = input.data.cpu().numpy() dist = np.linalg.norm(np.expand_dims(out, 1) - np.expand_dims(input, 0), axis=2) rids, cids = solve_dense(dist) matched = input[cids] size_u = 21 size_v = 20 degree_u = 3 degree_v = 3 # Do global surface approximation surf = geomdl_fitting.approximate_surface( matched.tolist(), size_u, size_v, degree_u, degree_v, ctrlpts_size_u=10, ctrlpts_size_v=10, ) regular_parameters = draw_surf.regular_parameterization(31, 30) optimized_points = surf.evaluate_list(regular_parameters) optimized_points = torch.from_numpy( np.array(optimized_points).astype(np.float32)).cuda() optimized_points = torch.unsqueeze(optimized_points, 0) return optimized_points
def fit_surface(points, size_u, size_v, degree_u=3, degree_v=3, regular_grids=False): fitted_surface = fitting.approximate_surface( points, size_u=size_u, size_v=size_v, degree_u=degree_u, degree_v=degree_v, ctrlpts_size_u=10, ctrlpts_size_v=10, ) if regular_grids: parameters = regular_parameterization(25, 25) else: parameters = np.random.random((3000, 2)) fitted_points = fitted_surface.evaluate_list(parameters) return fitted_surface, fitted_points
def make_nearest_surf(center, radius, rotation, contour_pts, psize=20, qsize=8, vis=False, seg=None): points = np.array([[ 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=psize) for v in np.linspace( -math.pi / 2 + 0.01, math.pi / 2 - 0.01, num=psize)]) for i in range(len(points)): points[i] = np.dot(points[i], rotation) points += center tree = BallTree(contour_pts) _, ind = tree.query(points, k=1) ind = np.reshape(ind, (ind.shape[0])) points = contour_pts[ind, :].astype(np.float64) noise = 0.001 points += np.random.rand(points.shape[0], points.shape[1]) * noise if vis: img_mask = get_image_mask_points(seg, points) color_img = draw_segmentation(seg, img_mask, mark_val=255) show_ct_image(color_img) return approximate_surface(points.tolist(), psize, psize, 3, 3, ctrlpts_size_u=qsize, ctrlpts_size_v=qsize)
def manual_init(points, radius, pn=20, qn=8): trace = interpolate_curve(points, 3) rad_curve = interp1d([p[0] for p in points], radius) params = np.linspace(0, 1, pn).tolist() trace_binormal = np.array(trace.binormal(params)) trace_tangent = np.array(trace.tangent(params)) trace_points = [] for tbi, tt in zip(trace_binormal, trace_tangent): for angle in np.linspace(0, 2 * np.pi, pn).tolist(): r = R.from_rotvec(angle * tt[1]) p = tbi[0] + rad_curve(tbi[0][0]) * r.apply(tbi[1]) trace_points.append(p.tolist()) return approximate_surface(trace_points, pn, pn, 3, 3, ctrlpts_size_u=qn, ctrlpts_size_v=qn)
toroid = np.array(toroid) toroid = preProcess(toroid) toroid_def = np.array(toroid_def) toroid_def = preProcess(toroid_def) 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 = []
# points = np.array([patch_center + u * patch_u + v * pathc_v # for u in np.linspace(-wide,wide,num=psize) # for v in np.linspace(-wide,wide,num=psize)]) bsurf.delta = 0.05 bsurf.evaluate(start_u=0.5 * gu, stop_u=0.5 * (gu + 1), start_v=0.5 * gv, stop_v=0.5 * (gv + 1)) points = np.array(bsurf.evalpts) psize = int(np.sqrt(points.shape[0])) # points = np.reshape(points,(psize,psize,3)) surf = approximate_surface(points.tolist(), psize, psize, 3, 3, ctrlpts_size_u=qsize, ctrlpts_size_v=qsize) # tb.show_image_collection(tb.draw_contour(img,surf).astype(np.uint8)) surf = tb.cul_contour(img, surf, rect_size, div=20, N_limit=10, c=0.95, ctrlpts_size=qsize, dif_limit=0.001, w=0.95) mask = tb.get_image_mask(img, surf)
def scordelis_lo(radius=25, thickness=0.25, length=50, angle=40, **kwargs): """ Generates a Scordelis-Lo Roof. The Scordelis-Lo roof is a classical test case for linear static analysis. Please refer to the following articles for details: * https://doi.org/10.14359/7796 * https://doi.org/10.1016/0045-7825(85)90035-0 * https://doi.org/10.1016/j.cma.2010.03.029 Keyword Arguments: * ``jump_angle``: iteration step for `angle` value. *Default: 2* * ``jump_length``: iteration step for `length` value. *Default: 2* * ``degree_u``: degree of the volume (u-dir). *Default: 2* * ``degree_v``: degree of the volume (v-dir). *Default: 2* * ``size_u``: number of control points (u-dir). *Default: degree_u + 2* * ``size_v``: number of control points (v-dir). *Default: degree_v + 2* :param radius: radius (R) :type radius: int, float :param thickness: thickness (t) :type thickness: int, float :param length: length (L) :type length: int, float :param angle: angle in degrees (Theta) :type angle: int, float :return: Scordelis-Lo Roof as a shell/volume :rtype: BSpline.Volume """ # Iteration parameters jump_angle = kwargs.get('jump_angle', 2) jump_length = kwargs.get('jump_length', 2) # Spline parameters degree_u = kwargs.get('degree_u', 2) degree_v = kwargs.get('degree_v', 2) size_u = kwargs.get('size_u', degree_u + 2) size_v = kwargs.get('size_v', degree_v + 2) # Generate data points points_bottom = [] # data points for the bottom surface points_top = [] # data points for the top surface size_u = 0 size_v = 0 for l in range(0, length, jump_length): # y-direction size_v = 0 for a in range(0, angle, jump_angle): # x-z plane arad = math.radians(a) pt_bottom = [radius * math.sin(arad), l, radius * math.cos(arad)] points_bottom.append(pt_bottom) pt_top = [(radius + thickness) * math.sin(arad), l, (radius + thickness) * math.cos(arad)] points_top.append(pt_top) size_v += 1 size_u += 1 # Approximate bottom surface surf_bottom = fitting.approximate_surface(points_bottom, size_u, size_v, degree_u, degree_v, ctrlpts_size_u=degree_u + 2, ctrlpts_size_v=degree_v + 2) # Approximate top surface surf_top = fitting.approximate_surface(points_top, size_u, size_v, degree_u, degree_v, ctrlpts_size_u=degree_u + 2, ctrlpts_size_v=degree_v + 2) # Generate Scordelis-Lo Roof as a spline volume slroof = construct.construct_volume("w", surf_bottom, surf_top) # Return the generated volume return slroof
radius_init = 40 points = np.array( [[ radius_init * math.cos(u) * math.cos(v), radius_init * math.cos(v) * math.sin(u), radius_init * math.sin(v) ] for u in np.linspace(0, 2 * math.pi, num=20) for v in np.linspace(-math.pi / 2 + 0.01, math.pi / 2 - 0.01, num=20)]) points += center + 0.5 # 制御点補完 surf = approximate_surface(points.tolist(), 20, 20, 3, 3, ctrlpts_size_u=8, ctrlpts_size_v=8) img = tb.draw_contour(sphere, surf) tb.show_ct_image(img) div = 100 evalpts = tb.evalpts_uv(surf, div, 0) ave = [] for evalp in evalpts: for e in evalp: ave.append( np.linalg.norm(np.array(e) - np.array([center, center, center])))
drdz_ed.append(cylinder_ed.partial_z()) 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 separability_membrane(img, init, rect_size, div=40, N_limit=20, dif_limit=0.001, dif_abs=True, increasing_limit=0.01, ctrlpts_increasing=True, c=0.95, ctrlpts_size=8, w=0.95, debug=True): margin = rect_size[0] img = add_margin(img, margin) newcp = np.array(init.ctrlpts) + margin init.ctrlpts = newcp.tolist() prev_separability = 0 for _ in range(N_limit): evalpts = evalpts_uv(init, div, 0.00001) mean_separability, updated_evalpts = update_evalpts( evalpts, img, rect_size.astype(np.int64), div, w) if debug: print(mean_separability) if dif_abs: if math.fabs(mean_separability - prev_separability) < dif_limit: break else: if mean_separability - prev_separability < dif_limit: break init = approximate_surface(updated_evalpts.tolist(), div, div, 3, 3, ctrlpts_size_u=ctrlpts_size, ctrlpts_size_v=ctrlpts_size) if ctrlpts_increasing: if math.fabs(mean_separability - prev_separability) < increasing_limit: ctrlpts_size = ctrlpts_size + 1 if debug: print(ctrlpts_size) prev_separability = mean_separability if debug: print(rect_size.astype(np.int64)) rect_size = np.array( [rs * c if 1 <= rs * c else 1 for rs in rect_size]) newcp = np.array(init.ctrlpts) - margin init.ctrlpts = newcp.tolist() return init
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
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",
def max_cul_contour_seg(img, seg, init, rect_size, restraint=False, P=None, div=20, N_limit=30, dif_limit=0.001, dif_abs=True, increasing_limit=0.01, ctrlpts_increasing=False, c=0.95, ctrlpts_size=8, w=0.95, weight=0.5, debug=False): prev_separability = 0 mindim = 6 maxdim = 14 challenge = True separabilities = [] surfs = [] for _ in range(N_limit): evalpts = evalpts_uv(init, div, 0.00001) mean_separability, updated_evalpts = update_evalpts_seg( evalpts, img, seg, rect_size.astype(np.int64), div, weight, w) separabilities.append(mean_separability) print(mean_separability) if restraint: if dif_abs: if math.fabs(mean_separability - prev_separability) < dif_limit: break else: if mean_separability - prev_separability < dif_limit: if challenge: print('challenge!!') escape = init init = projection_surf(P[init.ctrlpts_size_u - mindim], init) challenge = False continue else: init = escape break else: if dif_abs: if math.fabs(mean_separability - prev_separability) < dif_limit: break else: if mean_separability - prev_separability < dif_limit: break init = approximate_surface(updated_evalpts.tolist(), div, div, 3, 3, ctrlpts_size_u=ctrlpts_size, ctrlpts_size_v=ctrlpts_size) surfs.append(init) if ctrlpts_increasing: if math.fabs(mean_separability - prev_separability ) < increasing_limit and ctrlpts_size < maxdim: ctrlpts_size += 1 print(ctrlpts_size) prev_separability = mean_separability print(rect_size.astype(np.int64)) rect_size = np.array( [rs * c if 1 <= rs * c else 1 for rs in rect_size]) challenge = True # fig = plt.figure() # ax = Axes3D(fig) # ax.plot(updated_evalpts[:,0],updated_evalpts[:,1],updated_evalpts[:,2],'o',markersize=2) # ax.plot(evalpts.reshape([(div+2)**2,3])[:,0],evalpts.reshape([(div+2)**2,3])[:,1],evalpts.reshape([(div+2)**2,3])[:,2],'x',markersize=2) # plt.show() return surfs[np.argmax(separabilities)]
def cul_contour_seg(img, seg, init, rect_size, restraint=False, P=None, div=20, N_limit=30, dif_limit=0.001, dif_abs=True, increasing_limit=0.01, ctrlpts_increasing=False, c=0.95, ctrlpts_size=8, w=0.95, weight=0.5, debug=False): prev_separability = 0 mindim = 6 maxdim = 14 challenge = True for _ in range(N_limit): evalpts = evalpts_uv(init, div, 0.00001) mean_separability, updated_evalpts = update_evalpts_seg( evalpts, img, seg, rect_size.astype(np.int64), div, weight, w) if debug: # evalpts = np.reshape(evalpts[1:div+1,1:div+1,:],(div*div,3)) # u_evalpts = np.array(updated_evalpts) # for i in range(0,evalpts.shape[0],10): # mask = np.zeros(img.shape) # mask[int(evalpts[i,0]),int(evalpts[i,1]),int(evalpts[i,2])] = 1 # mask[int(u_evalpts[i,0]),int(u_evalpts[i,1]),int(u_evalpts[i,2])] = 1 # print(evalpts[i,:]) # print(u_evalpts[i,:]) # color_img = draw_segmentation(seg, mask,mark_val=1) # show_ct_image(color_img) evalpts = np.array(updated_evalpts) evalpts = np.reshape(evalpts, (div * div, 3)) img_mask = get_image_mask_points(img, evalpts) color_img = draw_segmentation(seg, img_mask, mark_val=255) show_ct_image(color_img) print(mean_separability) if restraint: if dif_abs: if math.fabs(mean_separability - prev_separability) < dif_limit: break else: if mean_separability - prev_separability < dif_limit: if challenge: print('challenge!!') escape = init init = projection_surf(P[init.ctrlpts_size_u - mindim], init) challenge = False continue else: init = escape break else: if dif_abs: if math.fabs(mean_separability - prev_separability) < dif_limit: break else: if mean_separability - prev_separability < dif_limit: break init = approximate_surface(updated_evalpts.tolist(), div, div, 3, 3, ctrlpts_size_u=ctrlpts_size, ctrlpts_size_v=ctrlpts_size) if ctrlpts_increasing: if math.fabs(mean_separability - prev_separability ) < increasing_limit and ctrlpts_size < maxdim: ctrlpts_size += 1 print(ctrlpts_size) prev_separability = mean_separability print(rect_size.astype(np.int64)) rect_size = np.array( [rs * c if 1 <= rs * c else 1 for rs in rect_size]) challenge = True # fig = plt.figure() # ax = Axes3D(fig) # ax.plot(updated_evalpts[:,0],updated_evalpts[:,1],updated_evalpts[:,2],'o',markersize=2) # ax.plot(evalpts.reshape([(div+2)**2,3])[:,0],evalpts.reshape([(div+2)**2,3])[:,1],evalpts.reshape([(div+2)**2,3])[:,2],'x',markersize=2) # plt.show() return init
# points = np.array([[u, v,math.sin(v)+math.sin(u)] # for u in np.linspace(0,2*math.pi,num=30) # for v in np.linspace(0,2*math.pi,num=30)]) points = np.array([[math.cos(u)*math.cos(v), math.cos(v)*math.sin(u),math.sin(v)] for u in np.linspace(0,2*math.pi,num=30) for v in np.linspace(-math.pi/2,math.pi/2,num=30)]) # print(points) # fig = plt.figure() # ax = Axes3D(fig) # ax.plot(points[:,0],points[:,1],points[:,2],'o',markersize=2) # plt.show() surf = approximate_surface(points.tolist(),30,30,3,3,ctrlpts_size_u=10,ctrlpts_size_v=10) surf.delta = 0.05 surf.vis = VisMPL.VisSurfWireframe() # surf.render() div = 100 evalpts = np.array([surf.evaluate_list([(u,v) for v in np.linspace(0,1,div)]) for u in np.linspace(0,1,div)]) print(evalpts.shape) fig = plt.figure() ax = Axes3D(fig) # all_points = np.reshape(evalpts,(div*div,3))
plt.title('Cartesian') ax.scatter(X[:, 0], X[:, 1], X[:, 2]) np.savetxt("cpts_test.csv", X, delimiter=",") # setup pre reqs for surface fitting p_ctrlpts = X size_u = N + 1 size_v = 20 degree_u = 3 degree_v = 3 # Do global surface approximation surf = fitting.approximate_surface(p_ctrlpts, size_u, size_v, degree_u, degree_v, centripetal=True) # 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.03 surf.vis = vis.VisSurface() surf.render(extras=plot_extras) ''' Next steps: - get the evaluated points of generated surface