def test_search_range(): t = link(unit_steps(), 1.1, hash_generator((10, 10), 1)) assert len(t) == 1 # One track t_short = link(unit_steps(), 0.9, hash_generator((10, 10), 1)) assert len(t_short) == len(unit_steps()) # Each step is a separate track. t = link(random_walk(), max_disp + 0.1, hash_generator((10, 10), 1)) assert len(t) == 1 # One track t_short = link(random_walk(), max_disp - 0.1, hash_generator((10, 10), 1)) assert len(t_short) > 1 # Multiple tracks
def test_box_size(): """No matter what the box size, there should be one track, and it should contain all the points.""" for box_size in [0.1, 1, 10]: t1 = link(unit_steps(), 1.1, hash_generator((10, 10), box_size)) t2 = link(random_walk(), max_disp + 1, hash_generator((10, 10), box_size)) assert len(t1) == 1 assert len(t2) == 1 assert len(t1[0].points) == len(unit_steps()) assert len(t2[0].points) == len(random_walk())
def test_memory(): """A unit-stepping trajectory and a random walk are observed simultaneously. The random walk is missing from one observation.""" a = [p[0] for p in unit_steps()] b = [p[0] for p in random_walk()] # b[2] is intentionally omitted below. gapped = lambda: deepcopy([[a[0], b[0]], [a[1], b[1]], [a[2]], [a[3], b[3]], [a[4], b[4]]]) safe_disp = 1 + random_x.max() - random_x.min() # Definitely large enough t0 = link(gapped(), safe_disp, hash_generator((10, 10), 1), memory=0) assert len(t0) == 3, len(t0) t5 = link(gapped(), safe_disp, hash_generator((10, 10), 1), memory=5) assert len(t5) == 2, len(t5)
def test_pathological_tracking(): level_count = 5 p_count = 16 levels = [] shift = 1 for j in range(level_count): level = [] for k in np.arange(p_count) * 2: level.append(pt.PointND(k // 2, (j, k + j * shift))) levels.append(level) hash_generator = lambda: pt.Hash_table( (level_count + 1, p_count * 2 + level_count * shift + 1), .5) tracks = pt.link(levels, 8, hash_generator) assert len(tracks) == p_count, len(tracks) for t in tracks: x, y = zip(*[p.pos for p in t]) dx = np.diff(x) dy = np.diff(y) assert np.sum(dx) == level_count - 1 assert np.sum(dy) == (level_count - 1) * shift
def test_pathological_tracking(): level_count = 5 p_count = 16 levels = [] shift = 1 for j in range(level_count): level = [] for k in np.arange(p_count) * 2: level.append(pt.PointND(k // 2, (j, k + j * shift))) levels.append(level) hash_generator = lambda: pt.Hash_table((level_count + 1, p_count * 2 + level_count * shift + 1), .5) tracks = pt.link(levels, 8, hash_generator) assert len(tracks) == p_count, len(tracks) for t in tracks: x, y = zip(*[p.pos for p in t]) dx = np.diff(x) dy = np.diff(y) assert np.sum(dx) == level_count - 1 assert np.sum(dy) == (level_count - 1) * shift
def track_data(points_list): data=[] for frame in range(len(points_list)): frame_data=[] data.append(frame_data) for pts in range(len(points_list[frame][0,:])): data[frame].append(pt.PointND(float(frame+1), np.asarray((points_list[frame][0,pts],points_list[frame][1,pts])))) hash_generator = lambda: pt.Hash_table((20, 20), .5) t=pt.link(data,2) return t '''fig = plt.figure()
def test_easy_tracking(): level_count = 5 p_count = 16 levels = [] for j in range(level_count): level = [] for k in np.arange(p_count) * 2: level.append(pt.PointND(j, (j, k))) levels.append(level) hash_generator = lambda: pt.Hash_table((level_count + 1, p_count * 2 + 1), .5) tracks = pt.link(levels, 1.5, hash_generator) assert len(tracks) == p_count for t in tracks: x, y = zip(*[p.pos for p in t]) dx = np.diff(x) dy = np.diff(y) assert np.sum(dx) == level_count - 1 assert np.sum(dy) == 0
def test_easy_tracking(): level_count = 5 p_count = 16 levels = [] for j in range(level_count): level = [] for k in np.arange(p_count) * 2: level.append(pt.PointND(j, (j, k))) levels.append(level) hash_generator = lambda: pt.Hash_table( (level_count + 1, p_count * 2 + 1), .5) tracks = pt.link(levels, 1.5, hash_generator) assert len(tracks) == p_count for t in tracks: x, y = zip(*[p.pos for p in t]) dx = np.diff(x) dy = np.diff(y) assert np.sum(dx) == level_count - 1 assert np.sum(dy) == 0
import trackpy.tracking as pt import matplotlib.pyplot as plt import numpy as np # generate fake data levels = [] # 15 planes for i in range(15): level = [] # add the current level to the list of levels levels.append(level) # a 15 by 15 grid for j in range(15): for k in range(15): # displace the location from the grid by a guassian with width 1/10 level.append(pt.PointND(i, np.asarray((j + 2, k + 2)) + np.random.randn(2) / 10)) # do the tracking hash_generator = lambda: pt.Hash_table((20, 20), .5) t = pt.link(levels, .75, hash_generator) # plot tracks fig = plt.figure() ax = fig.gca() for trk in t: x, y = zip(*[p.pos for p in trk.points]) ax.plot(x, y) plt.show()
import numpy as np # generate fake data levels = [] # 15 planes for i in range(15): level = [] # add the current level to the list of levels levels.append(level) # a 15 by 15 grid for j in range(15): for k in range(15): # displace the location from the grid by a guassian with width 1/10 level.append( pt.PointND( i, np.asarray((j + 2, k + 2)) + np.random.randn(2) / 10)) # do the tracking hash_generator = lambda: pt.Hash_table((20, 20), .5) t = pt.link(levels, .75, hash_generator) # plot tracks fig = plt.figure() ax = fig.gca() for trk in t: x, y = zip(*[p.pos for p in trk.points]) ax.plot(x, y) plt.show()