def plotBsplineSurface(self,
pts,
corsequences,
lsagsequences=[],
rsagsequences=[],
degree=3,
visualization_type=-1,
side=2):
# side = 0 (Left) | side = 1 (Right)
if side == 0:
lsurface = self.createBsplineSurface(pts=pts,
corsequences=corsequences,
sagsequences=lsagsequences)
# Set visualization component
if visualization_type == 0:
lsurface.delta = 0.01
vis_comp = VisMPL.VisSurfScatter()
elif visualization_type == 1:
vis_comp = VisMPL.VisSurface()
elif visualization_type == 2:
vis_comp = VisMPL.VisSurfWireframe()
else:
vis_comp = VisMPL.VisSurfTriangle()
lsurface.vis = vis_comp
# Render the surface
lsurface.render()
else:
rsurface = self.createBsplineSurface(pts=pts,
corsequences=corsequences,
sagsequences=rsagsequences)
# Set visualization component
if visualization_type == 0:
rsurface.delta = 0.01
vis_comp = VisMPL.VisSurfScatter()
elif visualization_type == 1:
vis_comp = VisMPL.VisSurface()
elif visualization_type == 2:
vis_comp = VisMPL.VisSurfWireframe()
else:
vis_comp = VisMPL.VisSurfTriangle()
rsurface.vis = vis_comp
# Render the surface
rsurface.render()
def plotNURBSSurfaces(self,
left_pts,
right_pts,
corsequences,
lsagsequences,
rsagsequences,
degree=3,
visualization_type=-1):
left_surface = self.createNURBSSurface(pts=left_pts,
corsequences=corsequences,
sagsequences=lsagsequences)
right_surface = self.createNURBSSurface(pts=right_pts,
corsequences=corsequences,
sagsequences=rsagsequences)
# Create a MultiSurface
surfaces = Multi.MultiSurface()
surfaces.add(left_surface)
surfaces.add(right_surface)
# Set visualization component
if visualization_type == 0:
surfaces.delta = 0.01
vis_comp = VisMPL.VisSurfScatter()
elif visualization_type == 1:
vis_comp = VisMPL.VisSurface()
elif visualization_type == 2:
vis_comp = VisMPL.VisSurfWireframe()
else:
vis_comp = VisMPL.VisSurfTriangle()
surfaces.vis = vis_comp
# Render the surface
surfaces.render()
def surface_visualizer(self, surface):
#%matplotlib
# Create a visualization configuration instance with no legend, no axes and set the resolution to 120 dpi
vis_config = VisMPL.VisConfig(ctrlpts=False, axes_equal=False)
# Create a visualization method instance using the configuration above
vis_obj = VisMPL.VisSurface(vis_config)
# Set the visualization method of the curve object
surface.vis = vis_obj
surface.render(colormap=cm.cool, plot=False)
def test_deriv_surf_fig(bspline_surface):
fname = "test-derivative_surface.png"
data = operations.derivative_surface(bspline_surface)
multi_shape = multi.SurfaceContainer(data)
multi_shape.vis = VisMPL.VisSurface()
multi_shape.render(filename=fname, plot=False)
assert os.path.isfile(fname)
assert os.path.getsize(fname) > 0
# Clean up temporary file if exists
if os.path.isfile(fname):
os.remove(fname)
def test_surf_fig_nowindow(bspline_surface):
conf = VisMPL.VisConfig()
vis = VisMPL.VisSurface(config=conf)
fname = conf.figure_image_filename
bspline_surface.vis = vis
bspline_surface.render(plot=False)
assert os.path.isfile(fname)
assert os.path.getsize(fname) > 0
# Clean up temporary file if exists
if os.path.isfile(conf.figure_image_filename):
os.remove(conf.figure_image_filename)
def test_surf_fig_save(bspline_surface):
conf = VisMPL.VisConfig()
vis = VisMPL.VisSurface(config=conf)
fname = "test-surface.png"
bspline_surface.vis = vis
bspline_surface.render(filename=fname, plot=False)
assert os.path.isfile(fname)
assert os.path.getsize(fname) > 0
# Clean up temporary file if exists
if os.path.isfile(fname):
os.remove(fname)
def test_surf_multi_fig_save(bspline_surface):
conf = VisMPL.VisConfig()
vis = VisMPL.VisSurface(config=conf)
fname = "test-multi_surface.png"
multi = operations.decompose_surface(bspline_surface)
multi.vis = vis
multi.render(filename=fname, plot=False)
assert os.path.isfile(fname)
assert os.path.getsize(fname) > 0
# Clean up temporary file if exists
if os.path.isfile(fname):
os.remove(fname)
def test_surf_ctrlpts_offset(bspline_surface):
conf = VisMPL.VisConfig()
vis = VisMPL.VisSurface(config=conf)
# Set control points grid offset
vis.ctrlpts_offset = 3.5
fname = "test-surface.png"
bspline_surface.vis = vis
bspline_surface.render(filename=fname, plot=False)
assert os.path.isfile(fname)
assert os.path.getsize(fname) > 0
# Clean up temporary file if exists
if os.path.isfile(fname):
os.remove(fname)
def build_vis(obj, **kwargs):
""" Prepares visualization module for the input spline geometry.
:param obj: input spline geometry object
:return: spline geometry object updated with a visualization module
"""
vis_config = VisMPL.VisConfig(**kwargs)
if isinstance(obj, (NURBS.Curve, multi.CurveContainer)):
if obj.dimension == 2:
obj.vis = VisMPL.VisCurve2D(vis_config)
elif obj.dimension == 3:
obj.vis = VisMPL.VisCurve3D(vis_config)
else:
raise RuntimeError("Can only plot 2- or 3-dimensional curves")
if isinstance(obj, (NURBS.Surface, multi.SurfaceContainer)):
obj.vis = VisMPL.VisSurface(vis_config)
if isinstance(obj, (NURBS.Volume, multi.VolumeContainer)):
obj.vis = VisMPL.VisVolume(vis_config)
return obj
# Set degrees surf.degree_u = 3 surf.degree_v = 3 # Get the control points from the generated grid surf.ctrlpts2d = surfgrid.grid # Set knot vectors surf.knotvector_u = utilities.generate_knot_vector(surf.degree_u, surf.ctrlpts_size_u) surf.knotvector_v = utilities.generate_knot_vector(surf.degree_v, surf.ctrlpts_size_v) # Set sample size of the surface surf.sample_size = 50 # Generate the visualization component and its configuration vis_config = vis.VisConfig(ctrlpts=True, legend=False) vis_comp = vis.VisSurface(vis_config) # Set visualization component of the surface surf.vis = vis_comp # Plot the surface surf.render() # Export the surface as a .stl file exchange.export_stl(surf, "bump_smoother_1pt-padding.stl") # Good to have something here to put a breakpoint pass
os.chdir(os.path.dirname(os.path.realpath(__file__)))
# Create a NURBS surface instance
surf = NURBS.Surface()
# Set degrees
surf.degree_u = 1
surf.degree_v = 2
# Set control points
surf.set_ctrlpts(
*exchange.import_txt("ex_cylinder_quarter.cptw", two_dimensional=True))
# Set knot vectors
surf.knotvector_u = [0, 0, 1, 1]
surf.knotvector_v = [0, 0, 0, 1, 1, 1]
# Set evaluation delta
surf.delta = 0.05
# Evaluate surface
surf.evaluate()
# Plot the control point grid and the evaluated surface
vis_comp = vis.VisSurface()
surf.vis = vis_comp
surf.render()
# Good to have something here to put a breakpoint
pass
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Examples for the NURBS-Python Package
Released under MIT License
Developed by Onur Rauf Bingol (c) 2018
"""
from geomdl.shapes import surface
# Try to load the visualization module
try:
render = True
from geomdl.visualization import VisMPL
except ImportError:
render = False
cylinder = surface.cylinder(radius=5.0, height=22.5)
cylinder.delta = 0.05
# Render the surface
if render:
vis_config = VisMPL.VisConfig(ctrlpts=False)
vis_comp = VisMPL.VisSurface(config=vis_config)
cylinder.vis = vis_comp
cylinder.render()
# Good to have something here to put a breakpoint
pass
surf03.ctrlpts2d = sg03.grid
# Set knot vectors
surf03.knotvector_u = utilities.generate_knot_vector(
surf03.degree_u, surf03.ctrlpts_size_u)
surf03.knotvector_v = utilities.generate_knot_vector(
surf03.degree_v, surf03.ctrlpts_size_v)
# Construct the parametric volume
pvolume = construct.construct_volume(surf01, surf02, surf03, degree=1)
pvolume.vis = vis.VisVoxel(vis.VisConfig(ctrlpts=False))
pvolume.delta_u = pvolume.delta_v = 0.025
pvolume.delta_w = 0.05
pvolume.render(evalcolor="firebrick", use_mp=True, num_procs=16)
# Extract surfaces from the parametric volume
surfvol = construct.extract_surfaces(pvolume)
# Construct the isosurface
msurf = multi.SurfaceContainer(surfvol['uv'][0], surfvol['uv'][-1],
surfvol['uw'][0], surfvol['uw'][-1],
surfvol['vw'][0], surfvol['vw'][-1])
msurf.vis = vis.VisSurface(vis.VisConfig(ctrlpts=False))
msurf.delta = 0.05
msurf.render(evalcolor=[
"skyblue", "cadetblue", "crimson", "crimson", "crimson", "crimson"
])
# Good to have something here to put a breakpoint
pass
cdict = {'red': [], 'green': [], 'blue': []}
for i, item in enumerate(seq):
if isinstance(item, float):
r1, g1, b1 = seq[i - 1]
r2, g2, b2 = seq[i + 1]
cdict['red'].append([item, r1, r2])
cdict['green'].append([item, g1, g2])
cdict['blue'].append([item, b1, b2])
return mcolors.LinearSegmentedColormap('CustomMap', cdict)
surf_ed, surf_es, drdt_ed, drdz_ed, drdt_es, drdz_es = sinusoidal_cylinder()
surf_ed.delta = 0.025
# vis_config = vis.VisConfig(legend=True, axes=False, figure_dpi=120,ctrlpts = False)
surf_ed.vis = vis.VisSurface()
evalpts_ed = np.array(surf_ed.evalpts)
surf_es.delta = 0.025
surf_es.vis = vis.VisSurface()
evalpts_es = np.array(surf_es.evalpts)
# compute analytical metric tensor for ed phase
a_E_ed = []
a_F_ed = []
a_G_ed = []
for i in range(0, len(drdt_ed)):
a_E_ed.append(np.dot(drdz_ed[i], drdz_ed[i]))
a_F_ed.append(np.dot(drdz_ed[i], drdt_ed[i]))
a_G_ed.append(np.dot(drdt_ed[i], drdt_ed[i]))
rect_size = np.array([20, 6, 6])
center = np.array([135, 300, 330])
radius = np.array([35, 35, 35])
margin = rect_size[0]
center += margin
img = tb.add_margin(inside, margin)
img = tb.window_function(img, 0, 300)
# tb.show_ct_image(img)
# surf = tb.make_ellipsoid_surf(center,radius)
tb.show_ct_image(tb.draw_contour(img, surf))
surf = tb.cul_contour(img,
surf,
rect_size,
div=20,
N_limit=30,
c=0.95,
ctrlpts_size=8,
dif_limit=0.001,
w=0.95)
surf.vis = VisMPL.VisSurface()
surf.render(colormap=cm.cool)
color_img = tb.draw_contour(img, surf)
tb.show_ct_image(color_img)
# Set control points
surf.set_ctrlpts(*exchange.import_txt("../ex_surface01.cpt", two_dimensional=True))
# Set knot vectors
surf.knotvector_u = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
surf.knotvector_v = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
# Set sample size
surf.sample_size = 30
# Set surface tessellation component
surf.tessellator = tessellate.TrimTessellate()
# Set visualization component
visconf = vis.VisConfig(ctrlpts=False, legend=False, trims=False)
surf.vis = vis.VisSurface(config=visconf)
# Generate circular trim curves with different sense
tcrv1 = analytic.Circle(origin=(0.25, 0.25), radius=0.20)
tcrv1.opt = ['sense', 1]
tcrv2 = analytic.Circle(origin=(0.75, 0.75), radius=0.20)
tcrv2.opt = ['sense', 1]
trim_curves = [tcrv1, tcrv2]
# Set trim curves (as a list)
surf.trims = trim_curves
# Visualize surface
surf.render(colormap=cm.copper)
# # Save as Wavefront OBJ file
[0, 4, 0],
[0, 8, -3],
[2, 0, 6],
[2, 4, 0],
[2, 8, 0],
[4, 0, 0],
[4, 4, 0],
[4, 8, 3],
[6, 0, 0],
[6, 4, -3],
[6, 8, 0],
]
surf.set_ctrlpts(control_points, 4, 3)
surf.knotvector_u = [0, 0, 0, 0, 1, 1, 1, 1]
surf.knotvector_v = [0, 0, 0, 1, 1, 1]
# surf.delta = 0.05
surf.delta = 0.20 # 0.20 for testing, was originally 0.05 for smoothness
# 0.20, with 1.0 / 0.20 = 5.0,
# gives a matrix of [5x5] evalution points found by > surf.evalpts
# surf.vis = vis.VisSurface()
surf.vis = vis.VisSurface(vis.VisConfig(alpha=0.8))
surface_points = surf.evalpts
print(surface_points)
surf.render()
# surface 2, to come.
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)
]
tube_pcl = np.array(surf.evalpts)
tube_cpts = np.array(surf.ctrlpts)
np.savetxt("cpts_tube.dat", tube_cpts, delimiter=' ')
from matplotlib import cm
surf.delta = 0.018
surf.vis = vis.VisSurface(ctrlpts=False)
surf.render(extras=plot_extras)
exchange.export_obj(surf, "fitted_helix.obj")
# visualize data samples, original RV data, and fitted surface
np.savetxt("RV_tube.dat", tube_pcl, delimiter=' ')
fig = plt.figure()
ax = plt.axes(projection="3d")
ax.scatter(tube_pcl[:, 0], tube_pcl[:, 1], tube_pcl[:, 2])
ax.scatter(points[:, 0], points[:, 1], points[:, 2], color="red")
plt.show()
def main():
path = "d:/Workspace/RV-Mapping/RVshape/"
rm_file = "rm_RVendo_0"
std_file = "standardSample_15x25_RVendo_0"
remapped_RV_file = path + rm_file
standard_RV_file = path + std_file
trimmed_rv_file = np.loadtxt("d:/Workspace/RV-Mapping/RVshape/transformed_RVendo_0.txt")
# trimmed_rv_file = np.loadtxt("d:/Workspace/RV-Mapping.py/processed_RVendo_0.txt")
std_rv_data = np.loadtxt(standard_RV_file + ".csv", delimiter=",")
# std_rv_data = preProcess(std_rv_data)
rm_rv_data = np.loadtxt(remapped_RV_file + ".txt", delimiter="\t")
rm_rv_data = rm_rv_data[rm_rv_data[:,2] > 1]
rm_rv_data = rm_rv_data[rm_rv_data[:,2] < max(rm_rv_data[:,2]) - 11]
# rm_rv_data = preProcess(rm_rv_data)
points = std_rv_data
# np.savetxt("trimmed_" + rm_file + ".txt",rm_rv_data)
N = 25
M = 15
# surf,sampled_data = fit_Remapped_RV(N,M, rm_rv_data,flag = False)
surf = fit_Standard_RV(N,M, std_rv_data)
fig = plt.figure()
ax = plt.axes(projection="3d")
# ax.scatter(trimmed_rv_file[:, 0],trimmed_rv_file[:, 1],trimmed_rv_file[:, 2])
ax.scatter(std_rv_data[:, 0],std_rv_data[:, 1],std_rv_data[:, 2], s= 50,color = 'r')
# ax.scatter(points[:, 0],points[:, 1],points[:, 2])
# ax.scatter(sampled_data[:, 0],sampled_data[:, 1],sampled_data[:, 2] , color = 'r')
# ax.scatter3D(0*np.ones((len(points))),0*np.ones((len(points))),points[:, 2],color = 'r')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
plt.axis('off')
plt.show()
# fig = plt.figure()
# ax = plt.axes(projection="3d")
# ax.scatter(std_rv_data[:, 0],std_rv_data[:, 1],std_rv_data[:, 2], color = 'r')
# ax.scatter(trimmed_rv_file[:, 0],trimmed_rv_file[:, 1],trimmed_rv_file[:, 2])
# plt.axis('off')
# plt.show()
# np.savetxt("sampled_" + str(M) + 'x' + str(N) + '_' + rm_file + ".txt",sampled_data)
# 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=5),
dict(points=surf_curves["v"][0].evalpts, name="v", color="black", size=5),
]
surf.delta = 0.02
surf.vis = vis.VisSurface()
surf.render(extras=plot_extras)
# exchange.export_obj(surf, rm_file + "_fit.obj")
exchange.export_obj(surf, std_file + "_fit.obj")
# # visualize data samples, original RV data, and fitted surface
eval_surf = np.array(surf.evalpts)
np.savetxt(std_file + "_NURBS_surf_pts.csv",eval_surf,delimiter = ',')
# np.savetxt(rm_file + "_NURBS_surf_pts.csv",eval_surf,delimiter = ',')
# # 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(trimmed_rv_file[:, 0],trimmed_rv_file[:, 1],trimmed_rv_file[:, 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)
print(len(cpts))
# np.savetxt('cpts_'+rm_file+".csv",cpts, delimiter = ',')
np.savetxt('cpts_'+ std_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()
def main():
points = np.loadtxt("N2_RV_P0.txt")
zmin_loc_temp = np.where(points[:, 1] == 0)[0]
zmin_loc = zmin_loc_temp
# points = remove_3dpoint(points,zmin_loc)
N = 5
slice(N, points)
slice0 = slice.slices[0]
x0 = slice0[:, 0]
y0 = slice0[:, 1]
z0 = slice0[:, 2]
slice1 = slice.slices[1]
x1 = slice1[:, 0]
y1 = slice1[:, 1]
z1 = slice1[:, 2]
slice2 = slice.slices[2]
x2 = slice2[:, 0]
y2 = slice2[:, 1]
z2 = slice2[:, 2]
slice3 = slice.slices[3]
x3 = slice3[:, 0]
y3 = slice3[:, 1]
z3 = slice3[:, 2]
slice4 = slice.slices[4]
x4 = slice4[:, 0]
y4 = slice4[:, 1]
z4 = slice4[:, 2]
print(np.shape(points))
ranges = slice.bins
diameter = x0.max() - x0.min()
radius = diameter
height = z0.max()
diameter1 = x1.max() - x1.min()
radius1 = diameter1
height1 = z1.max()
diameter2 = x2.max() - x2.min()
radius2 = diameter2
height2 = z2.max()
diameter3 = x3.max() - x3.min()
radius3 = diameter3
height3 = z3.max()
diameter4 = x4.max() - x4.min()
radius4 = diameter4 / 2
height4 = x4.max()
# Generate a cylindrical surface using the shapes component
cylinder = surface.cylinder(radius, height)
# vis_config = VisMPL.VisConfig(ctrlpts=True)
# vis_comp = VisMPL.VisSurface(config=vis_config)
# cylinder.vis = vis_comp
# cylinder.render()
cyl_points = cylinder.evalpts
print("*****************")
# print(len(cyl_points))
print("*****************")
cylinder1 = surface.cylinder(radius1, height1)
cyl_points1 = cylinder1.evalpts
# vis_config = VisMPL.VisConfig(ctrlpts=True)
# vis_comp = VisMPL.VisSurface(config=vis_config)
# cylinder1.vis = vis_comp
# cylinder1.render()
cylinder2 = surface.cylinder(radius2, height2)
cyl_points2 = cylinder2.evalpts
# vis_config = VisMPL.VisConfig(ctrlpts=True)
# vis_comp = VisMPL.VisSurface(config=vis_config)
# cylinder2.vis = vis_comp
# cylinder2.render()
cylinder3 = surface.cylinder(radius3, height3)
cyl_points3 = cylinder3.evalpts
# vis_config = VisMPL.VisConfig(ctrlpts=True)
# vis_comp = VisMPL.VisSurface(config=vis_config)
# cylinder2.vis = vis_comp
# cylinder2.render()
cylinder4 = surface.cylinder(radius4, height4)
cyl_points4 = cylinder4.evalpts
# vis_config = VisMPL.VisConfig(ctrlpts=True)
# vis_comp = VisMPL.VisSurface(config=vis_config)
# cylinder4.vis = vis_comp
# cylinder4.render()
#try using points from the surface not the control points
cylinder_cpts = np.array(cylinder.ctrlpts)
cylinder_cpts1 = np.array(cylinder1.ctrlpts)
cylinder_cpts2 = np.array(cylinder2.ctrlpts)
cylinder_cpts3 = np.array(cylinder3.ctrlpts)
cylinder_cpts4 = np.array(cylinder4.ctrlpts)
a = np.array(cdist(np.array(cyl_points), slice0)).min(axis=0)
b = np.array(cdist(np.array(cyl_points1), slice1)).min(axis=0)
c = np.array(cdist(np.array(cyl_points2), slice2)).min(axis=0)
d = np.array(cdist(np.array(cyl_points3), slice3)).min(axis=0)
e = np.array(cdist(np.array(cyl_points4), slice4)).min(axis=0)
test = np.zeros((len(cylinder_cpts), 3))
test1 = np.zeros((len(cylinder_cpts1), 3))
test2 = np.zeros((len(cylinder_cpts2), 3))
test3 = np.zeros((len(cylinder_cpts3), 3))
test4 = np.zeros((len(cylinder_cpts4), 3))
for i in range(0, len(cylinder_cpts)):
test[i] = (cylinder_cpts[i] / np.linalg.norm(cylinder_cpts[i])) * a[i]
test1[i] = (cylinder_cpts1[i] /
np.linalg.norm(cylinder_cpts1[i])) * b[i]
test2[i] = (cylinder_cpts2[i] /
np.linalg.norm(cylinder_cpts2[i])) * c[i]
test3[i] = (cylinder_cpts3[i] /
np.linalg.norm(cylinder_cpts3[i])) * d[i]
test4[i] = (cylinder_cpts4[i] /
np.linalg.norm(cylinder_cpts4[i])) * e[i]
test_zeros_loc = np.where(test[:, 2] == 0)[0]
test1_zeros_loc = np.where(test1[:, 2] == 0)[0]
test2_zeros_loc = np.where(test2[:, 2] == 0)[0]
test3_zeros_loc = np.where(test3[:, 2] == 0)[0]
test4_zeros_loc = np.where(test4[:, 2] == 0)[0]
test = remove_3dpoint(test, test_zeros_loc)
test1 = remove_3dpoint(test1, test1_zeros_loc)
test2 = remove_3dpoint(test2, test2_zeros_loc)
test3 = remove_3dpoint(test3, test3_zeros_loc)
test4 = remove_3dpoint(test4, test4_zeros_loc)
test = np.array(
[test[:, 0], test[:, 1],
np.ones(len(test[:, 2])) * ranges[0]]).T
test1 = np.array(
[test1[:, 0], test1[:, 1],
np.ones(len(test1[:, 2])) * ranges[1]]).T
test2 = np.array(
[test2[:, 0], test2[:, 1],
np.ones(len(test2[:, 2])) * ranges[2]]).T
test3 = np.array(
[test3[:, 0], test3[:, 1],
np.ones(len(test3[:, 2])) * ranges[3]]).T
test4 = np.array(
[test4[:, 0], test4[:, 1],
np.ones(len(test4[:, 2])) * ranges[4]]).T
# for i in range(0,len(test1)):
# test1[i] = test1[i] + [0,0,height]
# test2[i] = test2[i]+[0,0,height1]
# test3[i] = test3[i]+[0,0,height2]
test = remove_3dpoint(test, len(test) - 1)
test1 = remove_3dpoint(test1, len(test1) - 1)
test2 = remove_3dpoint(test2, len(test2) - 1)
test3 = remove_3dpoint(test3, len(test3) - 1)
test4 = remove_3dpoint(test4, len(test4) - 1)
# test = np.insert(test,[0,len(test)],[[0,0,-5],[0,0,ranges[0]]],axis=0)
# test1 = np.insert(test1,[0,len(test1)],[0,0,ranges[1]],axis=0)
# test2 = np.insert(test2,[0,len(test2)],[0,0,ranges[2]],axis=0)
test = np.insert(
test,
[len(test) - 2, len(test) - 1, len(test)], [test[0], test[1], test[2]],
axis=0)
test1 = np.insert(
test1, [len(test1) - 2, len(test1) - 1,
len(test1)], [test1[0], test1[1], test1[2]],
axis=0)
test2 = np.insert(
test2, [len(test2) - 2, len(test2) - 1,
len(test2)], [test2[0], test2[1], test2[2]],
axis=0)
test3 = np.insert(
test3, [len(test3) - 2, len(test3) - 1,
len(test3)], [test3[0], test3[1], test3[2]],
axis=0)
test = np.insert(
test4, [len(test4) - 2, len(test4) - 1,
len(test4)], [test4[0], test4[1], test4[2]],
axis=0)
# print(test)
# print(test1)
# print(test2)
# print(test3)
X = np.row_stack((test, test1, test2, test3, test4))
print(X)
# np.random.shuffle(X)
np.savetxt("cpts_test.csv", X, delimiter=",")
# np.savetxt("cpts_test1.csv", test1, delimiter=",")
fig = plt.figure()
ax = plt.axes(projection="3d")
ax.scatter3D(test[:, 0],
test[:, 1],
np.ones(len(test[:, 2])) * ranges[0],
color='red')
ax.scatter3D(test1[:, 0], test1[:, 1], test1[:, 2], color='blue')
ax.scatter3D(test2[:, 0], test2[:, 1], test2[:, 2], color='green')
ax.scatter3D(test3[:, 0], test3[:, 1], test3[:, 2], color='yellow')
ax.scatter3D(test4[:, 0], test4[:, 1], test4[:, 2], color='purple')
# ax.scatter3D(cylinder_cpts[:,0],cylinder_cpts[:,1],cylinder_cpts[:,2])
# ax.scatter3D(cylinder_cpts1[:,0],cylinder_cpts1[:,1],cylinder_cpts1[:,2])
# try fitting a NURBS Surface
surf = NURBS.Surface()
surf.delta = 0.03
p_ctrlpts = exchange.import_csv("cpts_test.csv")
print(len(p_ctrlpts))
p_weights = np.ones((len(p_ctrlpts)))
p_size_u = 9
p_size_v = 5
p_degree_u = 3
p_degree_v = 3
t_ctrlptsw = compat.combine_ctrlpts_weights(p_ctrlpts, p_weights)
n_ctrlptsw = compat.flip_ctrlpts_u(t_ctrlptsw, p_size_u, p_size_v)
n_knotvector_u = utils.generate_knot_vector(p_degree_u, p_size_u)
n_knotvector_v = utils.generate_knot_vector(p_degree_v, p_size_v)
surf.degree_u = p_degree_u
surf.degree_v = p_degree_v
surf.set_ctrlpts(n_ctrlptsw, p_size_u, p_size_v)
surf.knotvector_u = n_knotvector_u
surf.knotvector_v = n_knotvector_v
vis_config = vis.VisConfig(ctrlpts=True, axes=True, legend=True)
surf.vis = vis.VisSurface(vis_config)
surf.evaluate()
surf.render()
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
def plotBsplineSurfaces(self,
left_pts,
right_pts,
corsequences,
lsagsequences,
rsagsequences,
degree=3,
visualization_type=-1):
""" Create B-spline surface
Parameters
----------
left_pts: list
List of tuples with 3D points that represents the left diaphragmatic surface
right_pts: list
List of tuples with 3D points that represents the right diaphragmatic surface
corsequences: list
List of int with the coronal sequences available
lsagsequences: list
List of int with the sagittal sequences available from the left lung
rsagsequences: list
List of int with the sagittal sequences available from the right lung
degree: int
B-spline surface's Degree (Default = 2)
visualization_type: int
-1: (Default) Wireframe plot for the control points and triangulated plot for the surface points
0: Wireframe plot for the control points and scatter plot for the surface points
1: Triangular mesh plot for the surface and wireframe plot for the control points grid
2: Scatter plot for the control points and wireframe for the surface points
"""
left_surface = self.createBsplineSurface(pts=left_pts,
corsequences=corsequences,
sagsequences=lsagsequences)
right_surface = self.createBsplineSurface(pts=right_pts,
corsequences=corsequences,
sagsequences=rsagsequences)
# Create a MultiSurface
surfaces = Multi.MultiSurface()
surfaces.add(left_surface)
surfaces.add(right_surface)
# Set visualization component
if visualization_type == 0:
surfaces.delta = 0.01
vis_comp = VisMPL.VisSurfScatter()
elif visualization_type == 1:
vis_comp = VisMPL.VisSurface()
elif visualization_type == 2:
vis_comp = VisMPL.VisSurfWireframe()
else:
vis_comp = VisMPL.VisSurfTriangle()
surfaces.vis = vis_comp
# Render the surface
surfaces.render()
name="u",
color="red",
size=10
),
dict(
points=surf_curves['v'][0].evalpts,
name="v",
color="black",
size=10
)
]
toroid_pcl = np.array(surf.evalpts)
np.savetxt("tapered_toroid_pcl.csv",toroid_pcl,delimiter = ',')
toroid_cpts = np.array(surf.ctrlpts)
np.savetxt("toroid_cpts.csv",toroid_cpts,delimiter = ',',fmt = "%1.3f")
print(len(toroid_cpts))
# np.savetxt("cpts_bezier.dat",r,delimiter = ',')
# from matplotlib import cm
surf.delta = 0.03
surf.vis = vis.VisSurface()
surf.render(extras=plot_extras)
exchange.export_obj(surf, "tapered_toroid.obj")
np.savetxt("tapered_toroid.dat",toroid_pcl,delimiter = ' ')
# np.savetxt("tube_cpts.dat",tube_cpts,delimiter = ' ')
plt.show()
def vis_spline_surf(self, surf):
surf.vis = VisMPL.VisSurface()
surf.render()
# Fix file path
os.chdir(os.path.dirname(os.path.realpath(__file__)))
# Create a BSpline surface instance (Bezier surface)
surf = BSpline.Surface()
# Set up the Bezier surface
surf.degree_u = 3
surf.degree_v = 2
control_points = [[0, 0, 0], [0, 4, 0], [0, 8, -3], [2, 0, 6], [2, 4, 0],
[2, 8, 0], [4, 0, 0], [4, 4, 0], [4, 8, 3], [6, 0, 0],
[6, 4, -3], [6, 8, 0]]
surf.set_ctrlpts(control_points, 4, 3)
surf.knotvector_u = utilities.generate_knot_vector(surf.degree_u,
surf.ctrlpts_size_u)
surf.knotvector_v = utilities.generate_knot_vector(surf.degree_v,
surf.ctrlpts_size_v)
# Set sample size
surf.sample_size = 25
# Evaluate surface
surf.evaluate()
# Plot the control point grid and the evaluated surface
vis_comp = VisMPL.VisSurface()
surf.vis = vis_comp
surf.render()
pass
def vis_multiple_spline_surf(self, surfs):
mcrv = multi.SurfaceContainer([surf, surf1])
mcrv.vis = VisMPL.VisSurface()
mcrv.render()
surf1.set_ctrlpts(
*exchange.import_txt("ex_surface01.cpt", two_dimensional=True))
# Set knot vectors
surf1.knotvector_u = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
surf1.knotvector_v = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
# Set evaluation delta
surf1.delta = 0.025
# Rotate surf1 and generate a copy in surf2
surf2 = operations.rotate(surf1, 45, axis=2)
# Visualize surfaces
msurf1 = multi.SurfaceContainer(surf1, surf2)
msurf1.vis = vis.VisSurface()
msurf1.render()
# Decompose surf1
surf1_decomposed = operations.decompose_surface(surf1)
msurf2 = multi.SurfaceContainer(surf1_decomposed)
# Rotate decomposed surface
msurf2_rotated = operations.rotate(msurf2, 90, axis=1)
# Visualize decomposed and decomposed-rotated surfaces
msurf3 = multi.SurfaceContainer(msurf2, msurf2_rotated)
msurf3.vis = vis.VisSurface()
msurf3.render()
# Good to have something here to put a breakpoint
def _execute(self):
print('Process of field surface evaluation started')
start = time.time()
if not os.path.exists(self.path + 'surface_evaluation/'):
os.makedirs(self.path + 'surface_evaluation/')
odP = outlier_detector_Parameters()
tfP = terrain_filter_Parameters()
tgP = terrain_grid_Parameters()
sfP = surface_fit_Parameters()
out_flag = self.outlier_detector(points=self.dws_point_cloud,
metric=odP.METRIC,
method=odP.METHOD,
radius=odP.RADIUS,
deviance=odP.DEVIANCE,
K=odP.K)
store_point_cloud(self.path + 'surface_evaluation/' + "clean_roi.las",
self.dws_point_cloud[out_flag, :], self.header)
save_img(self.dws_point_cloud[out_flag, :], 'clean_roi_0_0',
self.path + 'surface_evaluation/', 0, 0)
save_img(self.dws_point_cloud[out_flag, :], 'clean_roi_0_90',
self.path + 'surface_evaluation/', 0, 90)
print('outliers removed .....')
terrain_points = self.terrain_filter(
points=self.dws_point_cloud[out_flag, :],
method=tfP.METHOD,
window_size=tfP.WINDOW_SIZE,
window_stride=tfP.WINDOW_STRIDE,
quantile=tfP.WINDOW_QUANTILE,
k=tfP.K)
print('terrain points founded .....')
terrain_grid_points = self.terrain_grid(
points=terrain_points,
metric=tgP.METRIC,
K=tgP.K,
grid_resolution=tgP.GRID_RESOLUTION)
print('terrain grid was formed .....')
surface = self.surface_fit(terrain_grid=terrain_grid_points,
grid_resolution=tgP.GRID_RESOLUTION,
u_degree=sfP.U_DEGREE,
v_degree=sfP.V_DEGREE,
delta=sfP.DELTA)
# Create a visualization configuration instance with no legend, no axes and set the resolution to 120 dpi
vis_config = VisMPL.VisConfig(ctrlpts=False, axes_equal=False)
# Create a visualization method instance using the configuration above
vis_obj = VisMPL.VisSurface(vis_config)
# Set the visualization method of the curve object
surface.vis = vis_obj
surface.render(filename=self.path + 'surface_evaluation/' +
"terrain.png",
colormap=cm.cool,
plot=False)
print('surface was modeled .....')
# Get the evaluated points
surface_points = np.array(surface.evalpts)
print('de-terrain points process')
deTerreained_points = np.zeros_like(self.dws_point_cloud[out_flag, :])
for i, point in enumerate(tqdm(self.dws_point_cloud[out_flag, :])):
clean_point = point.copy()
point_dist = np.array(
((surface_points[:, 0] - point[0])**2 +
(surface_points[:, 1] - point[1])**2)**(0.5))
clean_point[2] = clean_point[2] - surface_points[
np.argmin(point_dist), 2]
deTerreained_points[i] = clean_point
deTerreained_points[:, 2] = deTerreained_points[:, 2] + np.abs(
deTerreained_points[:, 2].min())
store_point_cloud(
self.path + 'surface_evaluation/' + "de-terrained_roi.las",
deTerreained_points, self.header)
save_img(deTerreained_points, 'de-terrained_roi_0_0',
self.path + 'surface_evaluation/', 0, 0)
save_img(deTerreained_points, 'de-terrained_roi_0_90',
self.path + 'surface_evaluation/', 0, 90)
print('point cloud was de-terrained ......')
end = time.time()
print('Time:{}'.format(end - start))
import numpy as np
import matplotlib.pyplot as plt
from geomdl import fitting
from geomdl import convert
from geomdl import construct
from geomdl.visualization import VisMPL as vis
import sys
np.set_printoptions(threshold=sys.maxsize)
from tools import preProcess
from geomdl import exchange
from geomdl import knotvector
from geomdl import BSpline
from generateHelix import helix
ctrlpts = np.loadtxt("test1.txt")
np.savetxt("candidate_cpts.csv", ctrlpts, delimiter=',')
helix = helix()
c = np.array(helix.ctrlpts)
print(c)
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.scatter(c[:, 0], c[:, 1], c[:, 2])
helix.ctrlpts = ctrlpts
helix.delta = 0.015
helix.vis = vis.VisSurface()
helix.render()
exchange.export_obj(helix, "trial0.obj")
[-15.0, 15.0, 0.0, 1.0], [-25.0, 15.0, 0.0, 1.0]],
[[25.0, 25.0, 0.0, 1.0], [15.0, 25.0, 0.0, 1.0],
[5.0, 25.0, 5.0, 1.0], [-5.0, 25.0, 5.0, 1.0],
[-15.0, 25.0, 0.0, 1.0], [-25.0, 25.0, 0.0, 1.0]]]
# Generate surface
surf = NURBS.Surface()
surf.degree_u = 3
surf.degree_v = 3
surf.ctrlpts2d = ctrlpts
surf.knotvector_u = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
surf.knotvector_v = [0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 3.0, 3.0, 3.0]
surf.sample_size = 30
# Set visualization component
surf.vis = VisMPL.VisSurface(
VisMPL.VisConfig(alpha=0.75, figure_size=[10.66, 8]))
# Visualize
surf.render(filename="surf01.png", plot=False)
# Create a deep copy of the surface
surf_refined = deepcopy(surf)
# Refine knot vectors
operations.refine_knotvector(surf_refined, [1, 1])
# Visualize after knot vector refinement
surf_refined.render(filename="surf02.png", plot=False)
# Create a deep copy of the surface
surf_refined = deepcopy(surf)
