def test_ProsthesisSystem_reshape_stim(rot, gtype, n_frames):
implant = ProsthesisSystem(ElectrodeGrid((10, 10), 30, rot=rot,
type=gtype))
# Smoke test the automatic reshaping:
n_px = 21
implant.stim = ImageStimulus(np.ones((n_px, n_px, n_frames)).squeeze())
npt.assert_equal(implant.stim.data.shape, (implant.n_electrodes, 1))
npt.assert_equal(implant.stim.time, None)
implant.stim = VideoStimulus(np.ones((n_px, n_px, 3 * n_frames)),
time=2 * np.arange(3 * n_frames))
npt.assert_equal(implant.stim.data.shape,
(implant.n_electrodes, 3 * n_frames))
npt.assert_equal(implant.stim.time, 2 * np.arange(3 * n_frames))
# Verify that a horizontal stimulus will always appear horizontally, even if
# the device is rotated:
data = np.zeros((50, 50))
data[20:-20, 10:-10] = 1
implant.stim = ImageStimulus(data)
model = ScoreboardModel(xrange=(-1, 1),
yrange=(-1, 1),
rho=30,
xystep=0.02)
model.build()
percept = label(model.predict_percept(implant).data.squeeze().T > 0.2)
npt.assert_almost_equal(regionprops(percept)[0].orientation, 0, decimal=1)
def test_deepcopy_ScoreboardModel():
original = ScoreboardModel()
copied = copy.deepcopy(original)
# Assert these are two different objects
npt.assert_equal(id(original) != id(copied), True)
# Assert these objects are equivalent
npt.assert_equal(original.__dict__ == copied.__dict__, True)
# Assert building one object does not affect the copied
original.build()
npt.assert_equal(copied.is_built, False)
npt.assert_equal(original.__dict__ != copied.__dict__, True)
# Assert destroying the original doesn't affect the copied
original = None
npt.assert_equal(copied is not None, True)
def test_plot_argus_simulated_phosphenes(implant):
implant.stim = {'A1': [1, 0, 0], 'B2': [0, 1, 0], 'C3': [0, 0, 1]}
percepts = ScoreboardModel().build().predict_percept(implant)
plot_argus_simulated_phosphenes(percepts, implant)
# Add axon map:
_, ax = plt.subplots()
plot_argus_simulated_phosphenes(percepts,
implant,
ax=ax,
axon_map=AxonMapModel())
def test_plot_argus_phosphenes():
df = pd.DataFrame([
{
'subject': 'S1',
'electrode': 'A1',
'image': np.random.rand(10, 10),
'xrange': (-10, 10),
'yrange': (-10, 10)
},
{
'subject': 'S1',
'electrode': 'B2',
'image': np.random.rand(10, 10),
'xrange': (-10, 10),
'yrange': (-10, 10)
},
])
_, ax = plt.subplots()
plot_argus_phosphenes(df, ArgusI(), ax=ax)
plot_argus_phosphenes(df, ArgusII(), ax=ax)
# Add axon map:
_, ax = plt.subplots()
plot_argus_phosphenes(df, ArgusI(), ax=ax, axon_map=AxonMapModel())
# Data must be a DataFrame:
with pytest.raises(TypeError):
plot_argus_phosphenes(np.ones(10), ArgusI())
# DataFrame must have the required columns:
with pytest.raises(ValueError):
plot_argus_phosphenes(pd.DataFrame(), ArgusI())
# Subjects must all be the same:
with pytest.raises(ValueError):
dff = pd.DataFrame([{'subject': 'S1'}, {'subject': 'S2'}])
plot_argus_phosphenes(dff, ArgusI())
# Works only for Argus:
with pytest.raises(TypeError):
plot_argus_phosphenes(df, AlphaAMS())
# Works only for axon maps:
with pytest.raises(TypeError):
plot_argus_phosphenes(df, ArgusI(), ax=ax, axon_map=ScoreboardModel())
# Manual subject selection
plot_argus_phosphenes(df[df.electrode == 'B2'], ArgusI(), ax=ax)
# If no implant given, dataframe must have additional columns:
with pytest.raises(ValueError):
plot_argus_phosphenes(df, ax=ax)
df['implant_type_str'] = 'ArgusII'
df['implant_x'] = 0
df['implant_y'] = 0
df['implant_rot'] = 0
plot_argus_phosphenes(df, ax=ax)
The scoreboard model can be instantiated and run in three simple steps. 1. Creating the model --------------------- The first step is to instantiate the :py:class:`~pulse2percept.models.ScoreboardModel` class by calling its constructor method. The most important parameter to set is ``rho`` from the above equation (here set to 100 micrometers): """ from pulse2percept.models import ScoreboardModel model = ScoreboardModel(rho=100) ############################################################################## # Parameters you don't specify will take on default values. You can inspect # all current model parameters as follows: print(model) ############################################################################## # This reveals a number of other parameters to set, such as: # # * ``xrange``, ``yrange``: the extent of the visual field to be simulated, # specified as a range of x and y coordinates (in degrees of visual angle, # or dva). For example, we are currently sampling x values between -20 dva # and +20dva, and y values between -15 dva and +15 dva. # * ``xystep``: The resolution (in dva) at which to sample the visual field.
def test_ScoreboardModel_predict_percept():
model = ScoreboardModel(xystep=0.55, rho=100, thresh_percept=0)
model.build()
# Single-electrode stim:
img_stim = np.zeros(60)
img_stim[47] = 1
percept = model.predict_percept(ArgusII(stim=img_stim))
# Single bright pixel, very small Gaussian kernel:
npt.assert_equal(np.sum(percept.data > 0.9), 1)
npt.assert_equal(np.sum(percept.data > 0.5), 1)
npt.assert_equal(np.sum(percept.data > 0.1), 7)
npt.assert_equal(np.sum(percept.data > 0.00001), 35)
# Brightest pixel is in lower right:
npt.assert_almost_equal(percept.data[34, 47, 0], np.max(percept.data))
# Full Argus II: 60 bright spots
model = ScoreboardModel(engine='serial', xystep=0.55, rho=100)
model.build()
percept = model.predict_percept(ArgusII(stim=np.ones(60)))
npt.assert_equal(np.sum(np.isclose(percept.data, 0.9, rtol=0.1, atol=0.1)),
60)
# Model gives same outcome as Spatial:
spatial = ScoreboardSpatial(engine='serial', xystep=1, rho=100)
spatial.build()
spatial_percept = model.predict_percept(ArgusII(stim=np.ones(60)))
npt.assert_almost_equal(percept.data, spatial_percept.data)
def test_ScoreboardModel():
# ScoreboardModel automatically sets `rho`:
model = ScoreboardModel(engine='serial', xystep=5)
npt.assert_equal(model.has_space, True)
npt.assert_equal(model.has_time, False)
npt.assert_equal(hasattr(model.spatial, 'rho'), True)
# User can set `rho`:
model.rho = 123
npt.assert_equal(model.rho, 123)
npt.assert_equal(model.spatial.rho, 123)
model.build(rho=987)
npt.assert_equal(model.rho, 987)
npt.assert_equal(model.spatial.rho, 987)
# Nothing in, None out:
npt.assert_equal(model.predict_percept(ArgusI()), None)
# Zero in = zero out:
implant = ArgusI(stim=np.zeros(16))
npt.assert_almost_equal(model.predict_percept(implant).data, 0)
# Multiple frames are processed independently:
model = ScoreboardModel(engine='serial', rho=200, xystep=5)
model.build()
percept = model.predict_percept(ArgusI(stim={'A1': [1, 2]}))
npt.assert_equal(percept.shape, list(model.grid.x.shape) + [2])
pmax = percept.data.max(axis=(0, 1))
npt.assert_almost_equal(percept.data[2, 3, :], pmax)
npt.assert_almost_equal(pmax[1] / pmax[0], 2.0)
constructor method. The model simulates a patch of the visual field specified by ``xrange`` and ``yrange`` (in degrees of visual angle), sampled at a step size of ``xystep``. The grid that is created from these parameters is equivalent to calling NumPy's ``linspace(xrange[0], xrange[1], num=xystep)``. By default, this patch is quite large, spanning 30deg x 30deg. Because PRIMA is rather small, we want to reduce the window size to 6deg x 6deg and sample it at 0.05deg resolution: """ # sphinx_gallery_thumbnail_number = 2 from pulse2percept.models import ScoreboardModel model = ScoreboardModel(xrange=(-3, 3), yrange=(-3, 3), xystep=0.05) ############################################################################## # Parameters you don't specify will take on default values. You can inspect # all current model parameters as follows: print(model) ############################################################################## # This reveals a number of other parameters to set, such as: # # * ``xrange``, ``yrange``: the extent of the visual field to be simulated, # specified as a range of x and y coordinates (in degrees of visual angle, # or dva). For example, we are currently sampling x values between -20 dva # and +20dva, and y values between -15 dva and +15 dva. # * ``xystep``: The resolution (in dva) at which to sample the visual field.
def test_ScoreboardModel():
# ScoreboardModel automatically sets `rho`:
model = ScoreboardModel(engine='serial', xystep=5)
npt.assert_equal(model.has_space, True)
npt.assert_equal(model.has_time, False)
npt.assert_equal(hasattr(model.spatial, 'rho'), True)
# User can set `rho`:
model.rho = 123
npt.assert_equal(model.rho, 123)
npt.assert_equal(model.spatial.rho, 123)
model.build(rho=987)
npt.assert_equal(model.rho, 987)
npt.assert_equal(model.spatial.rho, 987)
# Converting ret <=> dva
npt.assert_equal(isinstance(model.retinotopy, Watson2014Map), True)
npt.assert_almost_equal(model.retinotopy.ret2dva(0, 0), (0, 0))
npt.assert_almost_equal(model.retinotopy.dva2ret(0, 0), (0, 0))
model2 = ScoreboardModel(retinotopy=Watson2014DisplaceMap())
npt.assert_equal(isinstance(model2.retinotopy, Watson2014DisplaceMap),
True)
# Nothing in, None out:
npt.assert_equal(model.predict_percept(ArgusI()), None)
# Zero in = zero out:
implant = ArgusI(stim=np.zeros(16))
npt.assert_almost_equal(model.predict_percept(implant).data, 0)
# Multiple frames are processed independently:
model = ScoreboardModel(engine='serial',
rho=200,
xystep=5,
xrange=(-20, 20),
yrange=(-15, 15))
model.build()
percept = model.predict_percept(ArgusI(stim={'A1': [1, 2]}))
npt.assert_equal(percept.shape, list(model.grid.x.shape) + [2])
pmax = percept.data.max(axis=(0, 1))
npt.assert_almost_equal(percept.data[2, 3, :], pmax)
npt.assert_almost_equal(pmax[1] / pmax[0], 2.0)
npt.assert_almost_equal(percept.time, [0, 1])
def test_ScoreboardModel_predict_percept():
model = ScoreboardModel(xystep=0.55,
rho=100,
thresh_percept=0,
xrange=(-20, 20),
yrange=(-15, 15))
model.build()
# Single-electrode stim:
img_stim = np.zeros(60)
img_stim[47] = 1
percept = model.predict_percept(ArgusII(stim=img_stim))
# Single bright pixel, very small Gaussian kernel:
npt.assert_equal(np.sum(percept.data > 0.8), 1)
npt.assert_equal(np.sum(percept.data > 0.5), 2)
npt.assert_equal(np.sum(percept.data > 0.1), 7)
npt.assert_equal(np.sum(percept.data > 0.00001), 32)
# Brightest pixel is in lower right:
npt.assert_almost_equal(percept.data[33, 46, 0], np.max(percept.data))
# Full Argus II: 60 bright spots
model = ScoreboardModel(engine='serial', xystep=0.55, rho=100)
model.build()
percept = model.predict_percept(ArgusII(stim=np.ones(60)))
npt.assert_equal(np.sum(np.isclose(percept.data, 0.8, rtol=0.1, atol=0.1)),
88)
# Model gives same outcome as Spatial:
spatial = ScoreboardSpatial(engine='serial', xystep=1, rho=100)
spatial.build()
spatial_percept = model.predict_percept(ArgusII(stim=np.ones(60)))
npt.assert_almost_equal(percept.data, spatial_percept.data)
npt.assert_equal(percept.time, None)
# Warning for nonzero electrode-retina distances
implant = ArgusI(stim=np.ones(16), z=10)
msg = ("Nonzero electrode-retina distances do not have any effect on the "
"model output.")
assert_warns_msg(UserWarning, model.predict_percept, msg, implant)