def from_image(
image,
pixel_sizes_nm,
start=int(1e9),
dt=7,
axes=[0, 1],
samples_per_pixel=5,
line_padding=3,
):
"""Generate a mock file that can be read by Kymo or Scan"""
infowave, photon_counts = generate_image_data(image, samples_per_pixel,
line_padding)
json_string = generate_scan_json([{
"axis": axis,
"num of pixels": num_pixels,
"pixel size (nm)": pixel_size,
} for pixel_size, axis, num_pixels in zip(pixel_sizes_nm, axes,
image.shape[-2:])])
return (
MockConfocalFile(
Slice(Continuous(infowave, start=start, dt=dt)),
Slice(Continuous(photon_counts, start=start, dt=dt)),
),
json.loads(json_string)["value0"],
start + len(infowave) * dt,
)
def make_mock_fd(force, distance, start=0):
"""Mock FD curve which is not attached to an actual file, timestamps start at `start`"""
assert len(force) == len(distance)
fd = FdCurve(file=None, start=None, stop=None, name="")
timestamps = np.arange(len(force)) + start
fd._force_cache = Slice(TimeSeries(force, timestamps))
fd._distance_cache = Slice(TimeSeries(distance, timestamps))
return fd
def test_selector_widgets_open():
channel = Slice(TimeSeries([1, 2, 3, 4], [100, 200, 300, 400]))
widget = channel.range_selector()
assert isinstance(widget, BaseRangeSelectorWidget)
fd_curve = make_mock_fd(np.arange(10), np.arange(10), start=int(2500e9))
widget = fd_curve.range_selector()
assert isinstance(widget, BaseRangeSelectorWidget)
widget = fd_curve.distance_range_selector()
assert isinstance(widget, BaseRangeSelectorWidget)
def from_streams(
start,
dt,
axes,
num_pixels,
pixel_sizes_nm,
infowave,
red_photon_counts=None,
blue_photon_counts=None,
green_photon_counts=None,
):
make_slice = lambda data: None if data is None else Slice(
Continuous(data, start, dt))
if axes == [] and num_pixels == [] and pixel_sizes_nm == []:
json_string = generate_scan_json([])
else:
json_string = generate_scan_json([{
"axis": axis,
"num of pixels": num_pixels,
"pixel size (nm)": pixel_size,
} for (axis, pixel_size,
num_pixels) in zip(axes, pixel_sizes_nm, num_pixels)])
return (
MockConfocalFile(
infowave=make_slice(infowave),
red_channel=make_slice(red_photon_counts),
blue_channel=make_slice(blue_photon_counts),
green_channel=make_slice(green_photon_counts),
),
json.loads(json_string)["value0"],
start + len(infowave) * dt,
)
def test_plot_with_lf_force():
dt = int(1e9 / 78125)
start = 1536582124217030400
kymo = generate_kymo(
"Mock",
np.ones((5, 5)),
pixel_size_nm=100,
start=start,
dt=dt,
samples_per_pixel=2,
line_padding=0,
)
# Mock a force channel onto this file
data = np.array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
timestamps = data * 5 * dt + start
channel = Slice(TimeSeries(data, timestamps))
setattr(kymo.file, "force1x", empty_slice) # Not present in file
setattr(kymo.file, "downsampled_force1x", empty_slice) # Not present in file
setattr(kymo.file, "force2y", empty_slice) # Not present in file
setattr(kymo.file, "downsampled_force2y", channel)
with pytest.warns(
RuntimeWarning, match="Using downsampled force since high frequency force is unavailable."
):
kymo.plot_with_force("2y", "red")
np.testing.assert_allclose(plt.gca().lines[0].get_ydata(), [0.5, 2.5, 4.5, 6.5, 8.5])
with pytest.raises(RuntimeError, match="Desired force channel 1x not available in h5 file"):
kymo.plot_with_force("1x", "red")
def test_gmm_plots(trace_simple):
data, statepath, params = trace_simple
m = GaussianMixtureModel(data,
params["n_states"],
init_method="kmeans",
n_init=1,
tol=1e-3,
max_iter=100)
trace = Slice(Continuous(data, 20000, 12800))
m.hist(trace)
plt.close()
m.plot(trace)
plt.close()
def test_plot_correlated():
start = 1592916040906356300
dt = int(1e9)
cc = Slice(Continuous(np.arange(0, 1000, 2), start, dt), {
"y": "mock",
"title": "mock"
})
img = np.array([np.ones((5, 4)) * idx for idx in np.arange(3)])
scan = generate_scan(
"test",
img,
[1, 1],
start=start,
dt=dt,
samples_per_pixel=4,
line_padding=4,
)
scan.plot_correlated(cc, channel="red")
imgs = [
obj for obj in mpl.pyplot.gca().get_children()
if isinstance(obj, mpl.image.AxesImage)
]
assert len(imgs) == 1
np.testing.assert_allclose(imgs[0].get_array(), np.zeros((5, 4)))
scan.plot_correlated(cc, channel="red", frame=1)
imgs = [
obj for obj in mpl.pyplot.gca().get_children()
if isinstance(obj, mpl.image.AxesImage)
]
np.testing.assert_allclose(imgs[0].get_array(), np.ones((5, 4)))
# When no data overlaps, we need to raise.
with pytest.raises(AssertionError,
match="No overlap between range and selected channel"):
scan.plot_correlated(cc["500s":], channel="red", frame=1)
import pytest
import numpy as np
from lumicks.pylake.channel import Slice, Continuous, TimeSeries, TimeTags
t_start = 1 + int(1e18)
time_series = np.array([1, 2, 3, 4, 5], dtype=np.int64) + int(1e18)
slice_continuous_1 = Slice(Continuous([1, 2, 3, 4, 5], start=t_start, dt=1))
slice_continuous_2 = Slice(Continuous([2, 2, 2, 2, 2], start=t_start, dt=1))
slice_timeseries_1 = Slice(TimeSeries([1, 2, 3, 4, 5], time_series))
slice_timeseries_2 = Slice(TimeSeries([2, 2, 2, 2, 2], time_series))
operators = [
"__add__",
"__sub__",
"__truediv__",
"__mul__",
"__pow__",
"__radd__",
"__rsub__",
"__rtruediv__",
"__rmul__",
"__rpow__",
]
@pytest.mark.parametrize(
"slice1, slice2",
[
(slice_continuous_1, slice_continuous_2),
(slice_timeseries_1, slice_timeseries_2),
(slice_continuous_1, slice_timeseries_2),
def test_gmm_from_slice(trace_simple):
data, statepath, params = trace_simple
trace = Slice(Continuous(data, 20000, 12800))
m = GaussianMixtureModel.from_channel(trace, params["n_states"])
np.testing.assert_allclose(m.means, params["means"], atol=0.05)