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.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(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):
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):
# 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):
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):
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):
self.current_phase = 0
while True:
center = imagen.SineGrating(
mask_shape=imagen.Disk(smoothing=0.0,
size=self.center_radius * 2.0),
orientation=self.center_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)()
r = (self.center_radius + self.surround_radius + self.gap) / 2.0
t = (self.surround_radius - self.center_radius - self.gap) / 2.0
surround = imagen.SineGrating(
mask_shape=imagen.Ring(thickness=t * 2.0,
smoothing=0.0,
size=r * 2.0),
orientation=self.surround_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)()
offset = imagen.Constant(
mask_shape=imagen.Disk(smoothing=0.0,
size=self.surround_radius * 2.0),
bounds=BoundingBox(radius=self.size_x / 2.0),
scale=self.background_luminance * (100.0 - self.contrast) /
100.0,
xdensity=self.density,
ydensity=self.density)()
background = (imagen.Disk(
smoothing=0.0,
size=self.surround_radius * 2.0,
bounds=BoundingBox(radius=self.size_x / 2.0),
xdensity=self.density,
ydensity=self.density)() - 1) * -self.background_luminance
yield (numpy.add.reduce(
[numpy.maximum(center, surround), offset,
background]), [self.current_phase])
self.current_phase += 2 * pi * (self.frame_duration /
1000.0) * self.temporal_frequency
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:
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
class PatternCombine(TransferFn):
"""
Combine the supplied pattern with one generated using a
PatternGenerator.
Useful for operations like adding noise or masking out lesioned
items or around the edges of non-rectangular shapes.
"""
generator = param.ClassSelector(imagen.PatternGenerator,
default=imagen.Constant(),
doc="""
Pattern to combine with the supplied matrix.""")
operator = param.Parameter(np.multiply,
precedence=0.98,
doc="""
Binary Numeric function used to combine the two patterns.
Any binary Numeric array "ufunc" returning the same type of
array as the operands and supporting the reduce operator is
allowed here. See topo.pattern.Composite.operator for more
details.
""")
def __call__(self, x):
###JABHACKALERT: Need to set it up to be independent of
#density; right now only things like random numbers work
#reasonably
rows, cols = x.shape
bb = BoundingBox(points=((0, 0), (rows, cols)))
generated_pattern = self.generator(bounds=bb, xdensity=1,
ydensity=1).transpose()
new_pattern = self.operator(x, generated_pattern)
x *= 0.0
x += new_pattern
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])