def frames(self):
num_frames = 0
while True:
d = imagen.RawRectangle(offset=self.background_luminance,
scale=self.background_luminance *
(self.relative_luminance - 0.5),
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density,
x=self.x,
y=self.y,
orientation=self.orientation,
size=self.width,
aspect_ratio=self.length / self.width)()
b = imagen.Constant(scale=self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density)()
num_frames += 1
if (num_frames - 1) * self.frame_duration < self.flash_duration:
yield (d, [1])
else:
yield (b, [0])
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):
# the size length of square edge is given by half the period
size = 1. / (2 * self.spatial_frequency)
# if a separation size is provided we use it, otherwise we use the same as size
if self.separated:
halfseparation = self.separation / 2.
else:
halfseparation = size
# if the separation is less than the size of a square, the two squares will overlap and the luminance will be too much
if halfseparation < size / 2.:
halfseparation = size / 2.
# flashing squares with a temporal frequency of 6Hz are happening every 1000/6=167ms
time = self.duration / self.frame_duration
stim_period = time / self.temporal_frequency
t = 0
t0 = 0
# total time of the stimulus
while t <= time:
# frequency tick
if (t - t0) >= stim_period:
t0 = t
# Squares presence on screen is half of the period.
# Since the two patterns will be added together,
# the offset level is half it should be, to sum into the required level,
# and the scale level is twice as much, in order to overcome the presence of the other pattern
if t <= t0 + (stim_period / 2):
a = imagen.RawRectangle(
x=-halfseparation,
y=0,
orientation=self.orientation,
bounds=BoundingBox(radius=self.size_x / 2),
offset=0.5 * self.background_luminance *
(100.0 - self.contrast) / 100.0,
scale=2 * self.background_luminance * self.contrast /
100.0,
xdensity=self.density,
ydensity=self.density,
size=size)()
b = imagen.RawRectangle(
x=halfseparation,
y=0,
orientation=self.orientation,
bounds=BoundingBox(radius=self.size_x / 2),
offset=0.5 * self.background_luminance *
(100.0 - self.contrast) / 100.0,
scale=2 * self.background_luminance * self.contrast /
100.0,
xdensity=self.density,
ydensity=self.density,
size=size)()
yield (numpy.add(a, b), [t])
else:
yield (imagen.Constant(scale=self.background_luminance *
(100.0 - self.contrast) / 100.0,
bounds=BoundingBox(radius=self.size_x /
2),
xdensity=self.density,
ydensity=self.density)(), [t])
# time
t += 1
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 frames(self):
num_frames = 0
while True:
length = self.length / 2 - self.gap_length / 2.0
shift = length / 2.0 + self.gap_length / 2.0
r1 = imagen.Rectangle(
x=shift * numpy.cos(self.right_angle),
y=shift * numpy.sin(right_angle),
offset=self.background_luminance,
scale=2 * self.background_luminance *
(self.relative_luminance - 0.5),
orientation=numpy.pi / 2 + self.right_angle,
smoothing=0,
aspect_ratio=self.width / length,
size=length,
bounds=BoundingBox(radius=self.size_x / 2),
)
r2 = imagen.Rectangle(
x=shift * numpy.cos(self.left_angle),
y=shift * numpy.sin(left_angle),
offset=self.background_luminance,
scale=2 * self.background_luminance *
(self.relative_luminance - 0.5),
orientation=numpy.pi / 2 + self.left_angle,
smoothing=0,
aspect_ratio=self.width / length,
size=length,
bounds=BoundingBox(radius=self.size_x / 2),
)
r = imagen.Composite(generators=[r1, r2],
x=self.x,
y=self.y,
bounds=BoundingBox(radius=self.size_x / 2),
orientation=self.orientation,
xdensity=self.density,
ydensity=self.density)
b = imagen.Constant(scale=self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density)()
num_frames += 1
if (num_frames - 1) * self.frame_duration < self.flash_duration:
yield (r(), [1])
else:
yield (b, [0])
def frames(self):
fieldsize_x = self.size_x * self.density
fieldsize_y = self.size_y * self.density
folder_name = Global.root_directory + "/TextureImagesStimuli"
libpath = __file__.replace(
"/texture_based.py",
"") + "/textureLib" #path to the image processing library
matlabPyrToolspath = os.path.join(libpath, "textureSynth",
"matlabPyrTools")
if not os.path.isdir(matlabPyrToolspath):
raise IOError(
"matlabPyrTools should be downloaded from https://github.com/LabForComputationalVision/matlabPyrTools and its content should be put in the directory "
+ matlabPyrToolspath)
octave.addpath(libpath)
im = octave.textureBasedStimulus(self.texture_path, self.stats_type,
self.seed, fieldsize_x, fieldsize_y,
libpath)
scale = 2. * self.background_luminance / (numpy.max(im) -
numpy.min(im))
im = (im - numpy.min(im)) * scale
if not os.path.exists(folder_name):
os.mkdir(folder_name)
assert (im.shape == (fieldsize_x, fieldsize_y)
), "Image dimensions do not correspond to visual field size"
b = imagen.Constant(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(im, c)
d2 = numpy.multiply(b, -(c - 1.0))
d = numpy.add.reduce([d1, d2])
d = d.astype(numpy.uint8)
IM = Image.fromarray(d)
IM.save(folder_name + "/" + self.texture + "sample" +
str(self.sample) + "type" + str(self.stats_type) + 'radius' +
str(self.radius) + '.pgm')
while True:
yield (d, [0])
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 reference_frames(
self,
grid_size=default_noise["grid_size"],
size_x=default_topo["size_x"],
grid=default_noise["grid"],
background_luminance=default_topo["background_luminance"],
density=default_topo["density"],
):
time_per_image = default_noise["time_per_image"]
frame_duration = default_topo["frame_duration"]
aux = imagen.random.SparseNoise(
grid_density=grid_size * 1.0 / size_x,
grid=grid,
offset=0,
scale=2 * background_luminance,
bounds=BoundingBox(radius=size_x / 2),
xdensity=density,
ydensity=density,
random_generator=numpy.random.RandomState(seed=self.experiment_seed),
)
while True:
aux2 = aux()
for i in range(time_per_image / frame_duration):
yield (aux2, [0])
def frames(self):
while True:
yield (imagen.Constant(scale=self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density)(),
[self.frame_duration])
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 frames(self):
self.time = 0
f = open(self.eye_path_location, 'r')
self.eye_path = pickle.load(f)
self.pattern_sampler = imagen.image.PatternSampler(
size_normalization='fit_longest',
whole_pattern_output_fns=[imagen.image.DivisiveNormalizeLinf()])
while True:
location = self.eye_path[int(
numpy.floor(self.frame_duration * self.time /
self.eye_movement_period))]
image = imagen.image.FileImage(
filename=self.image_location,
x=location[0],
y=location[1],
orientation=0,
xdensity=self.density,
ydensity=self.density,
size=self.size,
bounds=BoundingBox(points=((-self.size_x / 2,
-self.size_y / 2),
(self.size_x / 2,
self.size_y / 2))),
scale=2 * self.background_luminance,
pattern_sampler=self.pattern_sampler)()
yield (image, [self.time])
self.time += 1
def frames(self):
num_frames = 0
while True:
z = self.gap_length / 4.0 + self.length / 4.0
d1 = imagen.RawRectangle(
offset=self.background_luminance,
scale=2 * self.background_luminance *
(self.relative_luminance - 0.5),
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density,
x=self.x + numpy.cos(self.orientation) * (z),
y=self.y + numpy.sin(self.orientation) * (z),
orientation=self.orientation + self.disalignment,
size=self.width,
aspect_ratio=(self.length - self.gap_length) / 2 /
self.width)()
d2 = imagen.RawRectangle(
offset=self.background_luminance,
scale=2 * self.background_luminance *
(self.relative_luminance - 0.5),
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density,
x=self.x + numpy.cos(self.orientation) * (-z),
y=self.y + numpy.sin(self.orientation) * (-z),
orientation=self.orientation + self.disalignment,
size=self.width,
aspect_ratio=(self.length - self.gap_length) / 2 /
self.width)()
b = imagen.Constant(scale=self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density)()
num_frames += 1
if (num_frames - 1) * self.frame_duration < self.flash_duration:
if self.relative_luminance > 0.5:
yield (numpy.maximum(d1, d2), [1])
else:
yield (numpy.minimum(d1, d2), [1])
else:
yield (b, [0])
def frames(self):
num_frames = 0
while True:
d1 = imagen.RawRectangle(
offset=0,
scale=2 * self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density,
x=self.x - (self.occlusion_bar_width / 2) -
(self.length - self.occlusion_bar_width) / 4,
y=self.y,
orientation=self.orientation,
size=self.background_bar_width,
aspect_ratio=(self.length - self.occlusion_bar_width) / 2 /
self.background_bar_width)()
d2 = imagen.RawRectangle(
offset=0,
scale=2 * self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density,
x=self.x + (self.occlusion_bar_width / 2) +
(self.length - self.occlusion_bar_width) / 4,
y=self.y,
orientation=self.orientation,
size=self.background_bar_width,
aspect_ratio=(self.length - self.occlusion_bar_width) / 2 /
self.background_bar_width)()
b = imagen.Constant(scale=0,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density)()
num_frames += 1
if (num_frames - 1) * self.frame_duration < self.flash_duration:
yield (numpy.add(d1, d2), [1])
else:
yield (b, [0])
def frames(self):
self.current_phase = 0
while True:
d = imagen.Disk(smoothing=0.0,
size=self.radius * 2,
offset=self.background_luminance,
scale=self.background_luminance *
(self.contrast / 100.0),
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density)()
yield (d, [self.current_phase])
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
def frames(self):
aux = imagen.random.DenseNoise(
grid_density=self.grid_size * 1.0 / self.size_x,
offset=0,
scale=2 * self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density,
random_generator=numpy.random.RandomState(
seed=self.experiment_seed))
while True:
aux2 = aux()
for i in range(self.time_per_image / self.frame_duration):
yield (aux2, [0])
def frames(self):
self.current_phase = 0
i = 0
while True:
i += 1
yield (imagen.SquareGrating(
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)(), [self.current_phase])
self.current_phase += 2 * pi * (self.frame_duration /
1000.0) * self.temporal_frequency
def frames(self):
num_frames = 0
while True:
d1 = imagen.RawRectangle(offset=self.background_luminance,
scale=2 * self.background_luminance *
(self.relative_luminance - 0.5),
bounds=BoundingBox(radius=self.size_x /
2),
xdensity=self.density,
ydensity=self.density,
x=self.x,
y=self.y,
orientation=self.orientation,
size=self.width,
aspect_ratio=self.length / self.width)()
d2 = imagen.RawRectangle(
offset=1,
scale=-1,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density,
x=self.x,
y=self.y,
orientation=self.orientation,
size=self.width,
aspect_ratio=self.gap_length / self.width)()
d3 = imagen.RawRectangle(
offset=0,
scale=self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density,
x=self.x,
y=self.y,
orientation=self.orientation,
size=self.width,
aspect_ratio=self.gap_length / self.width)()
d4 = imagen.RawRectangle(
offset=self.background_luminance,
scale=2 * self.background_luminance *
(self.relative_luminance - 0.5),
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density,
x=self.x,
y=self.y,
orientation=self.orientation + numpy.pi / 2,
size=self.width,
aspect_ratio=0.8 / self.width)()
b = imagen.Constant(scale=self.background_luminance,
bounds=BoundingBox(radius=self.size_x / 2),
xdensity=self.density,
ydensity=self.density)()
num_frames += 1
if (num_frames - 1) * self.frame_duration < self.flash_duration:
if self.relative_luminance > 0.5:
#yield (numpy.maximum(d4,numpy.add(numpy.multiply(d1,d2),d3)),[1])
yield (d4, [1])
else:
yield (d4, [1])
#yield (numpy.minimum(d4,numpy.add(numpy.multiply(d1,d2),d3)),[1])
else:
yield (b, [0])
