def showCortexImg(pV, nV, t):
"""Summary
This function encapsulates the routine to generate rectified cortical views of
one opponent retinal ganglion cell type
Args:
pV (vector): Positive rectified imagevector
nV (vector): Negative rectified imagevector
t (int): Index position of opponent cell species
Returns:
mergecort: Return a merged image of all cortical opponent cells as a numpy image array
"""
lpos = cort0.cort_image_left(
retina_cuda.convert_from_Piotr(pV[:, t, :].astype(float)))
rpos = cort0.cort_image_right(
retina_cuda.convert_from_Piotr(pV[:, t, :].astype(float)))
lneg = cort1.cort_image_left(
retina_cuda.convert_from_Piotr(nV[:, t, :].astype(float)))
rneg = cort1.cort_image_right(
retina_cuda.convert_from_Piotr(nV[:, t, :].astype(float)))
pos_cort_img = np.concatenate((np.rot90(lpos), np.rot90(rpos, k=3)),
axis=1)
neg_cort_img = np.concatenate((np.rot90(lneg), np.rot90(rneg, k=3)),
axis=1)
mergecort = np.concatenate((pos_cort_img, neg_cort_img), axis=1)
return mergecort
def showBPImg(pV, nV, t):
"""Summary
This function encapsulates the routine to generate rectified backprojected views of
one opponent retinal ganglion cell
Args:
pV (vector): Positive rectified imagevector
nV (vector): Negative rectified imagevector
t (int): Index position of opponent cell species
Returns:
merge: Return a merged image of all backprojected opponent cells as a numpy image array
"""
inverse = ret0.inverse(
retina_cuda.convert_from_Piotr(pV[:, t, :].astype(float)))
inv_crop = retina.crop(inverse, int(img.shape[1] / 2),
int(img.shape[0] / 2), loc[0])
inverse2 = ret1.inverse(
retina_cuda.convert_from_Piotr(nV[:, t, :].astype(float)))
inv_crop2 = retina.crop(inverse2, int(img.shape[1] / 2),
int(img.shape[0] / 2), dloc[0])
cv2.putText(inv_crop, types[t] + " + ", (1, 270), font, 1, (0, 255, 255),
2)
cv2.putText(inv_crop2, types[t] + " - ", (1, 270), font, 1, (0, 255, 255),
2)
merge = np.concatenate((inv_crop, inv_crop2), axis=1)
return merge
def showBPImg(pV, nV):
"""Summary
This function encapsulates the routine to generate rectified backprojected views of
all opponent retinal ganglion cells
Args:
pV (vector): Positive rectified imagevector
nV (vector): Negative rectified imagevector
Returns:
merge: Return a merged image of all backprojected opponent cells as a numpy image array
"""
# object arrays of the positive and negative images
inv_crop = np.empty(8, dtype=object)
inv_crop2 = np.empty(8, dtype=object)
for i in range(8):
# backprojection functions
inverse = ret0.inverse(
retina_cuda.convert_from_Piotr(pV[:, i, :].astype(float)))
inv_crop[i] = retina.crop(inverse, int(img.shape[1] / 2),
int(img.shape[0] / 2), loc[0])
inverse2 = ret1.inverse(
retina_cuda.convert_from_Piotr(nV[:, i, :].astype(float)))
inv_crop2[i] = retina.crop(inverse2, int(img.shape[1] / 2),
int(img.shape[0] / 2), dloc[0])
cv2.putText(inv_crop[i], types[i] + " + ", (1, 270), font, 1,
(0, 255, 255), 2)
cv2.putText(inv_crop2[i], types[i] + " - ", (1, 270), font, 1,
(0, 255, 255), 2)
# stack all images into a grid
posRG = np.vstack((inv_crop[:4]))
negRG = np.vstack((inv_crop2[:4]))
posYB = np.vstack((inv_crop[4:]))
negYB = np.vstack((inv_crop2[4:]))
merge = np.concatenate((posRG, negRG, posYB, negYB), axis=1)
return merge
def showCortexImg(pV, nV):
"""Summary
This function encapsulates the routine to generate rectified cortical views of
all opponent retinal ganglion cells
Args:
pV (vector): Positive rectified imagevector
nV (vector): Negative rectified imagevector
Returns:
mergecort: Return a merged image of all cortical opponent cells as a numpy image array
"""
# object arrays of the positive and negative cortical images
pos_cort_img = np.empty(8, dtype=object)
neg_cort_img = np.empty(8, dtype=object)
for i in range(8):
# accelerated cortical mapping functions
lpos = cort0.cort_image_left(
retina_cuda.convert_from_Piotr(pV[:, i, :].astype(float)))
rpos = cort0.cort_image_right(
retina_cuda.convert_from_Piotr(pV[:, i, :].astype(float)))
lneg = cort1.cort_image_left(
retina_cuda.convert_from_Piotr(nV[:, i, :].astype(float)))
rneg = cort1.cort_image_right(
retina_cuda.convert_from_Piotr(nV[:, i, :].astype(float)))
pos_cort_img[i] = np.concatenate((np.rot90(lpos), np.rot90(rpos, k=3)),
axis=1)
neg_cort_img[i] = np.concatenate((np.rot90(lneg), np.rot90(rneg, k=3)),
axis=1)
# stack all images into a grid
posRGcort = np.vstack((pos_cort_img[:4]))
negRGcort = np.vstack((neg_cort_img[:4]))
posYBcort = np.vstack((pos_cort_img[4:]))
negYBcort = np.vstack((neg_cort_img[4:]))
mergecort = np.concatenate((posRGcort, negRGcort, posYBcort, negYBcort),
axis=1)
return mergecort
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
"""
# Sample using accelerated retina function
S = ret1.sample(lateimg) # SURROUND
S = retina_cuda.convert_to_Piotr(S)
#showretina:
#return the modified,rectified imagevectors
ncentreV, nsurrV = rgc.nonopponency(C, S, theta)
# generate packprojected images
ninverse = ret0.inverse(
retina_cuda.convert_from_Piotr(ncentreV.astype(float)))
ninv_crop = retina.crop(ninverse, int(img.shape[1] / 2),
int(img.shape[0] / 2), loc[0])
ninverse2 = ret1.inverse(
retina_cuda.convert_from_Piotr(nsurrV.astype(float)))
ninv_crop2 = retina.crop(ninverse2, int(img.shape[1] / 2),
int(img.shape[0] / 2), dloc[0])
# place descriptive text onto generated images
cv2.putText(ninv_crop, "R+G + ", (1, 270), font, 1, (0, 255, 255), 2)
cv2.putText(ninv_crop2, "R+G - ", (1, 270), font, 1, (0, 255, 255), 2)
merged = np.concatenate((ninv_crop, ninv_crop2), axis=1)
#showcortex
## create cortical maps of the imagevectors using accelerated functions
lposnon = cort0.cort_image_left(
retina_cuda.convert_from_Piotr(ncentreV.astype(float)))
rposnon = cort0.cort_image_right(
retina_cuda.convert_from_Piotr(ncentreV.astype(float)))
lnegnon = cort1.cort_image_left(
retina_cuda.convert_from_Piotr(nsurrV.astype(float)))
rnegnon = cort1.cort_image_right(
retina_cuda.convert_from_Piotr(nsurrV.astype(float)))
pos_cort_img_non = np.concatenate(
(np.rot90(lposnon), np.rot90(rposnon, k=3)), axis=1)
neg_cort_img_non = np.concatenate(
(np.rot90(lnegnon), np.rot90(rnegnon, k=3)), axis=1)
# merge left and right hemispheres
mergedcortex = np.concatenate((pos_cort_img_non, neg_cort_img_non), axis=1)
return merged, mergedcortex