def RadialG(x, y, BlackBackground, phase_shift, Bound,frames):
parts = [1,2,4,8,12,16]
orien = [np.pi/2]*6
paras = zip(orien,parts)
paras = [[par] for par in paras]
if phase_shift:
paras = pert.modulation_of_phase(paras,'RG',frames)
else:
frames = 1
RG = np.empty([len(paras),frames],dtype=np.object)
idx_proto = 0
for pars in paras:
idx_shift = 0
for p in pars:
RG[idx_proto][idx_shift] = RadialGrating(bounds=Bound,parts=p[1],
orientation=p[0],xdensity=x,ydensity=y)()
if BlackBackground:
assert RG[idx_proto][idx_shift].max() <= 1.0 and RG[idx_proto][idx_shift].min() >= 0
RG[idx_proto][idx_shift] = 1-RG[idx_proto][idx_shift]
idx_shift += 1
idx_proto += 1
return RG
def SineG(x, y, BlackBackground, phase_shift, Bound,frames):
orientations = [i * np.pi /8 for i in range(8)]
frequencies = [1.0 ,2.0, 4.0, 8.0, 12.0, 16.0]
phase = np.pi/2
paras = [[[ori, fre, phase]] for ori in orientations for fre in frequencies]
if phase_shift:
paras = pert.modulation_of_phase(paras,'SG',frames)
else:
frames = 1
# generates images and saved into a numpy array
SG = np.empty([len(paras), frames], dtype=np.object)
idx_proto = 0
for pars in paras:
idx_shift = 0
for p in pars:
SG[idx_proto][idx_shift] = ig.SineGrating(bounds=Bound, phase=p[2], orientation=p[0],
frequency=p[1], xdensity=x, ydensity=y)()
if BlackBackground:
assert SG[idx_proto][idx_shift].max() <= 1.0 and SG[idx_proto][idx_shift].min() >= 0
SG[idx_proto][idx_shift] = 1 - SG[idx_proto][idx_shift]
idx_shift += 1
idx_proto += 1
return SG
def HyperG(x, y, BlackBackground, phase_shift, Bound, frames):
orientations = [i * np.pi / 8 for i in range(4)]
sizes = [1.0 / s for s in [1, 2, 4, 8, 12, 16]]
paras = [[[o, s, 0.0]] for o in orientations for s in sizes]
if phase_shift:
paras = pert.modulation_of_phase(paras, 'HG', frames)
else:
frames = 1
HG = np.empty([len(paras), frames], dtype=np.object)
idx_proto = 0
for pars in paras:
idx_shift = 0
for p in pars:
HG[idx_proto][idx_shift] = HyperbolicGrating(bounds=Bound,
orientation=p[0],
size=p[1],
phase=p[2],
xdensity=x,
ydensity=y)()
if BlackBackground:
assert HG[idx_proto][idx_shift].max(
) <= 1.0 and HG[idx_proto][idx_shift].min() >= 0
HG[idx_proto][idx_shift] = 1 - HG[idx_proto][idx_shift]
idx_shift += 1
idx_proto += 1
return HG
def Targets(x, y, BlackBackground, phase_shift, Bound, frames):
# sizes = [1.0/s for s in [1.2 ,2.4, 4.8, 9.6, 13.6, 19.2,27.2]]
sizes = [1.0 / s for s in [1, 2, 4, 8, 12, 16]]
paras = [[[0, s, 1, 0.0]] for s in sizes]
if phase_shift:
paras = pert.modulation_of_phase(paras, 'T', frames)
else:
frames = 1
T = np.empty([len(paras), frames], dtype=np.object)
idx_proto = 0
for pars in paras:
idx_shift = 0
for p in pars:
T[idx_proto][idx_shift] = ConcentricRings(bounds=Bound,
aspect_ratio=p[2],
size=p[1],
orientation=p[0],
phase=p[3],
xdensity=x,
ydensity=y)()
if BlackBackground:
assert T[idx_proto][idx_shift].max(
) <= 1.0 and T[idx_proto][idx_shift].min() >= 0
T[idx_proto][idx_shift] = 1 - T[idx_proto][idx_shift]
idx_shift += 1
idx_proto += 1
return T
def SpiralG(x, y, BlackBackground, phase_shift, Bound, frames):
parts = [1, 2, 4, 8, 12, 16]
C_target = [1.0, 2.0, 4.0, 8.0, 12.0, 16.0]
paras = [[[np.pi / 2, part / (C_t * 2 * np.pi), part]] for part in parts
for C_t in C_target]
if phase_shift:
paras = pert.modulation_of_phase(paras, 'SpG', frames)
else:
frames = 1
SpG = np.empty([len(paras), frames], dtype=np.object)
idx_proto = 0
for pars in paras:
idx_shift = 0
for p in pars:
SpG[idx_proto][idx_shift] = SpiralGrating(bounds=Bound,
parts=p[2],
turning=p[1],
orientation=p[0],
xdensity=x,
ydensity=y)()
if BlackBackground:
assert SpG[idx_proto][idx_shift].max(
) <= 1.0 and SpG[idx_proto][idx_shift].min() >= 0
SpG[idx_proto][idx_shift] = 1 - SpG[idx_proto][idx_shift]
idx_shift += 1
idx_proto += 1
return SpG
def SpiralG(x, y, BlackBackground, phase_shift, Bound, frames):
# parts = [1, 2, 4, 8, 12, 16]
# C_target = [1.0 ,2.0, 4.0, 8.0, 12.0, 16.0]
# paras = [[[np.pi/2, part/(C_t*2*np.pi), part]] for part in parts for C_t in C_target]
C_target = [2.0, 4.0, 12.0, 8.0]
parts = [8, 2, 4, 6]
paras = [[[np.pi / 2, x[1] / (x[0] * 2 * np.pi), x[1]]]
for x in zip(C_target, parts)]
scale_idx = [1 / 1.2, 1.0, 1.2]
ori = [np.pi * j / 4 for j in range(4)]
if phase_shift:
paras = pert.modulation_of_phase(paras, 'SpG', frames)
else:
frames = 12
SpG = np.empty([len(paras), frames], dtype=np.object)
idx_proto = 0
for pars in paras:
idx_shift = 0
for p in pars:
for ith_s in scale_idx:
for ith_ori in ori:
SpG[idx_proto][idx_shift] = SpiralGrating(
bounds=Bound,
parts=p[2],
turning=p[1] * ith_s,
aspect_ratio=1.8,
orientation=p[0] + ith_ori,
xdensity=x,
ydensity=y)()
if BlackBackground:
assert SpG[idx_proto][idx_shift].max(
) <= 1.0 and SpG[idx_proto][idx_shift].min() >= 0
SpG[idx_proto][
idx_shift] = 1 - SpG[idx_proto][idx_shift]
idx_shift += 1
idx_proto += 1
return SpG
