def speedup(loc, coeff, img, rgb, show_res):
'''
This test measures the performance of the two implementation
from initialisation to the end of the cortical transform
'''
init_p = time.time()
GI = retina.gauss_norm_img(int(img.shape[1] / 2), int(img.shape[0] / 2),
coeff, loc, img.shape, rgb)
init_c = time.time()
ret = retina_cuda.create_retina(
loc, coeff, img.shape, (int(img.shape[1] / 2), int(img.shape[0] / 2)))
sample_p = time.time()
V_p = retina.sample(img, img.shape[1] / 2, img.shape[0] / 2, coeff, loc,
rgb)
sample_c = time.time()
V_c = ret.sample(img)
invert_p = time.time()
inv_p = retina.inverse(V_p, img.shape[1] / 2, img.shape[0] / 2, coeff, loc,
GI, img.shape, rgb)
invert_c = time.time()
inv_c = ret.inverse(V_c)
retina_end = time.time()
cort_init_p = time.time()
L, R = cortex.LRsplit(loc)
L_loc, R_loc = cortex.cort_map(L, R)
L_loc, R_loc, G, cort_size = cortex.cort_prepare(L_loc, R_loc)
cort_init_c = time.time()
cort = cortex_cuda.create_cortex_from_fields(loc, rgb=rgb)
cort_img_p = time.time()
l_p, r_p = cortex.cort_img(V_p, L, L_loc, R, R_loc, cort_size, G)
cort_img_c = time.time()
l_c = cort.cort_image_left(V_c)
r_c = cort.cort_image_right(V_c)
cort_end = time.time()
print '%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,' % (init_c - init_p, sample_p - init_c, sample_c - sample_p, \
invert_p - sample_c, invert_c - invert_p, retina_end - invert_c,\
cort_init_c - cort_init_p, cort_img_p - cort_init_c, cort_img_c - cort_img_p, cort_end - cort_img_c)
if show_res:
cv2.namedWindow("inverse CUDA", cv2.WINDOW_NORMAL)
cv2.imshow("inverse CUDA", inv_c)
cv2.namedWindow("inverse Piotr", cv2.WINDOW_NORMAL)
cv2.imshow("inverse Piotr", inv_p)
c_c = np.concatenate((np.rot90(l_c), np.rot90(r_c, k=3)), axis=1)
c_p = np.concatenate((np.rot90(l_p), np.rot90(r_p, k=3)), axis=1)
cv2.namedWindow("cortex CUDA", cv2.WINDOW_NORMAL)
cv2.imshow("cortex CUDA", c_c)
cv2.namedWindow("cortex Piotr", cv2.WINDOW_NORMAL)
cv2.imshow("cortex Piotr", c_p)
def showNonOpponency(C, theta):
"""Summary
This function encapsulates the routine to generate backprojected and cortical views for
the magnocellular pathway retinal ganglion cells
Args:
C (vector): The sharp retina is passed to the function
theta (float): A threshold value is passed to the function
Returns:
merged: Return a merged image of the backprojected view as a numpy image array
mergecort: Return a merged image of the cortical view as a numpy image array
"""
GI = retina.gauss_norm_img(x,
y,
dcoeff[i],
dloc[i],
imsize=imgsize,
rgb=False)
# Sample using the other recepetive field, note there is no temporal response with still images
S = retina.sample(img, x, y, dcoeff[i], dloc[i], rgb=True)
#backproject the imagevectors
ncentreV, nsurrV = rgc.nonopponency(C, S, theta)
ninverse = retina.inverse(ncentreV,
x,
y,
dcoeff[i],
dloc[i],
GI,
imsize=imgsize,
rgb=True)
ninv_crop = retina.crop(ninverse, x, y, dloc[i])
ninverse2 = retina.inverse(nsurrV,
x,
y,
dcoeff[i],
dloc[i],
GI,
imsize=imgsize,
rgb=True)
ninv_crop2 = retina.crop(ninverse2, x, y, dloc[i])
# place descriptive text onto generated images
cv2.putText(ninv_crop, "R+G + ", (xx, yy), font, 1, (255, 255, 255), 2)
cv2.putText(ninv_crop2, "R+G - ", (xx, yy), font, 1, (255, 255, 255), 2)
merged = np.concatenate((ninv_crop, ninv_crop2), axis=1)
# create cortical maps of the imagevectors
lposnon, rposnon = cortex.cort_img(ncentreV, L, L_loc, R, R_loc, cort_size,
G)
lnegnon, rnegnon = cortex.cort_img(nsurrV, L, L_loc, R, R_loc, cort_size,
G)
pos_cort_img = np.concatenate((np.rot90(lposnon), np.rot90(rposnon, k=3)),
axis=1)
neg_cort_img = np.concatenate((np.rot90(lnegnon), np.rot90(rnegnon, k=3)),
axis=1)
mergecort = np.concatenate((pos_cort_img, neg_cort_img), axis=1)
return merged, mergecort
def prepRF():
"""Summary
Helper function that is used to pre-generate the cortical map locations,
before the main loop
"""
global L, R, L_loc, R_loc, G, cort_size
L, R = cortex.LRsplit(loc[i])
L_loc, R_loc = cortex.cort_map(L, R)
L_loc, R_loc, G, cort_size = cortex.cort_prepare(L_loc, R_loc)
ret, img = cap.read()
x = int(img.shape[1] / 2)
y = int(img.shape[0] / 2)
imgsize = (img.shape[0], img.shape[1])
global GI
GI = retina.gauss_norm_img(x,
y,
dcoeff[i],
dloc[i],
imsize=imgsize,
rgb=True)
def preview():
stdimg_dir = os.getcwd() + os.sep + 'testimage\\'
print "Using " + os.listdir(stdimg_dir)[0]
name = os.listdir(stdimg_dir)[0]
standard_image = cv2.imread(stdimg_dir + name, )
img = cv2.normalize(standard_image.astype('float'), None, 0.0, 1.0,
cv2.NORM_MINMAX)
img = cv2.cvtColor(standard_image, cv2.COLOR_BGR2GRAY)
x, y = img.shape[1] / 2, img.shape[0] / 2
size = img.shape
oz_V = retina.sample(img, x, y, ozimek_coeff, ozimek_loc, rgb=False)
oz_GI = retina.gauss_norm_img(x, y, ozimek_coeff, ozimek_loc, imsize=size)
oz_I = retina.inverse(oz_V,
x,
y,
ozimek_coeff,
ozimek_loc,
oz_GI,
imsize=size,
rgb=False)
oz_I_crop = retina.crop(oz_I, x, y, ozimek_loc)
oz_GI_crop = retina.crop(oz_GI, x, y, ozimek_loc)
# test application of retinal receptive field
plt.figure(figsize=(6, 6), num="Test application of retinal field")
plt.axis('off')
plt.imshow(oz_I_crop, cmap='gray')
plt.show()
#heatmap of retinal receptive field
plt.figure(figsize=(6, 6), num="Heatmap of retina")
plt.axis('off')
plt.imshow(oz_GI_crop, cmap='RdBu')
plt.show()
def correctness_test(loc, coeff, cap, rgb=False):
'''
CUDA code uses the minimal initialisation from the host,
all tracatable values are computed on the GPU
Get an image from the camera, generate inverse and cortical image
with both implementation and subtract the results
'''
r, img = cap.read()
if not rgb: img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# create CUDA objects to pass to evaluation
ret = retina_cuda.create_retina(
loc, coeff, img.shape, (int(img.shape[1] / 2), int(img.shape[0] / 2)),
None)
cort = cortex_cuda.create_cortex_from_fields(loc, rgb=rgb)
while ord('q') != cv2.waitKey(10):
r, img = cap.read()
if not rgb: img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
if r:
'''
Sample the image img with CUDA retina ret, inverse transform it with ret and
create the cortical image with CUDA cortex cort
Sample and generate retina and cortical images from img with Piotrs's code
Visually compare the results by showing the subtraction of the generatd images
'''
V_c = ret.sample(img) # sample with CUDA
inv_c = ret.inverse(V_c) # inverse with CUDA
l_c = cort.cort_image_left(V_c) # left cortical image CUDA
r_c = cort.cort_image_right(V_c) # right cortical image CUDA
c_c = np.concatenate(
(np.rot90(l_c), np.rot90(r_c, k=3)),
axis=1) #concatenate the results into one image
# create Piotr's retina and cortical images
GI = retina.gauss_norm_img(int(img.shape[1] / 2),
int(img.shape[0] / 2), coeff, loc,
img.shape, rgb)
L, R = cortex.LRsplit(loc)
L_loc, R_loc = cortex.cort_map(L, R)
L_loc, R_loc, G, cort_size = cortex.cort_prepare(L_loc, R_loc)
V_p = retina.sample(img, img.shape[1] / 2, img.shape[0] / 2, coeff,
loc, rgb)
inv_p = retina.inverse(V_p, img.shape[1] / 2, img.shape[0] / 2,
coeff, loc, GI, img.shape, rgb)
l_p, r_p = cortex.cort_img(V_p, L, L_loc, R, R_loc, cort_size, G)
c_p = np.concatenate((np.rot90(
l_p[:l_c.shape[0], :]), np.rot90(r_p[:r_c.shape[0], :], k=3)),
axis=1)
# show CUDA results
cv2.namedWindow("inverse CUDA", cv2.WINDOW_NORMAL)
cv2.imshow("inverse CUDA", inv_c)
cv2.namedWindow("cortex CUDA", cv2.WINDOW_NORMAL)
cv2.imshow("cortex CUDA", c_c)
# show Piotr's results
cv2.namedWindow("inverse Piotr", cv2.WINDOW_NORMAL)
cv2.imshow("inverse Piotr", inv_p)
cv2.namedWindow("cortex Piotr", cv2.WINDOW_NORMAL)
cv2.imshow("cortex Piotr", c_p)
# show the difference of the images
cv2.namedWindow("inverse diff", cv2.WINDOW_NORMAL)
cv2.imshow("inverse diff", np.power((inv_c - inv_p), 2) * 255)
cv2.namedWindow("cortex diff", cv2.WINDOW_NORMAL)
cv2.imshow("cortex diff", np.power((c_c - c_p), 2) * 255)
def compatibility_test(loc, coeff, cap, rgb=False):
'''
CUDA code uses different initialisations,
passed parameters are the results of Piotr's code
Initialise retina and cortex with external parameters
Process camera stream
'''
r, img = cap.read()
if not rgb: img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# Get parameters calculated by Piotr's code
GI = retina.gauss_norm_img(int(img.shape[1] / 2), int(img.shape[0] / 2),
coeff, loc, img.shape, rgb)
L, R = cortex.LRsplit(loc)
L_loc, R_loc = cortex.cort_map(L, R)
L_loc, R_loc, G, cort_size = cortex.cort_prepare(L_loc, R_loc)
# CUDA
# first retina creates everything on the GPU, proved to be identical with Piotr's implementation
ret0 = retina_cuda.create_retina(loc, coeff, img.shape,
(img.shape[1] / 2, img.shape[0] / 2),
None)
# second retina uses the GI from Piotr
ret1 = retina_cuda.create_retina(loc, coeff, img.shape,
(img.shape[1] / 2, img.shape[0] / 2), GI)
# first cortex creates everything on the GPU, proved to be identical with Piotr's implementation
cort0 = cortex_cuda.create_cortex_from_fields(loc, rgb=rgb)
# second cortex gets all the parameters from Piotr's code
cort1 = cortex_cuda.create_cortex_from_fields_and_locs(
L,
R,
L_loc,
R_loc, (cort0.cort_image_size[0], cort_size[1]),
gauss100=G,
rgb=rgb)
# read camera stream
while ord('q') != cv2.waitKey(10):
r, img = cap.read()
if not rgb: img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
if r:
'''
Sample the image img with ret0 and ret1, inverse transform the image vectors
create the cortical image with cort0 and cort1
Visually compare the results by showing the subtraction of the generatd images
'''
V0 = ret0.sample(img) # sample with reference ret
inv0 = ret0.inverse(V0) # inverse with reference ret
l_c0 = cort0.cort_image_left(
V0) # left cortical image reference cort
r_c0 = cort0.cort_image_right(
V0) # right cortical image refernce cort
c_c0 = np.concatenate(
(np.rot90(l_c0), np.rot90(r_c0, k=3)),
axis=1) #concatenate the results into one image
V1 = ret0.sample(img) # sample with reference ret
inv1 = ret0.inverse(V0) # inverse with reference ret
l_c1 = cort1.cort_image_left(
V1) # left cortical image reference cort
r_c1 = cort1.cort_image_right(
V1) # right cortical image refernce cort
c_c1 = np.concatenate(
(np.rot90(l_c1[:, :]), np.rot90(r_c1[:, :], k=3)),
axis=1) #concatenate the results into one image
# sampling error between the two instance
print('Sampling difference: %f' % np.sum(V1 - V0))
# show CUDA results
cv2.namedWindow("inverse ref", cv2.WINDOW_NORMAL)
cv2.imshow("inverse ref", inv0)
cv2.namedWindow("cortex ref", cv2.WINDOW_NORMAL)
cv2.imshow("cortex ref", c_c0)
# show Piotr's results
cv2.namedWindow("inverse toprove", cv2.WINDOW_NORMAL)
cv2.imshow("inverse toprove", inv1)
cv2.namedWindow("cortex toprove", cv2.WINDOW_NORMAL)
cv2.imshow("cortex toprove", c_c1)
# show the difference of the images
print len(
np.nonzero(inv0 - inv1)[0]) / (img.shape[0] * img.shape[1])
cv2.namedWindow("inverse diff", cv2.WINDOW_NORMAL)
cv2.imshow("inverse diff", np.abs(inv0 - inv1) * 255)
cv2.namedWindow("cortex diff", cv2.WINDOW_NORMAL)
cv2.imshow("cortex diff", np.abs(c_c0 - c_c1) * 255)
global L, R, L_loc, R_loc, G, cort_size
L, R = cortex.LRsplit(loc[i])
L_loc, R_loc = cortex.cort_map(L, R)
L_loc, R_loc, G, cort_size = cortex.cort_prepare(L_loc, R_loc)
# read in an image file
stdimg_dir = os.getcwd() + os.sep + 'testimage\\'
print "Using " + os.listdir(stdimg_dir)[0]
name = os.listdir(stdimg_dir)[0]
img = cv2.imread(stdimg_dir + name, )
x, y = img.shape[1] / 2, img.shape[0] / 2
xx, yy = 1, img.shape[0] / 10
imgsize = img.shape
# generate gaussian normalised image
GI = retina.gauss_norm_img(x, y, dcoeff[i], dloc[i], imsize=imgsize, rgb=True)
def showNonOpponency(C, theta):
"""Summary
This function encapsulates the routine to generate backprojected and cortical views for
the magnocellular pathway retinal ganglion cells
Args:
C (vector): The sharp retina is passed to the function
theta (float): A threshold value is passed to the function
Returns:
merged: Return a merged image of the backprojected view as a numpy image array
mergecort: Return a merged image of the cortical view as a numpy image array
"""
GI = retina.gauss_norm_img(x,