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
