test_features   A
last analyzed

Complexity

Total Complexity 10

Size/Duplication

Total Lines 324
Duplicated Lines 31.17 %

Importance

Changes 0
Metric Value
eloc 277
dl 101
loc 324
rs 10
c 0
b 0
f 0
wmc 10

10 Functions

Rating   Name   Duplication   Size   Complexity  
A test_unmask_track() 0 27 1
A test_kurtosis() 24 24 1
A test_asymmetry() 0 39 1
A test_alpha_calc() 24 24 1
B test_minboundrect() 0 49 1
A test_boundedness() 26 26 1
A test_msd_ratio() 0 26 1
A test_aspectratio() 0 13 1
A test_gyration_tensor() 0 39 1
A test_efficiency() 27 27 1

How to fix   Duplicated Code   

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

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():
0 ignored issues
show
Duplication introduced by
This code seems to be duplicated in your project.
Loading history...
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():
0 ignored issues
show
Duplication introduced by
This code seems to be duplicated in your project.
Loading history...
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():
0 ignored issues
show
Duplication introduced by
This code seems to be duplicated in your project.
Loading history...
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():
0 ignored issues
show
Duplication introduced by
This code seems to be duplicated in your project.
Loading history...
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