changed padding in some functions so they match the shape in the paper

stimuli/illusions/checkerboard_contrast_contrast.py

@@ -71,7 +71,7 @@ def checkerboard_contrast_contrast_effect(ppd=10, n_checks=8, check_size=1.0, ta
 
 
 def domijan2015():
-    return checkerboard_contrast_contrast_effect(n_checks=8, check_size=10, target_length=4, padding=(9,11,9,11), check1=1.,
+    return checkerboard_contrast_contrast_effect(ppd=10, n_checks=8, check_size=1.0, target_length=4, padding=(.9,1.1,.9,1.1), check1=1.,
                                                  check2=9., tau=5, alpha= .5)
 
 if __name__ == '__main__':

stimuli/illusions/checkerboard_sbc.py

@@ -1,10 +1,10 @@
 import numpy as np
-import stimuli.illusions
-from stimuli.utils import degrees_to_pixels, pad_img, plot_stim
+import stimuli
+from stimuli.utils import degrees_to_pixels, pad_img, pad_img_to_shape, plot_stim
 from stimuli.Stimulus import Stimulus
 
 def checkerboard_contrast(ppd=10, board_shape=(8,8), check_size=1.0, target1_coords=(3, 2), target2_coords=(5, 5), extend_targets=False,
-                          padding=(1.0,1.0,1.0,1.0), check1=0., check2=1., target=.5):
+                         check1=0., check2=1., target=.5):
     """
     Checkerboard Contrast
 
@@ -51,9 +51,6 @@ def checkerboard_contrast(ppd=10, board_shape=(8,8), check_size=1.0, target1_coo
     img = np.repeat(np.repeat(arr, check_size_px, axis=0), check_size_px, axis=1)
     mask = np.repeat(np.repeat(mask, check_size_px, axis=0), check_size_px, axis=1)
 
-    img = pad_img(img, padding, ppd, (check1+check2)/2)
-    mask = pad_img(mask, padding, ppd, 0)
-
     stim = Stimulus()
     stim.img = img
     stim.target_mask = mask
@@ -62,23 +59,35 @@ def checkerboard_contrast(ppd=10, board_shape=(8,8), check_size=1.0, target1_coo
 
 
 def domijan2015():
-    return checkerboard_contrast(ppd=10, board_shape=(8,8), check_size=1.0, target1_coords=(3, 2), target2_coords=(5, 5), extend_targets=False, padding=(.9,1.1,.9,1.1), check1=1., check2=9., target=5.)
+    stim = checkerboard_contrast(ppd=10, board_shape=(8,8), check_size=1.0, target1_coords=(3, 2), target2_coords=(5, 5), extend_targets=False, check1=1., check2=9., target=5.)
+    padding = (.9, 1.1, .9, 1.1)
+    stim.img = pad_img(stim.img, padding, ppd=10, val=5.)
+    stim.target_mask = pad_img(stim.target_mask, padding, ppd=10, val=0)
+    return stim
 
 def domijan2015_extended():
-    return checkerboard_contrast(ppd=10, board_shape=(8,8), check_size=1.0, target1_coords=(3, 2), target2_coords=(5, 5), extend_targets=True, padding=(.9,1.1,.9,1.1), check1=1., check2=9., target=5.)
+    stim = checkerboard_contrast(ppd=10, board_shape=(8,8), check_size=1.0, target1_coords=(3, 2), target2_coords=(5, 5), extend_targets=True, check1=1., check2=9., target=5.)
+    padding = (.9, 1.1, .9, 1.1)
+    stim.img = pad_img(stim.img, padding, ppd=10, val=5.)
+    stim.target_mask = pad_img(stim.target_mask, padding, ppd=10, val=0)
+    return stim
 
 def RHS2007_Checkerboard016():
     total_height, total_width, ppd = (32,) * 3
     height_checks, width_checks = 40, 102
     check_height, check_width = 32/102, 32/102
     board_shape = (height_checks, width_checks)
     height, width = check_height*height_checks, check_width*width_checks
-    padding_horizontal = (total_width - width) / 2
-    padding_vertical = (total_height - height) / 2
-    padding = (padding_vertical, padding_vertical, padding_horizontal, padding_horizontal)
-    img = stimuli.illusions.checkerboard_contrast(ppd=ppd, board_shape=board_shape, check_size=check_height, target1_coords=(20, 17), target2_coords=(20, 86),
-                                                  extend_targets=False, padding=padding, check1=0, check2=1, target=.5)
-    return img
+
+    check1, check2, target = 0, 1, .5
+    target_height = height_checks // 2
+    stim = stimuli.illusions.checkerboard_contrast(ppd=ppd, board_shape=board_shape, check_size=check_height, target1_coords=(target_height, 16), target2_coords=(target_height, 85),
+                                                  extend_targets=False, check1=check1, check2=check2, target=target)
+
+    stim.img = pad_img_to_shape(stim.img, (1024, 1024), val=target)
+    stim.target_mask = pad_img_to_shape(stim.target_mask, (1024, 1024), val=0)
+
+    return stim
 
 
 
@@ -88,14 +97,15 @@ def RHS2007_Checkerboard0938():
     check_height, check_width = 0.938, 0.938
     board_shape = (height_checks, width_checks)
     height, width = check_height*height_checks, check_width*width_checks
-    padding_horizontal = (total_width - width) / 2
-    padding_vertical = (total_height - height) / 2
-    padding = (padding_vertical, padding_vertical, padding_horizontal, padding_horizontal)
-    target_height = height_checks //2
-    img = stimuli.illusions.checkerboard_contrast(ppd=ppd, board_shape=board_shape, check_size=check_height, target1_coords=(target_height, 6), target2_coords=(target_height, 17),
-                                                  extend_targets=False, padding=padding, check1=0, check2=1, target=.5)
-    return img
 
+    check1, check2, target = 0, 1, .5
+    target_height = height_checks // 2
+    stim = stimuli.illusions.checkerboard_contrast(ppd=ppd, board_shape=board_shape, check_size=check_height, target1_coords=(target_height, 6), target2_coords=(target_height, 17),
+                                                   extend_targets=False, check1=check1, check2=check2, target=target)
+    stim.img = pad_img_to_shape(stim.img, (1024, 1024), val=target)
+    stim.target_mask = pad_img_to_shape(stim.target_mask, (1024, 1024), val=0)
+
+    return stim
 
 
 def RHS2007_Checkerboard209():
@@ -104,17 +114,26 @@ def RHS2007_Checkerboard209():
     check_height, check_width = 2.09, 2.09
     board_shape = (height_checks, width_checks)
     height, width = check_height*height_checks, check_width*width_checks
-    padding_horizontal = (total_width - width) / 2
-    padding_vertical = (total_height - height) / 2
-    padding = (padding_vertical, padding_vertical, padding_horizontal, padding_horizontal)
-    target_height = height_checks //2
-    img = stimuli.illusions.checkerboard_contrast(ppd=ppd, board_shape=board_shape, check_size=check_height, target1_coords=(target_height, 2), target2_coords=(target_height, 7),
-                                                  extend_targets=False, padding=padding, check1=0, check2=1, target=.5)
-    return img
+
+    check1, check2, target = 0, 1, .5
+    target_height = height_checks // 2
+    stim = stimuli.illusions.checkerboard_contrast(ppd=ppd, board_shape=board_shape, check_size=check_height, target1_coords=(target_height, 2), target2_coords=(target_height, 7),
+                                                   extend_targets=False, check1=check1, check2=check2, target=target)
+    stim.img = pad_img_to_shape(stim.img, (1024, 1024), val=target)
+    stim.target_mask = pad_img_to_shape(stim.target_mask, (1024, 1024), val=0)
+
+    return stim
+
+
 
 
 
 if __name__ == '__main__':
+    img1 = RHS2007_Checkerboard016()
+    img2 = RHS2007_Checkerboard0938()
+    img3 = RHS2007_Checkerboard209()
+
+
     import matplotlib.pyplot as plt
     stim = checkerboard_contrast()
     plt.figure()

stimuli/illusions/cornsweet.py

@@ -47,14 +47,14 @@ def cornsweet(size=(10,10), ppd=10, contrast=0.5, ramp_width=2, exponent=2.75,
     size = np.rint(np.tan(np.radians(np.array(size) / 2.)) /
                    np.tan(np.radians(.5)) * ppd / 2) * 2
     size = size.astype('int')
-    stim = np.ones(size) * mean_lum
+    img = np.ones(size) * mean_lum
     dist = np.arange(size[1] / 2)
     dist = np.degrees(np.arctan(dist / 2. / ppd * 2 * np.tan(np.radians(.5)))) * 2
     dist /= ramp_width
     dist[dist > 1] = 1
     profile = (1 - dist) ** exponent * mean_lum * contrast / 2
-    stim[:, :size[1] // 2] += profile[::-1]
-    stim[:, size[1] // 2:] -= profile
+    img[:, :size[1] // 2] += profile[::-1]
+    img[:, size[1] // 2:] -= profile
     mask = None
 
     stim = Stimulus()
@@ -66,6 +66,6 @@ def cornsweet(size=(10,10), ppd=10, contrast=0.5, ramp_width=2, exponent=2.75,
 
 if __name__ == '__main__':
     import matplotlib.pyplot as plt
-    img, mask = cornsweet()
-    plt.imshow(img, cmap='gray')
+    stim = cornsweet()
+    plt.imshow(stim, cmap='gray')
     plt.show()

stimuli/illusions/dungeon.py

@@ -45,9 +45,10 @@ def dungeon_illusion(ppd=10, n_cells=5, target_radius=1, cell_size=1.0, padding=
     arr[grid_mask] = back
     mask_arr[grid_mask] = 0
 
-    ind1, ind2 = np.nonzero(mask_arr)
-    for i in range(len(ind1)):
-        mask_arr[ind1[i], ind2[i]] = i+1
+    # This is used to number each target square individually instead of giving them all an index of 1
+    # ind1, ind2 = np.nonzero(mask_arr)
+    # for i in range(len(ind1)):
+    #     mask_arr[ind1[i], ind2[i]] = i+1
 
     img = np.repeat(np.repeat(arr, cell_size_px, axis=0), cell_size_px, axis=1)
     img = pad_img(img, padding, ppd, back)
@@ -58,7 +59,7 @@ def dungeon_illusion(ppd=10, n_cells=5, target_radius=1, cell_size=1.0, padding=
     if double:
         stim2 = dungeon_illusion(ppd=ppd, n_cells=n_cells, target_radius=target_radius, cell_size=cell_size, padding=padding,  back=grid, grid=back, target=target, double=False)
         img = np.hstack([img, stim2.img])
-        mask = np.hstack([mask, stim2.target_mask])
+        mask = np.hstack([mask, stim2.target_mask*2])
 
     stim = Stimulus()
     stim.img = img

stimuli/illusions/hermann.py

@@ -1,12 +1,11 @@
 import numpy as np
-
+from stimuli.utils import plot_stim
 
 ###################################
 #           Hermann Grid          #
 ###################################
-def hermann_grid(n_grid=1000, space=100):
+def hermann_grid(n_grid=100, space=5):
     #TODO: the parameters aren't analogous to the other stimuli
-    #TODO: figure out the default parameters that results in something that makes sense
 
     grid = np.zeros([n_grid, n_grid], dtype=np.float32)
     grid[::space, :] = 1
@@ -16,5 +15,6 @@ def hermann_grid(n_grid=1000, space=100):
 
 if __name__ == '__main__':
     import matplotlib.pyplot as plt
-    plt.imshow(hermann_grid(), cmap='gray')
+    stim = hermann_grid()
+    plt.imshow(stim, cmap='gray')
     plt.show()

stimuli/illusions/todorovic.py

@@ -6,7 +6,7 @@
 from stimuli.Stimulus import Stimulus
 
 
-def todorovic_illusion(target_shape=(4,4), ppd=10, covers_shape=(2.5, 2.5), spacing=(1.5,1.5,1.5,1.5), inner_padding=(3,3,3,3), padding=(2,2,2,2), back=0., grid=1., target=.5, double=True):
+def todorovic_illusion(target_shape=(4,4), ppd=10, covers_shape=(2.5, 2.5), spacing=(1.5,1.5,1.5,1.5), padding=(2,2,2,2), back=0., grid=1., target=.5, double=True):
     """
     Todorovic's illusion
 
@@ -29,16 +29,16 @@ def todorovic_illusion(target_shape=(4,4), ppd=10, covers_shape=(2.5, 2.5), spac
     target_height_px, target_width_px = degrees_to_pixels(target_shape, ppd)
 
     img = np.ones((target_height_px, target_width_px)) * target
-    img = pad_img(img, inner_padding, ppd, back)
+    img = pad_img(img, padding, ppd, back)
 
     mask = np.ones((target_height_px, target_width_px))
-    mask = pad_img(mask, inner_padding, ppd, 0)
+    mask = pad_img(mask, padding, ppd, 0)
 
-    inner_padding_px = degrees_to_pixels(inner_padding, ppd)
-    inner_padding_top_px, inner_padding_bottom_px, inner_padding_left_px, inner_padding_right_px = inner_padding_px
+    padding_px = degrees_to_pixels(padding, ppd)
+    padding_top_px, padding_bottom_px, padding_left_px, padding_right_px = padding_px
 
-    width_px = inner_padding_left_px + target_width_px + inner_padding_right_px
-    height_px = inner_padding_top_px + target_height_px + inner_padding_bottom_px
+    width_px = padding_left_px + target_width_px + padding_right_px
+    height_px = padding_top_px + target_height_px + padding_bottom_px
 
     cover_height_px, cover_width_px = degrees_to_pixels(covers_shape, ppd)
     spacing_px = degrees_to_pixels(spacing, ppd)
@@ -74,12 +74,12 @@ def todorovic_illusion(target_shape=(4,4), ppd=10, covers_shape=(2.5, 2.5), spac
     # create right half of stimulus
     if double:
         stim2 = todorovic_illusion(target_shape=target_shape, ppd=ppd, covers_shape=covers_shape, spacing=spacing,
-                                  padding=(0,0,0,0), inner_padding=inner_padding, back=grid, grid=back, target=target, double=False)
+                                  padding=padding, back=grid, grid=back, target=target, double=False)
         img = np.hstack([img, stim2.img])
         mask = np.hstack([mask, stim2.target_mask*2])
 
-    img = pad_img(img, padding, ppd, target)
-    mask = pad_img(mask, padding, ppd, 0)
+    #img = pad_img(img, padding, ppd, target)
+    #mask = pad_img(mask, padding, ppd, 0)
 
     stim = Stimulus()
     stim.img = img
@@ -88,8 +88,8 @@ def todorovic_illusion(target_shape=(4,4), ppd=10, covers_shape=(2.5, 2.5), spac
     return stim
 
 def domijan2015():
-    return todorovic_illusion(target_shape=(4.1, 4.1), ppd=10, covers_shape=(3.1, 3.1), spacing=(1.5, 1.5, 1.5, 1.5), inner_padding=(2.9,3.0, 2.9,3.0 ),
-                              padding=(0,0,0,0), grid=9., back=1., target=5.)
+    return todorovic_illusion(target_shape=(4.1, 4.1), ppd=10, covers_shape=(3.1, 3.1), spacing=(1.5, 1.5, 1.5, 1.5), padding=(2.9,3.0, 2.9,3.0 ),
+                              grid=9., back=1., target=5.)
 
 def RHS2007_todorovic_equal():
     total_height, total_width, ppd = (32,)*3
@@ -99,13 +99,24 @@ def RHS2007_todorovic_equal():
     inner_padding_vertical, inner_padding_horizontal = (height - target_height) / 2, (width - target_width) / 2
     inner_padding = (inner_padding_vertical, inner_padding_vertical, inner_padding_horizontal, inner_padding_horizontal)
 
-    padding_vertical, padding_horizontal = (total_height - height) / 2, (total_width - 2 * width) / 2
-    padding = (padding_vertical, padding_vertical, padding_horizontal, padding_horizontal)
-
     covers_shape = (0.4 * 8,) * 2
     spacing = (0,) * 4
-    return todorovic_illusion(target_shape=(target_height, target_width), ppd=ppd, covers_shape=covers_shape, spacing=spacing,
-                                                          inner_padding=inner_padding, padding=padding, back=1., grid=0.)
+
+    back, grid, target = 1., 0., .5
+    stim = todorovic_illusion(target_shape=(target_height, target_width), ppd=ppd, covers_shape=covers_shape, spacing=spacing,
+                                                         padding=inner_padding, back=back, grid=grid, target=target)
+    height_px, width_px = stim.img.shape
+
+    padding_vertical_top = degrees_to_pixels( (total_height - height) / 2, ppd)
+    padding_vertical_bottom = 1024 - padding_vertical_top - height_px
+    padding_horizontal_left = degrees_to_pixels( (total_width - width*2) / 2, ppd)
+    padding_horizontal_right = 1024 - padding_horizontal_left - width_px
+
+    stim.img = np.pad(stim.img, ((padding_vertical_top, padding_vertical_bottom), (padding_horizontal_left, padding_horizontal_right)), 'constant', constant_values=target)
+    stim.target_mask = np.pad(stim.target_mask, ((padding_vertical_top, padding_vertical_bottom), (padding_horizontal_left, padding_horizontal_right)), 'constant', constant_values=0)
+
+    return stim
+
 
 def RHS2007_todorovic_in_large():
     total_height, total_width, ppd = (32,)*3
@@ -115,14 +126,23 @@ def RHS2007_todorovic_in_large():
     inner_padding_vertical, inner_padding_horizontal = (height - target_height) / 2, (width - target_width) / 2
     inner_padding = (inner_padding_vertical, inner_padding_vertical, inner_padding_horizontal, inner_padding_horizontal)
 
-    padding_vertical, padding_horizontal = (total_height - height) / 2, (total_width - 2 * width) / 2
-    padding = (padding_vertical, padding_vertical, padding_horizontal, padding_horizontal)
-
     covers_shape = (0.4 * 8,) * 2
     spacing = ((8 - 5.3) / 2,) * 4
 
-    return todorovic_illusion(target_shape=(target_height, target_width), ppd=ppd, covers_shape=covers_shape, spacing=spacing,
-                              inner_padding=inner_padding, padding=padding, back=1., grid=0.)
+    back, grid, target = 1., 0., .5
+    stim = todorovic_illusion(target_shape=(target_height, target_width), ppd=ppd, covers_shape=covers_shape, spacing=spacing,
+                              padding=inner_padding, back=back, grid=grid, target=target)
+    height_px, width_px = stim.img.shape
+
+    padding_vertical_top = degrees_to_pixels( (total_height - height) / 2, ppd)
+    padding_vertical_bottom = 1024 - padding_vertical_top - height_px
+    padding_horizontal_left = degrees_to_pixels( (total_width - width*2) / 2, ppd)
+    padding_horizontal_right = 1024 - padding_horizontal_left - width_px
+
+    stim.img = np.pad(stim.img, ((padding_vertical_top, padding_vertical_bottom), (padding_horizontal_left, padding_horizontal_right)), 'constant', constant_values=target)
+    stim.target_mask = np.pad(stim.target_mask, ((padding_vertical_top, padding_vertical_bottom), (padding_horizontal_left, padding_horizontal_right)), 'constant', constant_values=0)
+
+    return stim
 
 
 def RHS2007_todorovic_in_small():
@@ -133,14 +153,23 @@ def RHS2007_todorovic_in_small():
     inner_padding_vertical, inner_padding_horizontal = (height - target_height) / 2, (width - target_width) / 2
     inner_padding = (inner_padding_vertical, inner_padding_vertical, inner_padding_horizontal, inner_padding_horizontal)
 
-    padding_vertical, padding_horizontal = (total_height - height) / 2, (total_width - 2 * width) / 2
-    padding = (padding_vertical, padding_vertical, padding_horizontal, padding_horizontal)
-
     covers_shape = (0.4 * 8,) * 2
     spacing = ((8 - 3) / 2,) * 4
-    return todorovic_illusion(target_shape=(target_height, target_width), ppd=ppd, covers_shape=covers_shape, spacing=spacing,
-                              inner_padding=inner_padding, padding=padding, back=1., grid=0.)
 
+    back, grid, target = 1., 0., .5
+    stim = todorovic_illusion(target_shape=(target_height, target_width), ppd=ppd, covers_shape=covers_shape, spacing=spacing,
+                              padding=inner_padding, back=back, grid=grid, target=target)
+    height_px, width_px = stim.img.shape
+
+    padding_vertical_top = degrees_to_pixels((total_height - height) / 2, ppd)
+    padding_vertical_bottom = 1024 - padding_vertical_top - height_px
+    padding_horizontal_left = degrees_to_pixels((total_width - width * 2) / 2, ppd)
+    padding_horizontal_right = 1024 - padding_horizontal_left - width_px
+
+    stim.img = np.pad(stim.img, ((padding_vertical_top, padding_vertical_bottom), (padding_horizontal_left, padding_horizontal_right)), 'constant', constant_values=target)
+    stim.target_mask = np.pad(stim.target_mask, ((padding_vertical_top, padding_vertical_bottom), (padding_horizontal_left, padding_horizontal_right)), 'constant', constant_values=0)
+
+    return stim
 
 if __name__ == '__main__':
     import matplotlib.pyplot as plt