def grid(gs):
g = gs + 1
beta = math.sqrt(np.pi / 6)
num = 300
h_x = np.linspace(-beta, beta, g)
h_y = np.linspace(-beta, beta, num)
hl = np.transpose([np.tile(h_x, len(h_y)), np.repeat(h_y, len(h_x))])
h_z = np.zeros(len(hl))
h_z.fill(beta)
hln = np.column_stack((hl[:, 0], hl[:, 1], h_z))
hln = np.concatenate((hln, np.column_stack((hl[:, 0], hl[:, 1], -h_z))))
hln = np.concatenate((hln, np.column_stack((hl[:, 0], h_z, hl[:, 1]))))
hln = np.concatenate((hln, np.column_stack((hl[:, 0], -h_z, hl[:, 1]))))
hln = np.concatenate((hln, np.column_stack((h_z, hl[:, 0], hl[:, 1]))))
hln = np.concatenate((hln, np.column_stack((-h_z, hl[:, 0], hl[:, 1]))))
v_x = np.linspace(-beta, beta, num)
v_y = np.linspace(-beta, beta, g)
vl = np.transpose([np.tile(v_x, len(v_y)), np.repeat(v_y, len(v_x))])
vln = np.column_stack((vl[:, 0], vl[:, 1], h_z))
vln = np.concatenate((vln, np.column_stack((vl[:, 0], vl[:, 1], -h_z))))
vln = np.concatenate((vln, np.column_stack((vl[:, 0], h_z, vl[:, 1]))))
vln = np.concatenate((vln, np.column_stack((vl[:, 0], -h_z, vl[:, 1]))))
vln = np.concatenate((vln, np.column_stack((h_z, vl[:, 0], vl[:, 1]))))
vln = np.concatenate((vln, np.column_stack((-h_z, vl[:, 0], vl[:, 1]))))
grid_lines = np.concatenate((hln, vln))
grid_lines_sphr = GBt.unique_rows_tol(mf.cube2sphr_2d(grid_lines), tol=1e-06)
return grid_lines_sphr
def pick_ctr(bp, l_rcsl_go, mt_cslr_go, grid_ctr, tol=1e-06):
bpn = np.copy(bp)
if len(bpn) == 1:
return bpn, np.array([])
bpn_sphr = mf.cube2sphr_2d(bpn)
mil_sphr = np.dot(np.linalg.inv(l_rcsl_go), bpn_sphr.transpose()).transpose()
mil_sphr = GBim.int_finder(mil_sphr, tol=1e-06, order="rows")
d_inv_sqr = np.diag(np.dot(np.dot(mil_sphr, mt_cslr_go), mil_sphr.transpose()))
d_inv_sqr_min = np.min(d_inv_sqr)
cond = np.abs(d_inv_sqr - d_inv_sqr_min) <= tol
# ind1 = np.where(cond)
bpn_min = bpn[cond]
num_bpn_min = len(bpn_min)
d_ctr = np.zeros(num_bpn_min)
for ct1 in range(num_bpn_min):
pt = bpn_min[ct1]
d_ctr[ct1] = np.sqrt((grid_ctr[0] - pt[0]) ** 2 + (grid_ctr[1] - pt[1]) ** 2)
ind = np.argsort(d_ctr)
bpn_pick = bpn_min[ind][0]
ind_r = np.where((bpn[:, 0] == bpn_pick[0]) & (bpn[:, 1] == bpn_pick[1]) & (bpn[:, 2] == bpn_pick[2]))[0]
return bpn_pick, ind_r
def bpn_in_grid(bpn, grid, n, l_rcsl_go, mt_rcsl_go, tol=1e-06):
bpn_c = mf.sphr2cube_2d(bpn)
beta = math.sqrt(np.pi / 6)
cond1 = abs(bpn_c[:, 0] - beta) < tol
bpn1 = np.copy(bpn_c[cond1])
bpn11 = bpn1[:, [1, 2]]
bpn_c = np.delete(bpn_c, np.where(cond1)[0], 0)
cond2 = abs(bpn_c[:, 0] + beta) < tol
bpn2 = np.copy(bpn_c[cond2])
bpn22 = bpn2[:, [1, 2]]
bpn_c = np.delete(bpn_c, np.where(cond2)[0], 0)
cond3 = abs(bpn_c[:, 1] - beta) < tol
bpn3 = np.copy(bpn_c[cond3])
bpn33 = bpn3[:, [2, 0]]
bpn_c = np.delete(bpn_c, np.where(cond3)[0], 0)
cond4 = abs(bpn_c[:, 1] + beta) < tol
bpn4 = np.copy(bpn_c[cond4])
bpn44 = bpn4[:, [2, 0]]
bpn_c = np.delete(bpn_c, np.where(cond4)[0], 0)
cond5 = abs(bpn_c[:, 2] - beta) < tol
bpn5 = np.copy(bpn_c[cond5])
bpn55 = bpn5[:, [0, 1]]
bpn_c = np.delete(bpn_c, np.where(cond5)[0], 0)
cond6 = abs(bpn_c[:, 2] + beta) < tol
bpn6 = np.copy(bpn_c[cond6])
bpn66 = bpn6[:, [0, 1]]
bpn_c = np.delete(bpn_c, np.where(cond6)[0], 0)
if len(bpn_c) != 0:
raise "Algorithm is incorrect!"
bpn_cc = [bpn11, bpn22, bpn33, bpn44, bpn55, bpn66]
num_bpn = 6 * n * n
bpn_grid = np.zeros((num_bpn, 3))
for ct1 in range(len(bpn_cc)):
bpn_l = bpn_cc[ct1]
for ct2 in range(len(grid)):
num_bpn = num_bpn - 1
g = grid[ct2]
g_x = g[0]
g_y = g[1]
a_lt_u = g_x + beta / n
a_lt_l = g_x - beta / n
b_lt_u = g_y + beta / n
b_lt_l = g_y - beta / n
tol1 = 1e-06
cond1a = (a_lt_l - bpn_l[:, 0]) < tol1
cond1b = (bpn_l[:, 0] - a_lt_u) < tol1
cond1 = cond1a & cond1b
cond2a = (b_lt_l - bpn_l[:, 1]) < tol1
cond2b = (bpn_l[:, 1] - b_lt_u) < tol1
cond2 = cond2a & cond2b
cond = cond1 & cond2
if np.any(cond):
if ct1 == 0:
bpn_pick, ind = pick_ctr(bpn1, l_rcsl_go, mt_rcsl_go, g)
bpn1 = np.delete(bpn1, ind, 0)
bpn_grid[num_bpn, :] = bpn_pick
elif ct1 == 1:
bpn_pick, ind = pick_ctr(bpn2, l_rcsl_go, mt_rcsl_go, g)
bpn2 = np.delete(bpn2, ind, 0)
bpn_grid[num_bpn, :] = bpn_pick
elif ct1 == 2:
bpn_pick, ind = pick_ctr(bpn3, l_rcsl_go, mt_rcsl_go, g)
bpn3 = np.delete(bpn3, ind, 0)
bpn_grid[num_bpn, :] = bpn_pick
elif ct1 == 3:
bpn_pick, ind = pick_ctr(bpn4, l_rcsl_go, mt_rcsl_go, g)
bpn4 = np.delete(bpn4, ind, 0)
bpn_grid[num_bpn, :] = bpn_pick
elif ct1 == 4:
bpn_pick, ind = pick_ctr(bpn5, l_rcsl_go, mt_rcsl_go, g)
bpn5 = np.delete(bpn5, ind, 0)
bpn_grid[num_bpn, :] = bpn_pick
elif ct1 == 5:
bpn_pick, ind = pick_ctr(bpn6, l_rcsl_go, mt_rcsl_go, g)
bpn6 = np.delete(bpn6, ind, 0)
bpn_grid[num_bpn, :] = bpn_pick
bpn_l = np.delete(bpn_l, ind, 0)
else:
raise "Insufficient normals to sample!"
bpn_grid_sphr = mf.cube2sphr_2d(bpn_grid)
return bpn_grid_sphr
