def vertices(N, points):
# N = No. of slices - 1
slice(N, points)
slices = slice.slices
ranges = slice.bins
hull_array = []
for i in range(0, len(slices)):
hull_array.append(ConvexHull(slices[i][:, 0:2]))
# initialize simplices and vertices list arrays
simplices = []
vertices = []
# get the simplex at each slice
for i in range(0, len(slices)):
for simplex in hull_array[i].simplices:
# plt.plot(slices[i][simplex, 0], slices[i][simplex, 1], "k-")
simplices.append(slices[i][simplex[:]])
# get the vertices at each slice
for i in range(0, len(slices)):
vertices.append([
slices[i][hull_array[i].vertices[:], 0],
slices[i][hull_array[i].vertices[:], 1],
np.ones(
(len(slices[i][hull_array[i].vertices[:], 0]))) * ranges[i],
])
# store xyz points and set vertex layers
vertex_layers = []
for i in range(0, len(vertices)):
vertex_layers.append(
np.array([vertices[i][0], vertices[i][1], vertices[i][2]]).T)
# append all of the layers into one array from least to greatest
test = []
for i in range(0, len(vertex_layers)):
np.random.shuffle(vertex_layers[i])
test.append(vertex_layers[i][:])
temp = []
for i in range(0, len(test)):
for j in range(0, len(test[i])):
temp.append(test[i][j])
convex_vertices = np.array(temp)
print(len(convex_vertices))
fig = plt.figure()
ax = plt.axes(projection="3d")
ax.scatter3D(convex_vertices[:, 0], convex_vertices[:, 1],
convex_vertices[:, 2])
plt.show()
return convex_vertices
def twiddle_1(a_re,a_im,bw_re,bw_im,sync_out,clk,sync,a,b,Coeffs,FFTSize,FFTStage):
""" Twiddle Block for FFT Stage = 1
"""
a_re1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
a_im1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
b_re1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
b_im1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
b_re11 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
b_im11 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
bb_im11 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
sync_cnt = Signal(bool())
sel = Signal(bool())
count_out = Signal(intbv()[16:])
slice_a_re = slice.slice(dout = a_re1, clk = clk, slice_mode = 0, SLICE_WIDTH = DATA_WIDTH, din = a)
delay0 = Delay.Delay(dout = a_re, din = a_re1, Delay = 6, clk = clk )
slice_a_im = slice.slice(dout = a_im1, clk = clk, slice_mode = 1,SLICE_WIDTH = DATA_WIDTH, din = a)
delay1 = Delay.Delay(dout = a_im, din = a_im1, Delay = 6, clk = clk)
slice_b_re = slice.slice(dout = b_re1, clk = clk, slice_mode = 0, SLICE_WIDH = DATA_WIDTH, din = b)
delay2 = Delay.Delay(dout = b_re11, din = b_re1, Delay = 2, clk = clk )
slice_b_im = slice.slice(dout = b_im1, clk = clk, slice_mode = 1, SLICE_MODE = DATA_WIDTH, din = b)
delay7 = Delay.Delay(dout = b_im11, din = b_im1, Delay = 2, clk = clk )
delay5 = Delay.Delay(dout = sync_cnt, din = sync, Delay = 2, clk = clk )
counter = counter_d.counter_d(count_out, clk, 1, sync_cnt, 1,1,0,(2**FFTStage - 1))
#slice_m(dout, clk, slice_mode,offset,SLICE_WIDTH, din)
slice_cnt = slice_m.slice_m(dout = sel, clk = clk, slice_mode = 2, offset =1,SLICE_WIDTH = 0, din = count_out)
delay6 = Delay.Delay(dout = sync_out, din = sync_cnt, Delay = 4, clk = clk )
@always(clk.posedge)
def twiddle1_logic():
bb_im11.next = -1*b_im11
mux0 = mux_2_1(bw_re,clk,sel,b_re11,b_im11)
mux1 = mux_2_1(bw_im,clk,sel,b_im11,bb_im11) # add output from the negate block
return twiddle1_logic,slice_a_re,slice_a_im,slice_b_re,slice_b_im,counter,mux0,mux1,slice_cnt,delay0,delay1,delay2,delay6
def twiddle_0(a_re,a_im,bw_re,bw_im,sync_out,clk,sync,a,b,Coeffs,FFTSize,FFTStage):
""" Twiddle block for FFT Stage = 0
Twiddle Coeffs = 0
"""
#slice(dout, clk, slice_mode,SLICE_WIDTH, din)
slice_a_re = slice.slice(dout = a_re, clk = clk, slice_mode = 0,SLICE_WIDTH = DATA_WIDTH,din = a)
slice_a_im = slice.slice(dout = a_im, clk =clk,slice_mode = 1,SLICE_WIDTH = DATA_WIDTH, din = a)
slice_b_re = slice.slice(dout = bw_re, clk = clk, slice_mode = 0, SLICE_WIDTH = DATA_WIDTH, din = b)
slice_b_im = slice.slice(dout = bw_im, clk = clk, slice_mode = 1, SLICE_WIDTH = DATA_WIDTH, din = b)
@always(clk.posedge)
def twiddle_0_logic():
sync_out.next = sync
return slice_a_re,slice_a_im,slice_b_re,slice_b_im,twiddle_0_logic
def twiddlea(a_re,a_im,bw_re,bw_im,sync_out,clk,sync,a,b,Coeffs,FFTSize,FFTStage):
a_c = Signal(intbv(0, min=0, max=2**(2*DATA_WIDTH)))
a_re1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
a_im1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
delay_a = Delay.Delay(dout = a_c, din = a, Delay = 6, clk = clk)
slice_a_re = slice.slice(dout = a_re, clk = clk, slice_mode = 0, SLICE_WIDTH = DATA_WIDTH, din = a_c)
slice_a_im = slice.slice(dout = a_im, clk = clk, slice_mode = 1, SLICE_WIDTH = DATA_WIDTH, din = a_c)
b_c = Signal(intbv(0, min=0, max=2**(2*DATA_WIDTH)))
b_re1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
b_im1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1 ))))
delay_b = Delay.Delay(dout = b_c, din = b, Delay = 2, clk = clk)
slice_b_re = slice.slice(dout = b_re1, clk = clk, slice_mode = 0, SLICE_WIDTH = DATA_WIDTH, din = b)
slice_b_im = slice.slice(dout = b_im1, clk = clk, slice_mode = 1, SLICE_WIDTH = DATA_WIDTH, din = b)
delay_sync = Delay.Delay(dout = sync_out, din = sync, Delay = 6, clk = clk)
br_indices = bit_reverse(Coeffs,clk)
ComplexCoeffs = np.exp(-2*np.pi*1j*np.array(br_indices)/2**FFTSize)
w = Signal(intbv(0, min=0, max=2**(2*DATA_WIDTH)))
w_re = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
w_im = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
#coeff_gen(sync, w,clk,CONTENT,FFTSize,FFTStage)
coeff_gen_1 = coeff_gen.coeff_gen(syncIn = sync, Out = w, clkIn = clk, CONTENT = ComplexCoeffs, FFTSize = FFTSize, FFTStage = FFTStage)
slice_coeff_gen_1 = slice.slice(dout = w_re, clk = clk, slice_mode = 0, SLICE_WIDTH = DATA_WIDTH, din = w)
slice_coeff_gen_2 = slice.slice(dout = w_im, clk = clk, slice_mode = 1, SLICE_WIDTH = DATA_WIDTH, din = w)
bw_re1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
bw_im1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
#mult_0 = signed_multiplier.complex_multiplier_IO_reg(bw_re,bw_im,clk,ena = 1,b_re1,b_im1,w_re,w_im,DATA_WIDTH)
return delay_a, slice_a_re, slice_a_im, delay_b, slice_b_re, slice_b_im, delay_sync, slice_coeff_gen_1, slice_coeff_gen_2, mult_0, coeff_gen_1,
def twiddlea(a_re,a_im,bw_re,bw_im,sync_out,clk,sync,a,b,Coeffs,FFTSize,FFTStage):
a_c = Signal(intbv(0, min=0, max=2**(2*DATA_WIDTH)))
a_re1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
a_im1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH-1 ))))
delay_a = Delay.Delay(dout = a_c, din = a, Delay = 6, clk = clk)
slice_a_re = slice.slice(dout = a_re, clk = clk, slice_mode = 0, SLICE_WIDTH = DATA_WIDTH, din = a_c)
slice_a_im = slice.slice(dout = a_im, clk = clk, slice_mode = 1, SLICE_WIDTH = DATA_WIDTH, din = a_c)
b_c = Signal(intbv(0, min=0, max=2**(2*DATA_WIDTH)))
b_re1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
b_im1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1 ))))
delay_b = Delay.Delay(dout = b_c, din = b, Delay = 2, clk = clk)
slice_b_re = slice.slice(dout = b_re1, clk = clk, slice_mode = 0, SLICE_WIDTH = DATA_WIDTH, din = b)
slice_b_im = slice.slice(dout = b_im1, clk = clk, slice_mode = 1, SLICE_WIDTH = DATA_WIDTH, din = b)
delay_sync = Delay.Delay(dout = sync_out, din = sync, Delay = 6, clk = clk)
br_indices = bit_reverse(Coeffs,clk)
ComplexCoeffs = np.exp(-2*np.pi*1j*np.array(br_indices)/2**FFTSize)
w = Signal(intbv(0, min=0, max=2**(2*DATA_WIDTH)))
w_re = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
w_im = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
#coeff_gen(sync, w,clk,CONTENT,FFTSize,FFTStage)
coeff_gen_1 = coeff_gen.coeff_gen(syncIn = sync, Out = w, clkIn = clk, CONTENT = ComplexCoeffs, FFTSize = FFTSize, FFTStage = FFTStage)
slice_coeff_gen_1 = slice.slice(dout = w_re, clk = clk, slice_mode = 0, SLICE_WIDTH = DATA_WIDTH, din = w)
slice_coeff_gen_2 = slice.slice(dout = w_im, clk = clk, slice_mode = 1, SLICE_WIDTH = DATA_WIDTH, din = w)
bw_re1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
bw_im1 = Signal(intbv(0, min=-2**(DATA_WIDTH - 1), max=(2**(DATA_WIDTH -1))))
mult_0 = signed_multiplier.complex_multiplier_IO_reg(bw_re,bw_im,clk,ena = 1,b_re1,b_im1,w_re,w_im,DATA_WIDTH)
return delay_a, slice_a_re, slice_a_im, delay_b, slice_b_re, slice_b_im, delay_sync, slice_coeff_gen_1, slice_coeff_gen_2, mult_0, coeff_gen_1,
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
import os
# logging.disable(sys.maxsize)
ptsz = 256
loc = "data/"
import logging
logging.basicConfig(level=logging.DEBUG,
format=' %(asctime)s - %(levelname)s- %(message)s')
sat = io.imread(loc+"sat/4.tif")
gt = io.imread(loc+"gt/4.tif")
finalShape = gt.shape
logging.debug("sat.shape:" + str(sat.shape) + "\tgt.shape:" + str(gt.shape))
satref, gtref = refPad(sat,ptsz), refPad(gt, ptsz)
logging.debug("satref.shape:"+str(satref.shape)+"\tgtref.shape:"+str(gtref.shape))
satPatchs, gtPatchs = slice(satref, gtref, ptsz)
logging.debug("satPatchs.shape:"+str(satPatchs.shape)+"\tgtPatchs.shape:"+str(gtPatchs.shape))
stitchedGt = stitch(gtPatchs, gtref.shape[:2])
logging.debug("Patchs of GT stiched")
logging.debug("Images Saved with shape " + str(finalShape))
io.imsave("test.tif", stitchedGt[:finalShape[0],:finalShape[1]])
t.append([data[i][:, 0], data[i][:, 1], data[i][:, 2]])
# ax.scatter(t[i][:, 0], t[i][:, 1], t[i][:, 2])
data = np.array(t)
for i in range(len(data)):
ax.scatter(data[i][0], data[i][1], data[i][2])
return data
data = np.loadtxt('D:/Workspace/RV-Fitting/rv_data/N2_RV_P0.dat')
fig = plt.figure()
ax = plt.axes(projection='3d')
# ax.scatter(data[:,0],data[:,1],data[:,2])
N = 5
slice(N, data)
bins = slice.bins
mean_per_slice = []
# slice.slices.pop(0)
# slice.slices.pop(-1)
temp = []
for i in range(0, len(slice.slices)):
# ax.scatter(slice.slices[i][:,0],slice.slices[i][:,1],slice.slices[i][:,2])
temp.append(
[slice.slices[i][:, 0], slice.slices[i][:, 1], slice.slices[i][:, 2]])
mean_per_slice.append([
np.mean(slice.slices[i][:, 0]),
np.mean(slice.slices[i][:, 1]),
np.mean(slice.slices[i][:, 2])
])
import Delay
#import ROM
import slice
import slice_m
import bit_reverse
import counter_d
import array
DATA_WIDTH = 18
def twiddle_0(a_re,a_im,bw_re,bw_im,sync_out,clk,sync,a,b,Coeffs,FFTSize,FFTStage):
""" Twiddle block for FFT Stage = 0
Twiddle Coeffs = 0
"""
#slice(dout, clk, slice_mode,SLICE_WIDTH, din)
slice_a_re = slice.slice(dout = a_re, clk = clk, slice_mode = 0,SLICE_WIDTH = DATA_WIDTH,din = a)
slice_a_im = slice.slice(dout = a_im, clk =clk,slice_mode = 1,SLICE_WIDTH = DATA_WIDTH, din = a)
slice_b_re = slice.slice(dout = bw_re, clk = clk, slice_mode = 0, SLICE_WIDTH = DATA_WIDTH, din = b)
slice_b_im = slice.slice(dout = bw_im, clk = clk, slice_mode = 1, SLICE_WIDTH = DATA_WIDTH, din = b)
@always(clk.posedge)
def twiddle_0_logic():
sync_out.next = sync
return slice_a_re,slice_a_im,slice_b_re,slice_b_im,twiddle_0_logic
def twiddle_1(a_re,a_im,bw_re,bw_im,sync_out,clk,sync,a,b,Coeffs,FFTSize,FFTStage):
""" Twiddle Block for FFT Stage = 1
deln = points[Delaunay(hull).simplices]
vols = np.abs(
det(deln[:, :dims, :] - deln[:, dims:, :])) / np.math.factorial(dims)
sample = np.random.choice(len(vols), size=n, p=vols / vols.sum())
return np.einsum('ijk, ij -> ik', deln[sample],
dirichlet.rvs([1] * (dims + 1), size=n))
ed_rv = np.loadtxt("trimmed_RVendo_20.txt")
# ed_rv = np.loadtxt("RVshape\\RVendo_0.txt")
# ed_rv = np.array([ed_rv[:,0],ed_rv[:,1],-ed_rv[:,2]]).T*1000
N = 4
slice(N, ed_rv)
X = np.array(slice.slices)
print(len(X))
top_layer = np.array(X[-1])
tv = []
pv = []
tv.append(top_layer[top_layer[:, 0] >= max(top_layer[:, 0]) - 37])
pv.append(top_layer[top_layer[:, 0] <= max(top_layer[:, 0]) - 47])
tv = np.array(tv)[0]
pv = np.array(pv)[0]
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.scatter(ed_rv[:, 0], ed_rv[:, 1], ed_rv[:, 2])
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
for i in range(len(data)):
t.append(cart(data[i][:, 0], data[i][:, 1], data[i][:, 2]))
# ax.scatter(t[i][:, 0], t[i][:, 1], t[i][:, 2])
data = np.array(t)
# for i in range(len(data)):
# ax.scatter(data[i][0], data[i][1], data[i][2])
return data
# load data
points = np.loadtxt("N2_RV_P0.txt")
# split data into slices
N = 14
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
data = np.array(t)
for i in range(len(data)):
ax.scatter(data[i][0], data[i][1], data[i][2])
return data
cyl_pcl = np.loadtxt("test.txt")
fig = plt.figure()
ax = plt.axes(projection="3d")
ax.scatter(cyl_pcl[:, 0], cyl_pcl[:, 1], cyl_pcl[:, 2])
# split data into slices
N = 5
slice(N, cyl_pcl)
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]])
def get_the_ros(self):
"""选取待匹配的特征块
将灰度图像选取特定区域，并转换维度为(?, 32, 32, 1)
"""
self.ros1, self.loc1 = slice(self.image1)
self.ros2, self.loc2 = slice(self.image2)
def main():
# N = No. of slices - 1
N = 6
points = np.loadtxt("N2_RV_P0.txt")
# test = np.loadtxt("N2ED_cpts.txt")
slice(N, points)
slices = slice.slices
slice1 = slice.slices[0]
ranges = slice.bins
# np.savetxt("N2_RV_P0.csv", points, delimiter=",")
fig = plt.figure()
ax = plt.axes(projection="3d")
# A = []
# for i in range(0,len(slices)):
# A.append((slices[i][(slices[i][:,2] == slices[i][:,2].max())]))
# ax.scatter(A[i][0][0],A[i][0][1],A[i][0][2])
# np.savetxt("slice1.csv", slice1, delimiter=",")
# np.savetxt("N2ED_cpts.csv", test, delimiter=",")
hull_array = []
for i in range(0, len(slices)):
hull_array.append(ConvexHull(slices[i][:, 0:2]))
# initialize simplices and vertices list arrays
simplices = []
vertices = []
# get the simplex at each slice
for i in range(0, len(slices)):
for simplex in hull_array[i].simplices:
# plt.plot(slices[i][simplex, 0], slices[i][simplex, 1], "k-")
simplices.append(slices[i][simplex[:]])
# get the vertices at each slice
for i in range(0, len(slices)):
# ax.scatter3D(
# slices[i][hull_array[i].vertices[:], 0],
# slices[i][hull_array[i].vertices[:], 1],
# np.ones((len(slices[i][hull_array[i].vertices[:], 1]))) * ranges[i],
# )
vertices.append([
slices[i][hull_array[i].vertices[:], 0],
slices[i][hull_array[i].vertices[:], 1],
np.ones(
(len(slices[i][hull_array[i].vertices[:], 0]))) * ranges[i],
])
# store xyz points and set vertex layers
vertex_layer1 = np.array([vertices[0][0], vertices[0][1],
vertices[0][2]]).T
vertex_layer2 = np.array([vertices[1][0], vertices[1][1],
vertices[1][2]]).T
vertex_layer3 = np.array([vertices[2][0], vertices[2][1],
vertices[2][2]]).T
vertex_layer4 = np.array([vertices[3][0], vertices[3][1],
vertices[3][2]]).T
vertex_layer5 = np.array([vertices[4][0], vertices[4][1],
vertices[4][2]]).T
vertex_layer6 = np.array([vertices[5][0], vertices[5][1],
vertices[5][2]]).T
# store vertex layers into array
vertex_layers = np.array([
vertex_layer1, vertex_layer2, vertex_layer3, vertex_layer4,
vertex_layer5, vertex_layer6
])
#append all of the layers into one array from least to greatest
test = []
for i in range(0, len(vertex_layers)):
np.random.shuffle(vertex_layers[i])
test.append(vertex_layers[i][:])
temp = []
for i in range(0, len(test)):
for j in range(0, len(test[i])):
temp.append(test[i][j])
convex_vertices = np.array(temp)
ax.scatter3D(convex_vertices[:, 0], convex_vertices[:, 1],
convex_vertices[:, 2])
plt.show()
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('-o',
'--order',
nargs='+',
help='<optional> node traversal ordering',
required=False)
parser.add_argument(
'--slice-all-nodes',
help=
'<optional> flag, whether to slice all xml nodes or just the ones related to code blocks',
action='store_true')
parser.add_argument(
'--slice-only-order',
help=
'<optional> flag, whether to slice just the nodes listed in -o order',
action='store_true')
args = parser.parse_args()
if args.order is None:
args.order = []
print('=' * 10 + 'slice.py' + '=' * 10)
print(args)
config = init_slicer('~/Scratch/work-dir/myriad/config.json')
import json
print(json.dumps(config, indent=4))
# TODO add directory as an order option
slice(config['project_dir'], config['target_file'], args.order)
print(calc_slice_reduction(config['project_dir'], config['target_file']))
