def frames(self):
self.current_phase = 0
while True:
center = imagen.SineGrating(
mask_shape=imagen.pattern.Disk(smoothing=0.0,
size=self.center_radius * 2),
orientation=self.center_orientation,
frequency=self.spatial_frequency,
phase=self.current_phase,
bounds=BoundingBox(radius=self.size_x / 2),
offset=self.background_luminance * (100.0 - self.contrast) /
100.0,
scale=2 * self.background_luminance * self.contrast / 100.0,
xdensity=self.density,
ydensity=self.density)()
r = (self.center_radius + self.surround_radius + self.gap) / 2
t = (self.surround_radius - self.surround_radius - self.gap) / 2
surround = imagen.SineGrating(
mask_shape=imagen.pattern.Ring(thickness=t,
smoothing=0,
size=r * 2),
orientation=self.surround_orientation,
frequency=self.spatial_frequency,
phase=self.current_phase,
bounds=BoundingBox(radius=self.size_x / 2),
offset=self.background_luminance * (100.0 - self.contrast) /
100.0,
scale=2 * self.background_luminance * self.contrast / 100.0,
xdensity=self.density,
ydensity=self.density)()
yield (numpy.add.reduce([center, surround]), [self.current_phase])
self.current_phase += 2 * pi * (self.frame_duration /
1000.0) * self.temporal_frequency
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 frames(self):
self.current_phase = 0
while True:
a = imagen.SineGrating(orientation=self.orientation,
frequency=self.spatial_frequency,
phase=self.current_phase,
bounds=BoundingBox(radius=self.size_x / 2),
offset=self.background_luminance *
(100.0 - self.contrast) / 100.0,
scale=2 * self.background_luminance *
self.contrast / 100.0,
xdensity=self.density,
ydensity=self.density)()
b = imagen.Null(scale=self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density)()
c = imagen.Disk(smoothing=0.0,
size=self.radius * 2,
scale=1.0,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density)()
d1 = numpy.multiply(a, c)
d2 = numpy.multiply(b, -(c - 1.0))
d = numpy.add.reduce([d1, d2])
yield (d, [self.current_phase])
self.current_phase += 2 * pi * (self.frame_duration /
1000.0) * self.temporal_frequency
def frames(self):
f = open(self.eye_path_location, 'r')
self.eye_path = pickle.load(f)
self.time = 0
self.current_phase = 0
while True:
location = self.eye_path[int(
numpy.floor(self.frame_duration * self.time /
self.eye_movement_period))]
image = imagen.SineGrating(
orientation=self.orientation,
x=location[0],
y=location[1],
frequency=self.spatial_frequency,
phase=self.current_phase,
bounds=BoundingBox(points=((-self.size_x / 2,
-self.size_y / 2),
(self.size_x / 2,
self.size_y / 2))),
offset=self.background_luminance * (100.0 - self.contrast) /
100.0,
scale=2 * self.background_luminance * self.contrast / 100.0,
xdensity=self.density,
ydensity=self.density)()
self.current_phase += 2 * pi * (self.frame_duration /
1000.0) * self.temporal_frequency
yield (image, [self.time])
self.time = self.time + 1
def frames(self):
self.current_phase = 0
i = 0
t = 0
while True:
i += 1
st = imagen.SineGrating(orientation=self.orientation,
frequency=self.spatial_frequency,
phase=self.current_phase,
bounds=BoundingBox(radius=self.size_x / 2),
offset=self.background_luminance *
(100.0 - self.contrast) / 100.0,
scale=2 * self.background_luminance *
self.contrast / 100.0,
xdensity=self.density,
ydensity=self.density)()
if t > self.offset_time:
st = st * 0 + self.background_luminance
if t < self.onset_time:
st = st * 0 + self.background_luminance
yield (st, [self.current_phase])
self.current_phase += 2 * pi * (self.frame_duration /
1000.0) * self.temporal_frequency
t = t + self.frame_duration
def SineG(x, y, BlackBackground, jetter, Bound):
# creates parameter list
orientations = [i * np.pi / 12 for i in range(12)]
frequencies = [3, 6, 12]
of = list(itertools.product(orientations, frequencies))
if jetter:
of = pert.modulation_of_jetter(of, 'SG')
# generates images and saved into a numpy array
SG = np.empty(len(of), dtype=np.object)
idx = 0
for ith_of in of:
SG[idx] = ig.SineGrating(bounds=Bound,
phase=np.pi / 2,
orientation=ith_of[0],
frequency=ith_of[1],
xdensity=x,
ydensity=y)()
# SG[idx] = ig.SineGrating(bounds=Bound, phase=0, orientation=ith_of[0],
# frequency=ith_of[1], xdensity=x, ydensity=y)()
if BlackBackground:
assert SG[idx].max() <= 1.0 and SG[idx].min() >= 0
SG[idx] = 1 - SG[idx]
idx += 1
return SG
def frames(self):
self.current_phase = 0
while True:
r = (self.inner_appareture_radius +
self.outer_appareture_radius) / 2.0
t = (self.outer_appareture_radius -
self.inner_appareture_radius) / 2.0
ring = imagen.SineGrating(
mask_shape=imagen.Ring(thickness=t * 2.0,
smoothing=0.0,
size=r * 2.0),
orientation=self.orientation,
frequency=self.spatial_frequency,
phase=self.current_phase,
bounds=BoundingBox(radius=self.size_x / 2.0),
offset=0,
scale=2 * self.background_luminance * self.contrast / 100.0,
xdensity=self.density,
ydensity=self.density)()
bg = imagen.Constant(bounds=BoundingBox(radius=self.size_x / 2.0),
scale=self.background_luminance,
xdensity=self.density,
ydensity=self.density)()
correction = imagen.Ring(smoothing=0.0,
thickness=t * 2.0,
size=r * 2.0,
scale=-self.background_luminance,
bounds=BoundingBox(radius=self.size_x /
2.0),
xdensity=self.density,
ydensity=self.density)()
yield (numpy.add.reduce([ring, bg,
correction]), [self.current_phase])
self.current_phase += 2 * pi * (self.frame_duration /
1000.0) * self.temporal_frequency
