def test_Nanduri2012Spatial():
# Nanduri2012Spatial automatically sets `atten_a`:
model = Nanduri2012Spatial(engine='serial', xystep=5)
# User can set `atten_a`:
model.atten_a = 12345
npt.assert_equal(model.atten_a, 12345)
model.build(atten_a=987)
npt.assert_equal(model.atten_a, 987)
# Nothing in, None out:
npt.assert_equal(model.predict_percept(ArgusI()), None)
# Zero in = zero out:
implant = ArgusI(stim=np.zeros(16))
percept = model.predict_percept(implant)
npt.assert_equal(isinstance(percept, Percept), True)
npt.assert_equal(percept.shape, list(model.grid.x.shape) + [1])
npt.assert_almost_equal(percept.data, 0)
# Only works for DiskElectrode arrays:
with pytest.raises(TypeError):
implant = ProsthesisSystem(ElectrodeArray(PointSource(0, 0, 0)))
implant.stim = 1
model.predict_percept(implant)
with pytest.raises(TypeError):
implant = ProsthesisSystem(
ElectrodeArray(
[DiskElectrode(0, 0, 0, 100),
PointSource(100, 100, 0)]))
implant.stim = [1, 1]
model.predict_percept(implant)
# Multiple frames are processed independently:
model = Nanduri2012Spatial(engine='serial',
atten_a=14000,
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)
# Nanduri model uses a linear dva2ret conversion factor:
for factor in [0.0, 1.0, 2.0]:
npt.assert_almost_equal(model.retinotopy.dva2ret(factor, factor),
(280.0 * factor, 280.0 * factor))
for factor in [0.0, 1.0, 2.0]:
npt.assert_almost_equal(
model.retinotopy.ret2dva(280.0 * factor, 280.0 * factor),
(factor, factor))
def test_ProsthesisSystem():
# Invalid instantiations:
with pytest.raises(ValueError):
ProsthesisSystem(ElectrodeArray(PointSource(0, 0, 0)), eye='both')
# Iterating over the electrode array:
implant = ProsthesisSystem(PointSource(0, 0, 0))
npt.assert_equal(implant.n_electrodes, 1)
npt.assert_equal(implant[0], implant.earray[0])
npt.assert_equal(implant.keys(), implant.earray.keys())
# Set a stimulus after the constructor:
npt.assert_equal(implant.stim, None)
implant.stim = 3
npt.assert_equal(isinstance(implant.stim, Stimulus), True)
npt.assert_equal(implant.stim.shape, (1, 1))
npt.assert_equal(implant.stim.time, None)
npt.assert_equal(implant.stim.electrodes, [0])
with pytest.raises(ValueError):
# Wrong number of stimuli
implant.stim = [1, 2]
with pytest.raises(TypeError):
# Invalid stim type:
implant.stim = "stim"
def test_ElectrodeArray():
with pytest.raises(TypeError):
ElectrodeArray("foo")
with pytest.raises(TypeError):
ElectrodeArray(OrderedDict({'A1': 0}))
with pytest.raises(TypeError):
ElectrodeArray([0])
# Empty array:
earray = ElectrodeArray([])
npt.assert_equal(earray.n_electrodes, 0)
# npt.assert_equal(earray[0], None)
npt.assert_equal(earray['A01'], None)
with pytest.raises(TypeError):
earray[PointSource(0, 0, 0)]
ElectrodeArray([])
# A single electrode:
earray = ElectrodeArray(PointSource(0, 1, 2))
npt.assert_equal(earray.n_electrodes, 1)
npt.assert_equal(isinstance(earray[0], PointSource), True)
npt.assert_equal(isinstance(earray[[0]], list), True)
npt.assert_equal(isinstance(earray[[0]][0], PointSource), True)
npt.assert_almost_equal(earray[0].x, 0)
npt.assert_almost_equal(earray[0].y, 1)
npt.assert_almost_equal(earray[0].z, 2)
# Indexing:
ps1, ps2 = PointSource(0, 0, 0), PointSource(1, 1, 1)
earray = ElectrodeArray({'A01': ps1, 'D07': ps2})
npt.assert_equal(earray['A01'], ps1)
npt.assert_equal(earray['D07'], ps2)
# Slots:
npt.assert_equal(hasattr(earray, '__slots__'), True)
npt.assert_equal(hasattr(earray, '__dict__'), False)
def test_Nanduri2012Temporal():
model = Nanduri2012Temporal()
# User can set their own params:
model.dt = 0.1
npt.assert_equal(model.dt, 0.1)
model.build(dt=1e-4)
npt.assert_equal(model.dt, 1e-4)
# User cannot add more model parameters:
with pytest.raises(FreezeError):
model.rho = 100
# Nothing in, None out:
npt.assert_equal(model.predict_percept(ArgusI().stim), None)
# Zero in = zero out:
implant = ArgusI(stim=np.zeros((16, 100)))
percept = model.predict_percept(implant.stim, t_percept=[0, 1, 2])
npt.assert_equal(isinstance(percept, Percept), True)
npt.assert_equal(percept.shape, (16, 1, 3))
npt.assert_almost_equal(percept.data, 0)
# Can't request the same time more than once (this would break the Cython
# loop, because `idx_frame` is incremented after a write; also doesn't
# make much sense):
with pytest.raises(ValueError):
implant.stim = np.ones((16, 100))
model.predict_percept(implant.stim, t_percept=[0.2, 0.2])
# Brightness scales differently with amplitude vs frequency:
model = Nanduri2012Temporal(dt=5e-3)
model.build()
sdur = 1000.0 # stimulus duration (ms)
pdur = 0.45 # (ms)
t_percept = np.arange(0, sdur, 5)
implant = ProsthesisSystem(ElectrodeArray(DiskElectrode(0, 0, 0, 260)))
bright_amp = []
for amp in np.linspace(0, 50, 5):
# implant.stim = PulseTrain(model.dt, freq=20, amp=amp, dur=sdur,
# pulse_dur=pdur, interphase_dur=pdur)
implant.stim = BiphasicPulseTrain(20, amp, pdur, interphase_dur=pdur,
stim_dur=sdur)
percept = model.predict_percept(implant.stim, t_percept=t_percept)
bright_amp.append(percept.data.max())
bright_amp_ref = [0.0, 0.00890, 0.0657, 0.1500, 0.1691]
npt.assert_almost_equal(bright_amp, bright_amp_ref, decimal=3)
bright_freq = []
for freq in np.linspace(0, 100, 5):
# implant.stim = PulseTrain(model.dt, freq=freq, amp=20, dur=sdur,
# pulse_dur=pdur, interphase_dur=pdur)
implant.stim = BiphasicPulseTrain(freq, 20, pdur, interphase_dur=pdur,
stim_dur=sdur)
percept = model.predict_percept(implant.stim, t_percept=t_percept)
bright_freq.append(percept.data.max())
bright_freq_ref = [0.0, 0.0394, 0.0741, 0.1073, 0.1385]
npt.assert_almost_equal(bright_freq, bright_freq_ref, decimal=3)
def test_ProsthesisSystem():
# Invalid instantiations:
with pytest.raises(ValueError):
ProsthesisSystem(ElectrodeArray(PointSource(0, 0, 0)),
eye='both')
with pytest.raises(TypeError):
ProsthesisSystem(Stimulus)
# Iterating over the electrode array:
implant = ProsthesisSystem(PointSource(0, 0, 0))
npt.assert_equal(implant.n_electrodes, 1)
npt.assert_equal(implant[0], implant.earray[0])
npt.assert_equal(implant.electrode_names, implant.earray.electrode_names)
for i, e in zip(implant, implant.earray):
npt.assert_equal(i, e)
# Set a stimulus after the constructor:
npt.assert_equal(implant.stim, None)
implant.stim = 3
npt.assert_equal(isinstance(implant.stim, Stimulus), True)
npt.assert_equal(implant.stim.shape, (1, 1))
npt.assert_equal(implant.stim.time, None)
npt.assert_equal(implant.stim.electrodes, [0])
ax = implant.plot()
npt.assert_equal(len(ax.texts), 0)
npt.assert_equal(len(ax.collections), 1)
with pytest.raises(ValueError):
# Wrong number of stimuli
implant.stim = [1, 2]
with pytest.raises(TypeError):
# Invalid stim type:
implant.stim = "stim"
# Invalid electrode names:
with pytest.raises(ValueError):
implant.stim = {'A1': 1}
with pytest.raises(ValueError):
implant.stim = Stimulus({'A1': 1})
# Safe mode requires charge-balanced pulses:
with pytest.raises(ValueError):
implant = ProsthesisSystem(PointSource(0, 0, 0), safe_mode=True)
implant.stim = 1
# Slots:
npt.assert_equal(hasattr(implant, '__slots__'), True)
npt.assert_equal(hasattr(implant, '__dict__'), False)
stim.plot(time=(0, 60)) ############################################################################### # Creating an implant # ------------------- # # Before we can run the Nanduri model, we need to create a retinal implant to # which we can assign the above pulse train. # # For the purpose of this exercise, we will create an # :py:class:`~pulse2percept.implants.ElectrodeArray` consisting of a single # :py:class:`~pulse2percept.implants.DiskElectrode` with radius=260um centered # at (x,y) = (0,0); i.e., centered over the fovea: from pulse2percept.implants import DiskElectrode, ElectrodeArray earray = ElectrodeArray(DiskElectrode(0, 0, 0, 260)) ############################################################################### # Usually we would use a predefined retinal implant such as # :py:class:`~pulse2percept.implants.ArgusII` or # :py:class:`~pulse2percept.implants.AlphaIMS`. Alternatively, we can wrap the # electrode array created above with a # :py:class:`~pulse2percept.implants.ProsthesisSystem` to create our own # retinal implant. We will also assign the above created stimulus to it: from pulse2percept.implants import ProsthesisSystem implant = ProsthesisSystem(earray, stim=stim) ############################################################################### # Running the model # -----------------
def test_Nanduri2012Model_predict_percept():
# Nothing in = nothing out:
model = Nanduri2012Model(xrange=(0, 0), yrange=(0, 0), engine='serial')
model.build()
implant = ArgusI(stim=None)
npt.assert_equal(model.predict_percept(implant), None)
implant.stim = np.zeros(16)
npt.assert_almost_equal(model.predict_percept(implant).data, 0)
# Single-pixel model same as TemporalModel:
implant = ProsthesisSystem(DiskElectrode(0, 0, 0, 100))
# implant.stim = PulseTrain(5e-6)
implant.stim = BiphasicPulseTrain(20, 20, 0.45, interphase_dur=0.45)
t_percept = [0, 0.01, 1.0]
percept = model.predict_percept(implant, t_percept=t_percept)
temp = Nanduri2012Temporal().build()
temp = temp.predict_percept(implant.stim, t_percept=t_percept)
npt.assert_almost_equal(percept.data, temp.data, decimal=4)
# Only works for DiskElectrode arrays:
with pytest.raises(TypeError):
implant = ProsthesisSystem(ElectrodeArray(PointSource(0, 0, 0)))
implant.stim = 1
model.predict_percept(implant)
with pytest.raises(TypeError):
implant = ProsthesisSystem(
ElectrodeArray(
[DiskElectrode(0, 0, 0, 100),
PointSource(100, 100, 0)]))
implant.stim = [1, 1]
model.predict_percept(implant)
# Requested times must be multiples of model.dt:
implant = ProsthesisSystem(ElectrodeArray(DiskElectrode(0, 0, 0, 260)))
# implant.stim = PulseTrain(tsample)
implant.stim = BiphasicPulseTrain(20, 20, 0.45)
model.temporal.dt = 0.1
with pytest.raises(ValueError):
model.predict_percept(implant, t_percept=[0.01])
with pytest.raises(ValueError):
model.predict_percept(implant, t_percept=[0.01, 1.0])
with pytest.raises(ValueError):
model.predict_percept(implant, t_percept=np.arange(0, 0.5, 0.101))
model.predict_percept(implant, t_percept=np.arange(0, 0.5, 1.0000001))
# Can't request the same time more than once (this would break the Cython
# loop, because `idx_frame` is incremented after a write; also doesn't
# make much sense):
with pytest.raises(ValueError):
model.predict_percept(implant, t_percept=[0.2, 0.2])
# It's ok to extrapolate beyond `stim` if the `extrapolate` flag is set:
model.temporal.dt = 1e-2
npt.assert_almost_equal(
model.predict_percept(implant, t_percept=10000).data, 0)
# Output shape must be determined by t_percept:
npt.assert_equal(
model.predict_percept(implant, t_percept=0).shape, (1, 1, 1))
npt.assert_equal(
model.predict_percept(implant, t_percept=[0, 1]).shape, (1, 1, 2))
# Brightness vs. size (use values from Nanduri paper):
model = Nanduri2012Model(xystep=0.5, xrange=(-4, 4), yrange=(-4, 4))
model.build()
implant = ProsthesisSystem(ElectrodeArray(DiskElectrode(0, 0, 0, 260)))
amp_th = 30
bright_th = 0.107
stim_dur = 1000.0
pdur = 0.45
t_percept = np.arange(0, stim_dur, 5)
amp_factors = [1, 6]
frames_amp = []
for amp_f in amp_factors:
implant.stim = BiphasicPulseTrain(20,
amp_f * amp_th,
pdur,
interphase_dur=pdur,
stim_dur=stim_dur)
percept = model.predict_percept(implant, t_percept=t_percept)
idx_frame = np.argmax(np.max(percept.data, axis=(0, 1)))
brightest_frame = percept.data[..., idx_frame]
frames_amp.append(brightest_frame)
npt.assert_equal([np.sum(f > bright_th) for f in frames_amp], [0, 161])
freqs = [20, 120]
frames_freq = []
for freq in freqs:
implant.stim = BiphasicPulseTrain(freq,
1.25 * amp_th,
pdur,
interphase_dur=pdur,
stim_dur=stim_dur)
percept = model.predict_percept(implant, t_percept=t_percept)
idx_frame = np.argmax(np.max(percept.data, axis=(0, 1)))
brightest_frame = percept.data[..., idx_frame]
frames_freq.append(brightest_frame)
npt.assert_equal([np.sum(f > bright_th) for f in frames_freq], [21, 49])
def test_ElectrodeArray_remove_electrode():
earray1 = ElectrodeArray([])
earray2 = ElectrodeArray([])
npt.assert_equal(earray1.n_electrodes, 0)
# Can't remove electrodes from empty electrodeArray
with pytest.raises(ValueError):
earray1.remove_electrode(None)
with pytest.raises(ValueError):
earray1.remove_electrode("foo")
key = [0] * 4
key[0] = 'D03'
key[1] = 'A02'
key[2] = 'F10'
key[3] = 'E12'
earray1.add_electrode(key[0], PointSource(0, 1, 2))
earray1.add_electrode(key[1], PointSource(3, 4, 5))
earray1.add_electrode(key[2], PointSource(6, 7, 8))
earray1.add_electrode(key[3], PointSource(9, 10, 11))
npt.assert_equal(earray1.n_electrodes, 4)
earray2.add_electrode(key[0], PointSource(0, 1, 2))
earray2.add_electrode(key[1], PointSource(3, 4, 5))
earray2.add_electrode(key[2], PointSource(6, 7, 8))
earray2.add_electrode(key[3], PointSource(9, 10, 11))
npt.assert_equal(earray2.n_electrodes, 4)
# Remove one electrode key[1] from the electrodeArray
earray1.remove_electrode(key[0])
npt.assert_equal(earray1.n_electrodes, 3)
# Can't remove an electrode that has been removed
with pytest.raises(ValueError):
earray1.remove_electrode(key[0])
# List keeps order:
npt.assert_equal(earray1[0], earray1[key[1]])
npt.assert_equal(earray1[1], earray1[key[2]])
npt.assert_equal(earray1[2], earray1[key[3]])
# Other electrodes stay the same
for k in [key[1], key[2], key[3]]:
npt.assert_equal(earray1[k].x, earray2[k].x)
npt.assert_equal(earray1[k].y, earray2[k].y)
npt.assert_equal(earray1[k].z, earray2[k].z)
# Remove two more electrodes from the electrodeArray
# List keeps order
earray1.remove_electrode(key[1])
earray1.remove_electrode(key[2])
npt.assert_equal(earray1.n_electrodes, 1)
npt.assert_equal(earray1[0], earray1[key[3]])
# The last electrode stays the same
for key in [key[3]]:
npt.assert_equal(earray1[key].x, earray2[key].x)
npt.assert_equal(earray1[key].y, earray2[key].y)
npt.assert_equal(earray1[key].z, earray2[key].z)
def test_ElectrodeArray_add_electrode():
earray = ElectrodeArray([])
npt.assert_equal(earray.n_electrodes, 0)
with pytest.raises(TypeError):
earray.add_electrode('A01', ElectrodeArray([]))
# Add an electrode:
key0 = 'A04'
earray.add_electrode(key0, PointSource(0, 1, 2))
npt.assert_equal(earray.n_electrodes, 1)
# Both numeric and string index should work:
for key in [key0, 0]:
npt.assert_equal(isinstance(earray[key], PointSource), True)
npt.assert_almost_equal(earray[key].x, 0)
npt.assert_almost_equal(earray[key].y, 1)
npt.assert_almost_equal(earray[key].z, 2)
with pytest.raises(ValueError):
# Can't add the same electrode twice:
earray.add_electrode(key0, PointSource(0, 1, 2))
# Add another electrode:
key1 = 'A01'
earray.add_electrode(key1, DiskElectrode(4, 5, 6, 7))
npt.assert_equal(earray.n_electrodes, 2)
# Both numeric and string index should work:
for key in [key1, 1]:
npt.assert_equal(isinstance(earray[key], DiskElectrode), True)
npt.assert_almost_equal(earray[key].x, 4)
npt.assert_almost_equal(earray[key].y, 5)
npt.assert_almost_equal(earray[key].z, 6)
npt.assert_almost_equal(earray[key].r, 7)
# We can also get a list of electrodes:
for keys in [[key0, key1], [0, key1], [key0, 1], [0, 1]]:
selected = earray[keys]
npt.assert_equal(isinstance(selected, list), True)
npt.assert_equal(isinstance(selected[0], PointSource), True)
npt.assert_equal(isinstance(selected[1], DiskElectrode), True)
def test_ElectrodeArray_add_electrodes():
earray = ElectrodeArray([])
npt.assert_equal(earray.n_electrodes, 0)
with pytest.raises(TypeError):
earray.add_electrodes(None)
with pytest.raises(TypeError):
earray.add_electrodes("foo")
# Add 2 electrodes, keep order:
key = [0] * 6
key[0] = 'D03'
key[1] = 'A02'
earray.add_electrodes({key[0]: PointSource(0, 1, 2)})
earray.add_electrodes({key[1]: PointSource(3, 4, 5)})
npt.assert_equal(earray[0], earray[key[0]])
npt.assert_equal(earray[1], earray[key[1]])
# Can't add the same key twice:
with pytest.raises(ValueError):
earray.add_electrodes({key[0]: PointSource(3, 5, 7)})
# Add 2 more, now keep order:
key[2] = 'F10'
key[3] = 'E12'
earray.add_electrodes({key[2]: PointSource(6, 7, 8)})
earray.add_electrodes({key[3]: PointSource(9, 10, 11)})
npt.assert_equal(earray[0], earray[key[0]])
npt.assert_equal(earray[1], earray[key[1]])
npt.assert_equal(earray[2], earray[key[2]])
npt.assert_equal(earray[3], earray[key[3]])
# List keeps order:
earray.add_electrodes([PointSource(12, 13, 14), PointSource(15, 16, 17)])
npt.assert_equal(earray[0], earray[key[0]])
npt.assert_equal(earray[1], earray[key[1]])
npt.assert_equal(earray[2], earray[key[2]])
npt.assert_equal(earray[3], earray[key[3]])
npt.assert_equal(earray[4].x, 12)
npt.assert_equal(earray[5].x, 15)
# Order is preserved in for loop:
for i, (key, val) in enumerate(earray.items()):
npt.assert_equal(earray[i], earray[key])
npt.assert_equal(earray[i], val)