1
|
|
|
import math |
2
|
|
|
|
3
|
|
|
import numpy as np |
4
|
|
|
import numpy.testing as npt |
5
|
|
|
import pandas as pd |
6
|
|
|
import pandas.util.testing as pdt |
7
|
|
|
import diff_classifier.features as ft |
8
|
|
|
import diff_classifier.msd as msd |
9
|
|
|
|
10
|
|
|
|
11
|
|
|
def test_unmask_track(): |
12
|
|
|
data = {'Frame': [0, 1, 2, 3, 4, 0, 1, 2, 3, 4], |
13
|
|
|
'Track_ID': [1, 1, 1, 1, 1, 2, 2, 2, 2, 2], |
14
|
|
|
'X': [np.nan, 6, 7, 8, 9, 1, 2, 3, 4, np.nan], |
15
|
|
|
'Y': [np.nan, 7, 8, 9, 10, 2, 3, 4, 5, np.nan], |
16
|
|
|
'Quality': [np.nan, 10, 10, 10, 10, 10, 10, 10, 10, np.nan], |
17
|
|
|
'SN_Ratio': [np.nan, 0.1, 0.1, 0.1, 0.1, 0.1, |
18
|
|
|
0.1, 0.1, 0.1, np.nan], |
19
|
|
|
'Mean_Intensity': [np.nan, 10, 10, 10, 10, 10, 10, 10, 10, np.nan]} |
20
|
|
|
dframe = pd.DataFrame(data=data) |
21
|
|
|
cols = ['Frame', 'Track_ID', 'X', 'Y', 'MSDs', 'Gauss', 'Quality', |
22
|
|
|
'SN_Ratio', 'Mean_Intensity'] |
23
|
|
|
length = max(dframe['Frame']) + 1 |
24
|
|
|
m_df = msd.all_msds2(dframe, frames=length)[cols] |
25
|
|
|
|
26
|
|
|
datat = {'Frame': [float(i) for i in[0, 1, 2, 3]], |
27
|
|
|
'Track_ID': [float(i) for i in[2, 2, 2, 2]], |
28
|
|
|
'X': [float(i) for i in[1, 2, 3, 4]], |
29
|
|
|
'Y': [float(i) for i in[2, 3, 4, 5]], |
30
|
|
|
'MSDs': [float(i) for i in[0, 2, 8, 18]], |
31
|
|
|
'Gauss': [float(i) for i in[0, 0.25, 0.25, 0.25]], |
32
|
|
|
'Quality': 4*[10.0], |
33
|
|
|
'SN_Ratio': 4*[0.1], |
34
|
|
|
'Mean_Intensity': 4*[10.0]} |
35
|
|
|
dft = pd.DataFrame(data=datat) |
36
|
|
|
|
37
|
|
|
pdt.assert_frame_equal(ft.unmask_track(m_df[m_df['Track_ID'] == 2]), dft) |
38
|
|
|
|
39
|
|
|
|
40
|
|
View Code Duplication |
def test_alpha_calc(): |
|
|
|
|
41
|
|
|
frames = 5 |
42
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
43
|
|
|
'X': np.linspace(0, frames, frames)+5, |
44
|
|
|
'Y': np.linspace(0, frames, frames)+3, |
45
|
|
|
'Track_ID': np.ones(frames), |
46
|
|
|
'Quality': 10.0*np.ones(frames), |
47
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
48
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
49
|
|
|
dframe = pd.DataFrame(data=data) |
50
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
51
|
|
|
assert ft.alpha_calc(dframe) == (2.0000000000000004, 0.4999999999999998) |
52
|
|
|
|
53
|
|
|
frames = 10 |
54
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
55
|
|
|
'X': np.sin(np.linspace(0, frames, frames)+5), |
56
|
|
|
'Y': np.cos(np.linspace(0, frames, frames)+3), |
57
|
|
|
'Track_ID': np.ones(frames), |
58
|
|
|
'Quality': 10.0*np.ones(frames), |
59
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
60
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
61
|
|
|
dframe = pd.DataFrame(data=data) |
62
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
63
|
|
|
assert ft.alpha_calc(dframe) == (0.8201034110620524, 0.1494342948594476) |
64
|
|
|
|
65
|
|
|
|
66
|
|
|
def test_gyration_tensor(): |
67
|
|
|
frames = 6 |
68
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
69
|
|
|
'X': np.linspace(0, frames, frames)+5, |
70
|
|
|
'Y': np.linspace(0, frames, frames)+3, |
71
|
|
|
'Track_ID': np.ones(frames), |
72
|
|
|
'Quality': 10.0*np.ones(frames), |
73
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
74
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
75
|
|
|
dframe = pd.DataFrame(data=data) |
76
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
77
|
|
|
o1, o2, o3, o4 = (8.0, 0.0, np.array([0.70710678, -0.70710678]), |
78
|
|
|
np.array([0.70710678, 0.70710678])) |
79
|
|
|
d1, d2, d3, d4 = ft.gyration_tensor(dframe) |
80
|
|
|
|
81
|
|
|
assert d1 == o1 |
82
|
|
|
assert d2 == o2 |
83
|
|
|
npt.assert_almost_equal(o3, d3) |
84
|
|
|
npt.assert_almost_equal(o4, d4) |
85
|
|
|
|
86
|
|
|
frames = 10 |
87
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
88
|
|
|
'X': np.sin(np.linspace(0, frames, frames)+5), |
89
|
|
|
'Y': np.cos(np.linspace(0, frames, frames)+5), |
90
|
|
|
'Track_ID': np.ones(frames), |
91
|
|
|
'Quality': 10.0*np.ones(frames), |
92
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
93
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
94
|
|
|
dframe = pd.DataFrame(data=data) |
95
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
96
|
|
|
o1, o2, o3, o4 = (0.47248734315843355, 0.3447097846562249, |
97
|
|
|
np.array([0.83907153, 0.54402111]), |
98
|
|
|
np.array([-0.54402111, 0.83907153])) |
99
|
|
|
d1, d2, d3, d4 = ft.gyration_tensor(dframe) |
100
|
|
|
|
101
|
|
|
assert d1 == o1 |
102
|
|
|
assert d2 == o2 |
103
|
|
|
npt.assert_almost_equal(o3, d3) |
104
|
|
|
npt.assert_almost_equal(o4, d4) |
105
|
|
|
|
106
|
|
|
|
107
|
|
View Code Duplication |
def test_kurtosis(): |
|
|
|
|
108
|
|
|
frames = 5 |
109
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
110
|
|
|
'X': np.linspace(0, frames, frames)+5, |
111
|
|
|
'Y': np.linspace(0, frames, frames)+3, |
112
|
|
|
'Track_ID': np.ones(frames), |
113
|
|
|
'Quality': 10.0*np.ones(frames), |
114
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
115
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
116
|
|
|
dframe = pd.DataFrame(data=data) |
117
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
118
|
|
|
assert ft.kurtosis(dframe) == 4.079999999999999 |
119
|
|
|
|
120
|
|
|
frames = 10 |
121
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
122
|
|
|
'X': np.sin(np.linspace(0, frames, frames)+3), |
123
|
|
|
'Y': np.cos(np.linspace(0, frames, frames)+3), |
124
|
|
|
'Track_ID': np.ones(frames), |
125
|
|
|
'Quality': 10.0*np.ones(frames), |
126
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
127
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
128
|
|
|
dframe = pd.DataFrame(data=data) |
129
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
130
|
|
|
assert ft.kurtosis(dframe) == 1.4759027695843443 |
131
|
|
|
|
132
|
|
|
|
133
|
|
|
def test_asymmetry(): |
134
|
|
|
frames = 10 |
135
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
136
|
|
|
'X': np.linspace(0, frames, frames)+5, |
137
|
|
|
'Y': np.linspace(0, frames, frames)+3, |
138
|
|
|
'Track_ID': np.ones(frames), |
139
|
|
|
'Quality': 10.0*np.ones(frames), |
140
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
141
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
142
|
|
|
dframe = pd.DataFrame(data=data) |
143
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
144
|
|
|
|
145
|
|
|
o1, o2, o3, o4, o5 = (20.0, 0.0, 1.0, 0.0, 0.69314718) |
146
|
|
|
d1, d2, d3, d4, d5 = ft.asymmetry(dframe) |
147
|
|
|
assert math.isclose(o1, d1, abs_tol=1e-10) |
148
|
|
|
assert math.isclose(o2, d2, abs_tol=1e-10) |
149
|
|
|
assert math.isclose(o3, d3, abs_tol=1e-10) |
150
|
|
|
assert math.isclose(o4, d4, abs_tol=1e-10) |
151
|
|
|
assert math.isclose(o5, d5, abs_tol=1e-10) |
152
|
|
|
|
153
|
|
|
frames = 100 |
154
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
155
|
|
|
'X': np.sin(np.linspace(0, frames, frames)+3), |
156
|
|
|
'Y': np.cos(np.linspace(0, frames, frames)+3), |
157
|
|
|
'Track_ID': np.ones(frames), |
158
|
|
|
'Quality': 10.0*np.ones(frames), |
159
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
160
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
161
|
|
|
dframe = pd.DataFrame(data=data) |
162
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
163
|
|
|
|
164
|
|
|
o1, o2, o3, o4, o5 = (0.4254120816156, 0.42004967815488, 0.0001609000151811, |
165
|
|
|
0.9873948021401, 2.0114322402896e-05) |
166
|
|
|
d1, d2, d3, d4, d5 = ft.asymmetry(dframe) |
167
|
|
|
assert math.isclose(o1, d1) |
168
|
|
|
assert math.isclose(o2, d2) |
169
|
|
|
assert math.isclose(o3, d3) |
170
|
|
|
assert math.isclose(o4, d4) |
171
|
|
|
assert math.isclose(o5, d5) |
172
|
|
|
|
173
|
|
|
|
174
|
|
|
def test_minboundrect(): |
175
|
|
|
frames = 10 |
176
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
177
|
|
|
'X': np.linspace(0, frames, frames)+5, |
178
|
|
|
'Y': np.linspace(0, frames, frames)+3, |
179
|
|
|
'Track_ID': np.ones(frames), |
180
|
|
|
'Quality': 10.0*np.ones(frames), |
181
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
182
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
183
|
|
|
dframe = pd.DataFrame(data=data) |
184
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
185
|
|
|
|
186
|
|
|
d1, d2, d3, d4, d5, d6 = ft.minboundrect(dframe) |
187
|
|
|
o1, o2, o3, o4 = (-2.356194490192, 0, 14.142135623730, 0) |
188
|
|
|
o5 = np.array([10, 8]) |
189
|
|
|
o6 = np.array([[5., 3.], [15., 13.], [15., 13.], [5., 3.]]) |
190
|
|
|
|
191
|
|
|
# assert math.isclose(d1, o1, abs_tol=1e-10) |
192
|
|
|
assert math.isclose(d2, o2, abs_tol=1e-10) |
193
|
|
|
assert math.isclose(d3, o3, abs_tol=1e-10) |
194
|
|
|
assert math.isclose(d4, o4, abs_tol=1e-10) |
195
|
|
|
npt.assert_almost_equal(d5, o5) |
196
|
|
|
# npt.assert_almost_equal(d6, o6) |
197
|
|
|
|
198
|
|
|
frames = 100 |
199
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
200
|
|
|
'X': np.sin(np.linspace(0, frames, frames)+3), |
201
|
|
|
'Y': np.cos(np.linspace(0, frames, frames)+3), |
202
|
|
|
'Track_ID': np.ones(frames), |
203
|
|
|
'Quality': 10.0*np.ones(frames), |
204
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
205
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
206
|
|
|
dframe = pd.DataFrame(data=data) |
207
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
208
|
|
|
|
209
|
|
|
d1, d2, d3, d4, d5, d6 = ft.minboundrect(dframe) |
210
|
|
|
o1, o2, o3, o4 = (-2.7345175425633, 3.7067697307443, 1.899593160348, |
211
|
|
|
1.951349272106) |
212
|
|
|
o5 = np.array([-0.00098312, 0.00228019]) |
213
|
|
|
o6 = np.array([[-1.2594591, 0.52217706], |
214
|
|
|
[0.4849046, 1.27427376], |
215
|
|
|
[1.25749286, -0.51761668], |
216
|
|
|
[-0.48687084, -1.26971339]]) |
217
|
|
|
|
218
|
|
|
# assert math.isclose(d1, o1, abs_tol=1e-10) |
219
|
|
|
assert math.isclose(d2, o2, abs_tol=1e-10) |
220
|
|
|
assert math.isclose(d3, o3, abs_tol=1e-10) |
221
|
|
|
assert math.isclose(d4, o4, abs_tol=1e-10) |
222
|
|
|
npt.assert_almost_equal(d5, o5) |
223
|
|
|
# npt.assert_almost_equal(d6, o6) |
224
|
|
|
|
225
|
|
|
|
226
|
|
|
def test_aspectratio(): |
227
|
|
|
frames = 6 |
228
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
229
|
|
|
'X': [0, 1, 1, 2, 2, 3], |
230
|
|
|
'Y': [0, 0, 1, 1, 2, 2], |
231
|
|
|
'Track_ID': np.ones(frames), |
232
|
|
|
'Quality': 10.0*np.ones(frames), |
233
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
234
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
235
|
|
|
dframe = pd.DataFrame(data=data) |
236
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
237
|
|
|
assert ft.aspectratio(dframe)[0:2] == (3.9000000000000026, 0.7435897435897438) |
238
|
|
|
npt.assert_almost_equal(ft.aspectratio(dframe)[2], np.array([1.5, 1.])) |
239
|
|
|
|
240
|
|
|
|
241
|
|
View Code Duplication |
def test_boundedness(): |
|
|
|
|
242
|
|
|
frames = 100 |
243
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
244
|
|
|
'X': np.sin(np.linspace(0, frames, frames)+3), |
245
|
|
|
'Y': np.cos(np.linspace(0, frames, frames)+3), |
246
|
|
|
'Track_ID': np.ones(frames), |
247
|
|
|
'Quality': 10.0*np.ones(frames), |
248
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
249
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
250
|
|
|
dframe = pd.DataFrame(data=data) |
251
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
252
|
|
|
assert ft.boundedness(dframe) == (0.607673328076712, 5.674370543833708, |
253
|
|
|
-0.0535555587618044) |
254
|
|
|
|
255
|
|
|
frames = 10 |
256
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
257
|
|
|
'X': np.linspace(0, frames, frames)+5, |
258
|
|
|
'Y': np.linspace(0, frames, frames)+3, |
259
|
|
|
'Track_ID': np.ones(frames), |
260
|
|
|
'Quality': 10.0*np.ones(frames), |
261
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
262
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
263
|
|
|
dframe = pd.DataFrame(data=data) |
264
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
265
|
|
|
assert ft.boundedness(dframe) == (0.039999999999999994, 1.0, |
266
|
|
|
-0.21501108474766228) |
267
|
|
|
|
268
|
|
|
|
269
|
|
View Code Duplication |
def test_efficiency(): |
|
|
|
|
270
|
|
|
frames = 100 |
271
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
272
|
|
|
'X': np.sin(np.linspace(0, frames, frames)+3), |
273
|
|
|
'Y': np.cos(np.linspace(0, frames, frames)+3), |
274
|
|
|
'Track_ID': np.ones(frames), |
275
|
|
|
'Quality': 10.0*np.ones(frames), |
276
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
277
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
278
|
|
|
dframe = pd.DataFrame(data=data) |
279
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
280
|
|
|
|
281
|
|
|
assert ft.efficiency(dframe) ==\ |
282
|
|
|
(0.003548421265914009, 0.0059620286331768385) |
283
|
|
|
|
284
|
|
|
frames = 10 |
285
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
286
|
|
|
'X': np.linspace(0, frames, frames)+5, |
287
|
|
|
'Y': np.linspace(0, frames, frames)+3, |
288
|
|
|
'Track_ID': np.ones(frames), |
289
|
|
|
'Quality': 10.0*np.ones(frames), |
290
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
291
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
292
|
|
|
dframe = pd.DataFrame(data=data) |
293
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
294
|
|
|
|
295
|
|
|
assert ft.efficiency(dframe) == (10.0, 1.0) |
296
|
|
|
|
297
|
|
|
|
298
|
|
|
def test_msd_ratio(): |
299
|
|
|
frames = 10 |
300
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
301
|
|
|
'X': np.sin(np.linspace(0, frames, frames)+3), |
302
|
|
|
'Y': np.cos(np.linspace(0, frames, frames)+3), |
303
|
|
|
'Track_ID': np.ones(frames), |
304
|
|
|
'Quality': 10.0*np.ones(frames), |
305
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
306
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
307
|
|
|
dframe = pd.DataFrame(data=data) |
308
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
309
|
|
|
|
310
|
|
|
assert ft.msd_ratio(dframe, 1, 9) == 0.09708430006771959 |
311
|
|
|
|
312
|
|
|
frames = 10 |
313
|
|
|
data = {'Frame': np.linspace(0, frames, frames), |
314
|
|
|
'X': np.linspace(0, frames, frames)+5, |
315
|
|
|
'Y': np.linspace(0, frames, frames)+3, |
316
|
|
|
'Track_ID': np.ones(frames), |
317
|
|
|
'Quality': 10.0*np.ones(frames), |
318
|
|
|
'SN_Ratio': 0.1*np.ones(frames), |
319
|
|
|
'Mean_Intensity': 10.0*np.ones(frames)} |
320
|
|
|
dframe = pd.DataFrame(data=data) |
321
|
|
|
dframe = msd.all_msds2(dframe, frames=frames+1) |
322
|
|
|
|
323
|
|
|
assert ft.msd_ratio(dframe, 1, 9) == -0.09876543209876543 |
324
|
|
|
|
325
|
|
|
# def test_calculate_features(): |
326
|
|
|
# data = {'Frame': [0, 1, 2, 3, 4, 0, 1, 2, 3, 4], |
327
|
|
|
# 'Track_ID': [1, 1, 1, 1, 1, 2, 2, 2, 2, 2], |
328
|
|
|
# 'X': [0, 0, 1, 1, 2, 1, 1, 2, 2, 3], |
329
|
|
|
# 'Y': [0, 1, 1, 2, 2, 0, 1, 1, 2, 2]} |
330
|
|
|
# dframe = pd.DataFrame(data=data) |
331
|
|
|
# dfi = msd.all_msds2(dframe, frames = 5) |
332
|
|
|
# feat = ft.calculate_features(dfi) |
333
|
|
|
|
334
|
|
|
# data = {'AR': np.ones(2)*3.9999999999999996, |
335
|
|
|
# 'D_fit': np.ones(2)*0.1705189932550273, |
336
|
|
|
# 'MSD_ratio': np.ones(2)*-0.2666666666666666, |
337
|
|
|
# 'X': [0.75, 1.75], |
338
|
|
|
# 'Y': [1.25, 1.25], |
339
|
|
|
# 'Track_ID': [1.0, 2.0], |
340
|
|
|
# 'alpha': np.ones(2)*1.7793370720777268, |
341
|
|
|
# 'asymmetry1': np.ones(2)*0.9440237239896903, |
342
|
|
|
# 'asymmetry2': np.ones(2)*0.12, |
343
|
|
|
# 'asymmetry3': np.ones(2)*0.3691430189107616, |
344
|
|
|
# 'boundedness': np.ones(2)*0.25, |
345
|
|
|
# 'efficiency': np.ones(2)*2.0, |
346
|
|
|
# 'elongation': np.ones(2)*0.75, |
347
|
|
|
# 'fractal_dim': np.ones(2)*1.333333333333333, |
348
|
|
|
# 'frames': [5.0, 5.0], |
349
|
|
|
# 'kurtosis': np.ones(2)*1.166666666666667, |
350
|
|
|
# 'straightness': np.ones(2)*0.7071067811865476, |
351
|
|
|
# 'trappedness': np.ones(2)*-0.15258529289428524} |
352
|
|
|
# dfi = pd.DataFrame(data=data) |
353
|
|
|
|
354
|
|
|
# pdt.assert_frame_equal(dfi, feat) |
355
|
|
|
|
356
|
|
|
|
357
|
|
|
# def test_unmask_track(): |
358
|
|
|
# size = 10 |
359
|
|
|
# ID = np.ones(size) |
360
|
|
|
# frame = np.linspace(5, size-1+5, size) |
361
|
|
|
# x = frame + 1 |
362
|
|
|
# y = frame + 3 |
363
|
|
|
# |
364
|
|
|
# data = {'Frame': frame, |
365
|
|
|
# 'Track_ID': ID, |
366
|
|
|
# 'X': x, |
367
|
|
|
# 'Y': y} |
368
|
|
|
# di = pd.DataFrame(data=data) |
369
|
|
|
# track = msd.all_msds2(di, frames=20) |
370
|
|
|
# output = ft.unmask_track(track) |
371
|
|
|
# |
372
|
|
|
# data2 = {'Frame': frame-5, |
373
|
|
|
# 'Track_ID': ID, |
374
|
|
|
# 'X': x, |
375
|
|
|
# 'Y': y, |
376
|
|
|
# 'MSDs': np.array((0, 2, 8, 18, 32, 50, 72, 98, 128, |
377
|
|
|
# 162)).astype('float64'), |
378
|
|
|
# 'Gauss': np.array((0, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, |
379
|
|
|
# 0.25, 0.25))} |
380
|
|
|
# check = pd.DataFrame(data=data2) |
381
|
|
|
# |
382
|
|
|
# pdt.assert_frame_equal(output, check) |
383
|
|
|
|