def process(self):
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()
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, u_size in zip_long_repeat(
vertices_s, degree_u_s, degree_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 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
surf = fitting.interpolate_surface(
vertices,
n_u,
n_v,
degree_u,
degree_v,
centripetal=self.centripetal)
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 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 fit_Remapped_RV(N, M, points, flag=False):
slice(N, points)
slices = []
cyl_coord_pts = []
layers = []
bins = slice.bins
for j in range(0, len(slice.slices)):
cyl_coord_pts.append(
cart2cylinder(
slice.slices[j][:, 0],
slice.slices[j][:, 1],
bins[j] * np.ones(len(slice.slices[j][:, 2])),
))
cyl_coord_pts = np.array(cyl_coord_pts)
# store all slices into layers array
for i in range(0, len(cyl_coord_pts)):
for j in range(0, len(cyl_coord_pts[i][0])):
layers.append([
cyl_coord_pts[:, 0][i][j],
cyl_coord_pts[:, 1][i][j],
cyl_coord_pts[:, 2][i][j],
])
# segment the layers into angled segments
layers = np.array(layers)
segments = split_into_angles(M, layers)
# find average points at each segment and slice
chunks = []
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)):
chunks.append(segment[i][segment[i][:, 2] == bins[j]])
chunks = np.array(chunks)
xbar = []
ybar = []
zbar = []
cylData = []
cartData = []
if flag == True:
for j in range(0, len(chunks)):
if chunks[j].size == 0:
print('')
else:
cylData.append(
cart2cylinder(chunks[j][:, 0], chunks[j][:, 1],
chunks[j][:, 2]))
for i in range(0, len(cylData)):
cartData.append(
cylinder2cart(cylData[i][0].max(), cylData[i][1].max(),
cylData[i][2].max()))
for i in range(0, (N + 1)):
cartData.append(
cylinder2cart(cylData[i][0].max(), cylData[i][1].max(),
cylData[i][2].max()))
X = np.array(cartData)
# print(X)
# ax.scatter(X[:,0],X[:,1],X[:,2])
else:
fig = plt.figure()
ax = plt.axes(projection='3d')
for j in range(0, len(chunks)):
print(j)
xbar.append(chunks[j][:, 0].mean())
ybar.append(chunks[j][:, 1].mean())
zbar.append(chunks[j][:, 2].max())
print(len(chunks[j]))
ax.scatter(chunks[j][:, 0], chunks[j][:, 1], chunks[j][:, 2])
plt.show()
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
# test = []
# # 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)
# set up the fitting parameters
p_ctrlpts = X
size_u = M + 1
size_v = N + 1
degree_u = 3
degree_v = 3
# fit a surface by applying global interpolation
remapped_NURBS_RV_surf = fitting.interpolate_surface(
p_ctrlpts, size_u, size_v, degree_u, degree_v)
return remapped_NURBS_RV_surf, X
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
def process(self):
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()
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, u_size in zip_long_repeat(
vertices_s, degree_u_s, degree_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 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
if geomdl is not None and self.nurbs_implementation == SvNurbsMaths.GEOMDL:
surf = fitting.interpolate_surface(
vertices,
n_u,
n_v,
degree_u,
degree_v,
centripetal=self.centripetal)
surf = SvGeomdlSurface(surf)
else:
vertices_np = np.array(split_by_count(vertices, n_v))
vertices_np = np.transpose(vertices_np, axes=(1, 0, 2))
surf = interpolate_nurbs_surface(degree_u,
degree_v,
vertices_np,
metric=self.metric)
points_out.append(surf.get_control_points().tolist())
knots_u_out.append(surf.get_knotvector_u().tolist())
knots_v_out.append(surf.get_knotvector_v().tolist())
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)
points = ((-5, -5, 0), (-2.5, -5, 0), (0, -5, 0), (2.5, -5, 0), (5, -5, 0),
(7.5, -5, 0), (10, -5, 0), (-5, 0, 3), (-2.5, 0, 3), (0, 0, 3),
(2.5, 0, 3), (5, 0, 3), (7.5, 0, 3), (10, 0, 3), (-5, 5, 0),
(-2.5, 5, 0), (0, 5, 0), (2.5, 5, 0), (5, 5, 0), (7.5, 5, 0),
(10, 5, 0), (-5, 7.5, -3), (-2.5, 7.5, -3), (0, 7.5, -3), (2.5, 7.5,
-3),
(5, 7.5, -3), (7.5, 7.5, -3), (10, 7.5, -3), (-5, 10, 0), (-2.5, 10,
0),
(0, 10, 0), (2.5, 10, 0), (5, 10, 0), (7.5, 10, 0), (10, 10, 0))
size_u = 5
size_v = 7
degree_u = 2
degree_v = 3
# Do global surface interpolation
surf = fitting.interpolate_surface(points, size_u, size_v, degree_u, degree_v)
# Plot the interpolated surface
surf.delta = 0.05
surf.vis = vis.VisSurface()
surf.render()
# # Visualize data and evaluated points together
# import numpy as np
# import matplotlib.pyplot as plt
# evalpts = np.array(surf.evalpts)
# pts = np.array(points)
# fig = plt.figure()
# ax = plt.axes(projection='3d')
# ax.scatter(evalpts[:, 0], evalpts[:, 1], evalpts[:, 2])
# ax.scatter(pts[:, 0], pts[:, 1], pts[:, 2], color="red")
