def generate(cls, **cnf):
"generate a view containing"
experiment = cls.tasktype(**cnf)
data = experiment.track(seed=experiment.seed, nbeads=experiment.nbeads)
track = Track(**data)
track.truth = data['truth']
return (TrackView(track=track, data=track.beads,
level=Level.peak).withaction(cls._action))
def swap(self,
data: Union[Track, TracksDict, Cycles, str, Axis] = None,
axis: Union[str, Axis] = None) -> Events:
"Returns indexes or values in data at the same key and index"
this = cast(Events, self)
if isinstance(data, TracksDict):
if axis is not None:
axis = Axis(axis)
if this.track.key in data:
data = cast(Track, data[this.track.key])
elif axis is not None:
data = cast(Track, data[Axis(axis).name[0] + this.track.key])
else:
raise KeyError("Unknown data")
if isinstance(data, (str, Axis)):
data = Track(path=this.track.path, axis=Axis(data))
if isinstance(data, Track):
data = data.cycles # type: ignore
return this.withaction(
partial(self._swap,
cast(Cycles, data).withphases(PHASE.measure)))
def run(self, args:'Runner'):
"updates frames"
task = cast(_tasks.TrackReaderTask, self.task)
attr = 'cycles' if task.levelou is Level.cycle else 'beads'
rpcomp = next(
(i for i in args.data.model if isinstance(i, _tasks.RawPrecisionTask)),
_tasks.RawPrecisionTask
).computer
if isinstance(task.path, dict):
trk = args.data.setcachedefault(self, TracksDict())
trk.update(task.path)
else:
trk = args.data.setcachedefault(
self,
Track(
path = task.path,
key = task.key,
axis = task.axis,
rawprecisions = rpcomp
)
)
und = next(
(i for i in args.data.model if isinstance(i, _tasks.UndersamplingTask)),
None
)
args.apply(self.__get(attr, task.copy, trk, und), levels = self.levels)
def insert_some_data():
session = DbSessionFactory.create_session()
album = Album()
album.id = 1
album.is_published = True
album.name = 'Uptown'
album.price = 56.10
album.album_image = 'http://cat.img'
for order, item in enumerate(tracks):
track = Track()
track.name = item['title']
track.length = item['duration']
track.display_order = order
album.tracks.append(track)
session.add(album)
session.commit()
def test_concatenate():
'test whether two Track stack properly'
trk1 = Track(path=utpath("small_legacy"))
trk2 = dropbeads(Track(path=utpath("small_legacy")), 0)
size1, size2 = [next(iter(x.data.values())).size for x in (trk1, trk2)]
trk = concatenatetracks(trk1, trk2)
assert set(trk.data.keys()) == (set(trk1.data.keys())
| set(trk2.data.keys()))
assert all((trk.secondaries.frames[1:] - trk.secondaries.frames[:-1]) == 1)
assert all(np.isnan(trk.data[0][-size2:]))
assert all(~np.isnan(trk.data[0][:size1]))
assert_allclose(trk.phases[:len(trk1.phases)], trk1.phases)
assert_allclose(
trk.phases[len(trk1.phases):], trk2.phases +
trk1.secondaries.frames[-1] - trk2.secondaries.frames[0] + 1)
def test_dataframe():
'test whether two Track stack properly'
trk = Track(path=utpath("small_legacy"))
dframe = dataframe(trk)
for i, j in trk.beads:
assert_equal(dframe[f'b{i}'], j)
for i in ("zmag", "phase", "cid"):
assert_equal(dframe[i], getattr(trk.secondaries, i))
assert len({"tsample", "tsink", "tservo"} - set(dframe.columns)) == 0
def test_clone():
'test whether two Track stack properly'
# pylint: disable=protected-access
trk1 = Track(path=utpath("small_legacy"))
trk2 = clone(trk1)
assert not trk1.isloaded
assert not trk2.isloaded
trk1.load()
trk2 = clone(trk1)
assert trk1.isloaded
assert trk2.isloaded
assert trk1._data is not trk2._data
assert trk1._secondaries is not trk2._secondaries
assert trk1._fov is not trk2._fov
assert all(i is j for i, j in zip(trk1.data.values(), trk2.data.values()))
assert all(i is j for i, j in zip(trk1._secondaries.values(),
trk2._secondaries.values()))
assert trk1.fov.image is trk2.fov.image
def test_resampling():
"test resampling"
track = Track(path=utpath("big_legacy"))
track.rawprecision(0)
assert undersample(track, 1) is track
under = undersample(track, 3)
assert_equal(under.phases, track.phases // 3)
assert_equal(under.beads[0], track.beads[0][::3])
assert_equal(under.secondaries.zmag, track.secondaries.zmag[::3])
assert_equal(under.secondaries.tsample['index'],
track.secondaries.tsample['index'] // 3)
assert track.ncycles == under.ncycles
assert track.nframes // 3 + 1 == under.nframes
assert len(track._rawprecisions.cache)
assert len(under._rawprecisions.cache) == 0
assert under.path is None
assert under.framerate == track.framerate / 3
assert under.fov is track.fov
under = undersample(track, 3, 'mean')
assert_equal(under.beads[0],
np.nanmean(track.beads[0][:50289].reshape((-1, 3)), axis=1))
assert track.nframes // 3 == under.nframes
under = undersample(track, 3, np.median)
assert_equal(under.beads[0],
np.nanmedian(track.beads[0][:50289].reshape((-1, 3)), axis=1))
assert track.nframes // 3 == under.nframes
beads = track.beads.withaction(lambda _, i: (i[0], i[1] * 2))
under = undersample(beads, 3)
assert_equal(under.beads[0], track.beads[0][::3] * 2)
beads = track.beads.withaction(lambda _, i: (i[0], i[1] * 2))
under = undersample(beads, 3, cycles=range(0, 1))
phases = track.phases - track.phases[0, 0]
beads = track.beads.withaction(lambda _, i: (i[0], i[1] * 2))
under = undersample(beads, 3, cycles=range(10, 200))
assert_equal(under.beads[0], track.beads[0][phases[10, 0]::3] * 2)
def test_selectcycles():
'test whether two Track stack properly'
trk = Track(path=utpath("big_legacy"))
other = selectcycles(trk, range(5))
assert other.ncycles == 5
assert set(other.beads.keys()) == set(trk.beads.keys())
assert_allclose(other.phases, trk.phases[:5, :] - trk.phases[0, 0])
assert_allclose(
other.secondaries.seconds,
trk.secondaries.seconds[:trk.phases[5, 0] - trk.phases[0, 0]])
other = selectcycles(trk, [2, 4, 10])
assert other.ncycles == 3
assert set(other.beads.keys()) == set(trk.beads.keys())
assert_allclose(other.phases[0, :], trk.phases[2, :] - trk.phases[2, 0])
other = selectcycles(trk, slice(None, None, 2))
assert abs(other.ncycles - trk.ncycles // 2) <= 1
assert set(other.beads.keys()) == set(trk.beads.keys())
assert_allclose(other.phases[0, :], trk.phases[0, :] - trk.phases[0, 0])
def test_phasemanipulator():
"test phase manipulator"
track = Track(path=utpath("big_legacy"))
pma = track.phase
assert pma['pull'] == 3
assert pma['measure'] == 5
inds, phases = pma.cut(range(1))
assert_equal(phases, track.phases[:1, :] - track.phases[0, 0])
assert np.all(np.diff(inds) == 1)
assert inds[0] == 0
assert inds[-1] == track.phases[1, 0] - track.phases[0, 0] - 1
inds, phases = pma.cut(range(track.ncycles - 1, track.ncycles + 10))
assert_equal(phases, track.phases[-1:, :] - track.phases[-1, 0])
assert np.all(np.diff(inds) == 1)
assert inds[0] == track.phases[-1, 0] - track.phases[0, 0]
assert inds[-1] == track.nframes - 1
assert_equal(pma.duration(..., 3), track.phases[:, 4] - track.phases[:, 3])
assert_equal(pma.duration(..., range(3)),
track.phases[:, 3] - track.phases[:, 0])
def test_beadstats():
"test bead extension"
trk1 = Track(path=utpath("big_legacy"), rawprecisions='normalized')
assert trk1.rawprecision().keyword() == "normalized"
trk1.rawprecision("range")
assert trk1.rawprecision().keyword() == "range"
trk1.load()
assert trk1.rawprecision().keyword() == "range"
trk1 = Track(path=utpath("big_legacy"), rawprecisions='range')
assert trk1.rawprecision().keyword() == "range"
trk1.rawprecision("normalized")
assert trk1.rawprecision().keyword() == "normalized"
trk1.load()
assert trk1.rawprecision().keyword() == "normalized"
trk1.rawprecision("range")
assert trk1.rawprecision().keyword() == "range"
assert trk1.rawprecision().keyword() == 'range'
assert trk1.rawprecision().keyword() == 'range'
assert abs(trk1.beadextension(0) - 0.9517850436270237) < 1e-5
assert abs(trk1.phaseposition(1, 0) + 0.10020114) < 1e-5
assert abs(trk1.rawprecision(0) - 0.001809247420169413) < 1e-5
assert abs(trk1.rawprecision(0, None) - 0.001809247420169413) < 1e-5
assert abs(trk1.rawprecision(0, {
1: .5,
3: .5
}) - 0.0018562973127700388) < 1e-5
assert abs(trk1.rawprecision(0) - 0.001809247420169413) < 1e-5
assert abs(trk1.rawprecision(0, (1, 5)) - 0.001809247420169413) < 1e-5
assert abs(trk1.rawprecision(0) - 0.001809247420169413) < 1e-5
assert abs(
trk1.rawprecision(0, {
1: 1 / 3.,
3: 1 / 3.,
5: 1 / 3.
}) - 0.0018470539168144264) < 1e-5
assert abs(trk1.rawprecision(0) - 0.001809247420169413) < 1e-5
trk1.rawprecision("normalized")
assert abs(trk1.rawprecision(0) - 0.0018470539168144264) < 1e-5