Python link Examples

Example #1

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

Example #2

File: test_more.py Project: Resonanz/trackpy

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

Example #3

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())

Example #4

File: test_more.py Project: Resonanz/trackpy

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())

Example #5

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)

Example #6

File: test_more.py Project: Resonanz/trackpy

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)

Example #7

File: basic_test.py Project: elizan/trackpy

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

Example #8

File: basic_test.py Project: akoser/trackpy

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

Example #9

File: python_iden_script.py Project: pfigliozzi/Python_Data_Analysis

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()

Example #10

File: basic_test.py Project: Resonanz/trackpy

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

Example #11

File: basic_test.py Project: elizan/trackpy

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

Example #12

File: simple.py Project: Resonanz/trackpy

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()

Example #13

File: simple.py Project: elizan/trackpy

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()