`tracking`¶

label='fast'

import dipy.tracking as dipytracking
dipytracking.bench()

[[1., 0., 0.],
 [0., 2., 0.],
 [0., 0., 1.]]

A------------
|   |   |   |
| C |   |   |
|   |   |   |
----B--------
|   |   |   |
|   |   |   |
|   |   |   |
-------------
|   |   |   |
|   |   |   |
|   |   |   |
------------D

A = [-.5, -1.]
B = [ .5,  1.]
C = [ 0.,  0.]
D = [ 2.5,  5.]

>>> success = np.lib.bench() #doctest: +SKIP
Running benchmarks for numpy.lib
...
using 562341 items:
unique:
0.11
unique1d:
0.11
ratio: 1.0
nUnique: 56230 == 56230
...
OK

>>> success #doctest: +SKIP
True

>>> np.lib.test() #doctest: +SKIP

>>> result = np.lib.test() #doctest: +SKIP
Running unit tests for numpy.lib
...
Ran 976 tests in 3.933s

>>> result.errors #doctest: +SKIP
[]
>>> result.knownfail #doctest: +SKIP
[]

>>> np.testing.assert_array_almost_equal([1.0,2.333,np.nan],
...                                      [1.0,2.333,np.nan])

>>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
...                                      [1.0,2.33339,np.nan], decimal=5)
Traceback (most recent call last):
    ...
AssertionError:
Arrays are not almost equal to 5 decimals
Mismatch: 33.3%
Max absolute difference: 6.e-05
Max relative difference: 2.57136612e-05
 x: array([1.     , 2.33333,     nan])
 y: array([1.     , 2.33339,     nan])

>>> np.testing.assert_array_almost_equal([1.0,2.33333,np.nan],
...                                      [1.0,2.33333, 5], decimal=5)
Traceback (most recent call last):
    ...
AssertionError:
Arrays are not almost equal to 5 decimals
x and y nan location mismatch:
 x: array([1.     , 2.33333,     nan])
 y: array([1.     , 2.33333, 5.     ])

>>> np.testing.assert_array_equal([1.0,2.33333,np.nan],
...                               [np.exp(0),2.33333, np.nan])

>>> np.testing.assert_array_equal([1.0,np.pi,np.nan],
...                               [1, np.sqrt(np.pi)**2, np.nan])
Traceback (most recent call last):
    ...
AssertionError:
Arrays are not equal
Mismatch: 33.3%
Max absolute difference: 4.4408921e-16
Max relative difference: 1.41357986e-16
 x: array([1.      , 3.141593,      nan])
 y: array([1.      , 3.141593,      nan])

>>> np.testing.assert_allclose([1.0,np.pi,np.nan],
...                            [1, np.sqrt(np.pi)**2, np.nan],
...                            rtol=1e-10, atol=0)

>>> from dipy.tracking.streamline import compress_streamlines
>>> import numpy as np
>>> # One streamline: a wiggling line
>>> rng = np.random.RandomState(42)
>>> streamline = np.linspace(0, 10, 100*3).reshape((100, 3))
>>> streamline += 0.2 * rng.rand(100, 3)
>>> c_streamline = compress_streamlines(streamline, tol_error=0.2)
>>> len(streamline)
100
>>> len(c_streamline)
10
>>> # Multiple streamlines
>>> streamlines = [streamline, streamline[::2]]
>>> c_streamlines = compress_streamlines(streamlines, tol_error=0.2)
>>> [len(s) for s in streamlines]
[100, 50]
>>> [len(s) for s in c_streamlines]
[10, 7]

>>> import numpy as np
>>> from dipy.data import get_fnames
>>> fimg,fbvals,fbvecs=get_fnames('small_101D')
>>> bvals=np.loadtxt(fbvals)
>>> bvecs=np.loadtxt(fbvecs).T
>>> import nibabel as nib
>>> img=nib.load(fimg)
>>> data=img.get_data()
>>> data.shape == (6, 10, 10, 102)
True
>>> bvals.shape == (102,)
True
>>> bvecs.shape == (102, 3)
True

>>> from dipy.tracking.streamline import length
>>> import numpy as np
>>> streamline = np.array([[1, 1, 1], [2, 3, 4], [0, 0, 0]])
>>> expected_length = np.sqrt([1+2**2+3**2, 2**2+3**2+4**2]).sum()
>>> length(streamline) == expected_length
True
>>> streamlines = [streamline, np.vstack([streamline, streamline[::-1]])]
>>> expected_lengths = [expected_length, 2*expected_length]
>>> lengths = [length(streamlines[0]), length(streamlines[1])]
>>> np.allclose(lengths, expected_lengths)
True
>>> length([])
0.0
>>> length(np.array([[1, 2, 3]]))
0.0

>>> times = 10
>>> etime = np.testing.measure('for i in range(1000): np.sqrt(i**2)', times=times)
>>> print("Time for a single execution : ", etime / times, "s")  # doctest: +SKIP
Time for a single execution :  0.005 s

>>> from dipy.tracking.streamline import set_number_of_points
>>> import numpy as np

>>> theta = np.pi*np.linspace(0, 1, 100)
>>> x = np.cos(theta)
>>> y = np.sin(theta)
>>> z = 0 * x
>>> streamline = np.vstack((x, y, z)).T
>>> modified_streamline = set_number_of_points(streamline, 3)
>>> len(modified_streamline)
3

>>> streamlines = [streamline, streamline[::2]]
>>> new_streamlines = set_number_of_points(streamlines, 10)
>>> [len(s) for s in streamlines]
[100, 50]
>>> [len(s) for s in new_streamlines]
[10, 10]

>>> import numpy as np
>>> import dipy.tracking.learning as tl
>>> A = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]])
>>> B = np.array([[1, 0, 0], [2, 0, 0], [3, 0, 0]])
>>> C = np.array([[0, 0, -1], [0, 0, -2], [0, 0, -3]])
>>> bundle1 = [A, B, C]
>>> bundle2 = [B, A]
>>> indices = [0, 1]
>>> arr = tl.detect_corresponding_tracks(indices, bundle1, bundle2)

>>> import numpy as np
>>> import dipy.tracking.learning as tl
>>> A = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]])
>>> B = np.array([[1, 0, 0], [2, 0, 0], [3, 0, 0]])
>>> C = np.array([[0, 0, -1], [0, 0, -2], [0, 0, -3]])
>>> bundle1 = [A, B, C]
>>> bundle2 = [B, A]
>>> indices = [0, 1]
>>> indices2 = indices
>>> arr = tl.detect_corresponding_tracks_plus(indices, bundle1, indices2, bundle2)

>>> x = np.array([1, 2, 4, 7, 11, 16], dtype=np.float)
>>> gradient(x)
array([ 1. ,  1.5,  2.5,  3.5,  4.5,  5. ])

>>> gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=np.float))
[array([[ 2.,  2., -1.],
       [ 2.,  2., -1.]]), array([[ 1. ,  2.5,  4. ],
       [ 1. ,  1. ,  1. ]])]

>>> import numpy as np
>>> from dipy.tracking.metrics import arbitrarypoint, length
>>> theta=np.pi*np.linspace(0,1,100)
>>> x=np.cos(theta)
>>> y=np.sin(theta)
>>> z=0*x
>>> xyz=np.vstack((x,y,z)).T
>>> ap=arbitrarypoint(xyz,length(xyz)/3)

>>> from dipy.tracking.metrics import center_of_mass
>>> center_of_mass([])
Traceback (most recent call last):
   ...
ValueError: xyz array cannot be empty
>>> center_of_mass([[1,1,1]])
array([ 1.,  1.,  1.])
>>> xyz = np.array([[0,0,0],[1,1,1],[2,2,2]])
>>> center_of_mass(xyz)
array([ 1.,  1.,  1.])

>>> import numpy as np
>>> # a semi-circle
>>> theta=np.pi*np.linspace(0,1,100)
>>> x=np.cos(theta)
>>> y=np.sin(theta)
>>> z=0*x
>>> xyz=np.vstack((x,y,z)).T
>>> xyz2=downsample(xyz,3)
>>> # a cosine
>>> x=np.pi*np.linspace(0,1,100)
>>> y=np.cos(theta)
>>> z=0*y
>>> xyz=np.vstack((x,y,z)).T
>>> _= downsample(xyz,3)
>>> len(xyz2)
3
>>> xyz3=downsample(xyz,10)
>>> len(xyz3)
10

>>> from dipy.tracking.metrics import endpoint
>>> import numpy as np
>>> theta=np.pi*np.linspace(0,1,100)
>>> x=np.cos(theta)
>>> y=np.sin(theta)
>>> z=0*x
>>> xyz=np.vstack((x,y,z)).T
>>> ep=endpoint(xyz)
>>> ep.any()==xyz[-1].any()
True

>>> from dipy.tracking import metrics as tm
>>> import numpy as np
>>> theta = 2*np.pi*np.linspace(0,2,100)
>>> x=np.cos(theta)
>>> y=np.sin(theta)
>>> z=theta/(2*np.pi)
>>> xyz=np.vstack((x,y,z)).T
>>> T,N,B,k,t=tm.frenet_serret(xyz)

>>> from dipy.tracking.metrics import generate_combinations
>>> ic=generate_combinations(range(3),2)
>>> for i in ic: print(i)
[0, 1]
[0, 2]
[1, 2]

>>> from dipy.tracking.metrics import inside_sphere
>>> line=np.array(([0,0,0],[1,1,1],[2,2,2]))
>>> sph_cent=np.array([1,1,1])
>>> sph_radius = 1
>>> inside_sphere(line,sph_cent,sph_radius)
True

>>> from dipy.tracking.metrics import inside_sphere_points
>>> line=np.array(([0,0,0],[1,1,1],[2,2,2]))
>>> sph_cent=np.array([1,1,1])
>>> sph_radius = 1
>>> inside_sphere_points(line,sph_cent,sph_radius)
array([[1, 1, 1]])

>>> from dipy.tracking.metrics import length
>>> xyz = np.array([[1,1,1],[2,3,4],[0,0,0]])
>>> expected_lens = np.sqrt([1+2**2+3**2, 2**2+3**2+4**2])
>>> length(xyz) == expected_lens.sum()
True
>>> len_along = length(xyz, along=True)
>>> np.allclose(len_along, expected_lens.cumsum())
True
>>> length([])
0
>>> length([[1, 2, 3]])
0
>>> length([], along=True)
array([0])

>>> from dipy.tracking.metrics import longest_track_bundle
>>> import numpy as np
>>> bundle = [np.array([[0,0,0],[2,2,2]]),np.array([[0,0,0],[4,4,4]])]
>>> longest_track_bundle(bundle)
array([[0, 0, 0],
       [4, 4, 4]])
>>> longest_track_bundle(bundle, True) #doctest: +ELLIPSIS
array([0, 1]...)

>>> from dipy.tracking import metrics as tm
>>> import numpy as np
>>> x=np.linspace(0,1,100)
>>> y=0*x
>>> z=0*x
>>> xyz=np.vstack((x,y,z)).T
>>> m=tm.mean_curvature(xyz) #mean curvature straight line
>>> theta=np.pi*np.linspace(0,1,100)
>>> x=np.cos(theta)
>>> y=np.sin(theta)
>>> z=0*x
>>> xyz=np.vstack((x,y,z)).T
>>> _= tm.mean_curvature(xyz) #mean curvature for semi-circle

>>> from dipy.tracking.metrics import midpoint
>>> midpoint([])
Traceback (most recent call last):
   ...
ValueError: xyz array cannot be empty
>>> midpoint([[1, 2, 3]])
array([1, 2, 3])
>>> xyz = np.array([[1,1,1],[2,3,4]])
>>> midpoint(xyz)
array([ 1.5,  2. ,  2.5])
>>> xyz = np.array([[0,0,0],[1,1,1],[2,2,2]])
>>> midpoint(xyz)
array([ 1.,  1.,  1.])
>>> xyz = np.array([[0,0,0],[1,0,0],[3,0,0]])
>>> midpoint(xyz)
array([ 1.5,  0. ,  0. ])
>>> xyz = np.array([[0,9,7],[1,9,7],[3,9,7]])
>>> midpoint(xyz)
array([ 1.5,  9. ,  7. ])

>>> import numpy as np
>>> from dipy.tracking.metrics import midpoint2point, midpoint
>>> theta=np.pi*np.linspace(0,1,100)
>>> x=np.cos(theta)
>>> y=np.sin(theta)
>>> z=0*x
>>> xyz=np.vstack((x,y,z)).T
>>> dist=midpoint2point(xyz,np.array([0,0,0]))

>>> import numpy as np
>>> from dipy.tracking.metrics import principal_components
>>> theta=np.pi*np.linspace(0,1,100)
>>> x=np.cos(theta)
>>> y=np.sin(theta)
>>> z=0*x
>>> xyz=np.vstack((x,y,z)).T
>>> va, ve = principal_components(xyz)
>>> np.allclose(va, [0.51010101, 0.09883545, 0])
True

>>> import numpy as np
>>> t=np.linspace(0,1.75*2*np.pi,100)# make ascending spiral in 3-space
>>> x = np.sin(t)
>>> y = np.cos(t)
>>> z = t
>>> x+= np.random.normal(scale=0.1, size=x.shape) # add noise
>>> y+= np.random.normal(scale=0.1, size=y.shape)
>>> z+= np.random.normal(scale=0.1, size=z.shape)
>>> xyz=np.vstack((x,y,z)).T
>>> xyzn=spline(xyz,3,2,-1)
>>> len(xyzn) > len(xyz)
True

>>> phi = np.linspace(0, 2.*np.pi, 40)
>>> r = 0.5 + np.cos(phi)         # polar coords
>>> x, y = r * np.cos(phi), r * np.sin(phi)    # convert to cartesian

>>> from scipy.interpolate import splprep, splev
>>> tck, u = splprep([x, y], s=0)
>>> new_points = splev(u, tck)

>>> import matplotlib.pyplot as plt
>>> fig, ax = plt.subplots()
>>> ax.plot(x, y, 'ro')
>>> ax.plot(new_points[0], new_points[1], 'r-')
>>> plt.show()

>>> from dipy.tracking.metrics import startpoint
>>> import numpy as np
>>> theta=np.pi*np.linspace(0,1,100)
>>> x=np.cos(theta)
>>> y=np.sin(theta)
>>> z=0*x
>>> xyz=np.vstack((x,y,z)).T
>>> sp=startpoint(xyz)
>>> sp.any()==xyz[0].any()
True

res = np.dot(aff[:3,:3], pts.T) + aff[:3,3:4]
transformed_pts = res.T

>>> aff = np.array([[0,2,0,10],[3,0,0,11],[0,0,4,12],[0,0,0,1]])
>>> pts = np.array([[1,2,3],[2,3,4],[4,5,6],[6,7,8]])
>>> apply_affine(aff, pts) #doctest: +ELLIPSIS
array([[14, 14, 24],
       [16, 17, 28],
       [20, 23, 36],
       [24, 29, 44]]...)

>>> (np.dot(aff[:3,:3], pts.T) + aff[:3,3:4]).T #doctest: +ELLIPSIS
array([[14, 14, 24],
       [16, 17, 28],
       [20, 23, 36],
       [24, 29, 44]]...)

>>> pts = pts.reshape((2,2,3))
>>> apply_affine(aff, pts) #doctest: +ELLIPSIS
array([[[14, 14, 24],
        [16, 17, 28]],
<BLANKLINE>
       [[20, 23, 36],
        [24, 29, 44]]]...)

dm = cdist(XA, XB, lambda u, v: np.sqrt(((u-v)**2).sum()))

dm = cdist(XA, XB, sokalsneath)

dm = cdist(XA, XB, 'sokalsneath')

>>> from scipy.spatial import distance
>>> coords = [(35.0456, -85.2672),
...           (35.1174, -89.9711),
...           (35.9728, -83.9422),
...           (36.1667, -86.7833)]
>>> distance.cdist(coords, coords, 'euclidean')
array([[ 0.    ,  4.7044,  1.6172,  1.8856],
       [ 4.7044,  0.    ,  6.0893,  3.3561],
       [ 1.6172,  6.0893,  0.    ,  2.8477],
       [ 1.8856,  3.3561,  2.8477,  0.    ]])

>>> a = np.array([[0, 0, 0],
...               [0, 0, 1],
...               [0, 1, 0],
...               [0, 1, 1],
...               [1, 0, 0],
...               [1, 0, 1],
...               [1, 1, 0],
...               [1, 1, 1]])
>>> b = np.array([[ 0.1,  0.2,  0.4]])
>>> distance.cdist(a, b, 'cityblock')
array([[ 0.7],
       [ 0.9],
       [ 1.3],
       [ 1.5],
       [ 1.5],
       [ 1.7],
       [ 2.1],
       [ 2.3]])

>>> from dipy.tracking.streamline import compress_streamlines
>>> import numpy as np
>>> # One streamline: a wiggling line
>>> rng = np.random.RandomState(42)
>>> streamline = np.linspace(0, 10, 100*3).reshape((100, 3))
>>> streamline += 0.2 * rng.rand(100, 3)
>>> c_streamline = compress_streamlines(streamline, tol_error=0.2)
>>> len(streamline)
100
>>> len(c_streamline)
10
>>> # Multiple streamlines
>>> streamlines = [streamline, streamline[::2]]
>>> c_streamlines = compress_streamlines(streamlines, tol_error=0.2)
>>> [len(s) for s in streamlines]
[100, 50]
>>> [len(s) for s in c_streamlines]
[10, 7]

>>> from dipy.tracking.streamline import length
>>> import numpy as np
>>> streamline = np.array([[1, 1, 1], [2, 3, 4], [0, 0, 0]])
>>> expected_length = np.sqrt([1+2**2+3**2, 2**2+3**2+4**2]).sum()
>>> length(streamline) == expected_length
True
>>> streamlines = [streamline, np.vstack([streamline, streamline[::-1]])]
>>> expected_lengths = [expected_length, 2*expected_length]
>>> lengths = [length(streamlines[0]), length(streamlines[1])]
>>> np.allclose(lengths, expected_lengths)
True
>>> length([])
0.0
>>> length(np.array([[1, 2, 3]]))
0.0

>>> streamlines = [np.array([[0, 0., 0],
...                          [1, 0., 0.],
...                          [2, 0., 0.]]),
...                np.array([[2, 0., 0.],
...                          [1, 0., 0],
...                          [0, 0,  0.]])]
>>> roi1 = np.zeros((4, 4, 4), dtype=bool)
>>> roi2 = np.zeros_like(roi1)
>>> roi1[0, 0, 0] = True
>>> roi2[1, 0, 0] = True
>>> orient_by_rois(streamlines, np.eye(4), roi1, roi2)
[array([[ 0.,  0.,  0.],
       [ 1.,  0.,  0.],
       [ 2.,  0.,  0.]]), array([[ 0.,  0.,  0.],
       [ 1.,  0.,  0.],
       [ 2.,  0.,  0.]])]

>>> streamlines = [np.array([[0, 0., 0.9],
...                          [1.9, 0., 0.]]),
...                np.array([[0., 0., 0],
...                          [0, 1., 1.],
...                          [0, 2., 2.]]),
...                np.array([[2, 2, 2],
...                          [3, 3, 3]])]
>>> mask1 = np.zeros((4, 4, 4), dtype=bool)
>>> mask2 = np.zeros_like(mask1)
>>> mask1[0, 0, 0] = True
>>> mask2[1, 0, 0] = True
>>> selection = select_by_rois(streamlines, np.eye(4), [mask1, mask2],
...                            [True, True],
...                            tol=1)
>>> list(selection) # The result is a generator
[array([[ 0. ,  0. ,  0.9],
       [ 1.9,  0. ,  0. ]]), array([[ 0.,  0.,  0.],
       [ 0.,  1.,  1.],
       [ 0.,  2.,  2.]])]
>>> selection = select_by_rois(streamlines, np.eye(4), [mask1, mask2],
...                            [True, False],
...                            tol=0.87)
>>> list(selection)
[array([[ 0.,  0.,  0.],
       [ 0.,  1.,  1.],
       [ 0.,  2.,  2.]])]
>>> selection = select_by_rois(streamlines, np.eye(4), [mask1, mask2],
...                            [True, True],
...                            mode="both_end",
...                            tol=1.0)
>>> list(selection)
[array([[ 0. ,  0. ,  0.9],
       [ 1.9,  0. ,  0. ]])]
>>> mask2[0, 2, 2] = True
>>> selection = select_by_rois(streamlines, np.eye(4), [mask1, mask2],
...                            [True, True],
...                            mode="both_end",
...                            tol=1.0)
>>> list(selection)
[array([[ 0. ,  0. ,  0.9],
       [ 1.9,  0. ,  0. ]]), array([[ 0.,  0.,  0.],
       [ 0.,  1.,  1.],
       [ 0.,  2.,  2.]])]

>>> from dipy.tracking.streamline import set_number_of_points
>>> import numpy as np

>>> theta = np.pi*np.linspace(0, 1, 100)
>>> x = np.cos(theta)
>>> y = np.sin(theta)
>>> z = 0 * x
>>> streamline = np.vstack((x, y, z)).T
>>> modified_streamline = set_number_of_points(streamline, 3)
>>> len(modified_streamline)
3

>>> streamlines = [streamline, streamline[::2]]
>>> new_streamlines = set_number_of_points(streamlines, 10)
>>> [len(s) for s in streamlines]
[100, 50]
>>> [len(s) for s in new_streamlines]
[10, 10]

res = np.dot(aff[:3,:3], pts.T) + aff[:3,3:4]
transformed_pts = res.T

>>> aff = np.array([[0,2,0,10],[3,0,0,11],[0,0,4,12],[0,0,0,1]])
>>> pts = np.array([[1,2,3],[2,3,4],[4,5,6],[6,7,8]])
>>> apply_affine(aff, pts) #doctest: +ELLIPSIS
array([[14, 14, 24],
       [16, 17, 28],
       [20, 23, 36],
       [24, 29, 44]]...)

>>> (np.dot(aff[:3,:3], pts.T) + aff[:3,3:4]).T #doctest: +ELLIPSIS
array([[14, 14, 24],
       [16, 17, 28],
       [20, 23, 36],
       [24, 29, 44]]...)

>>> pts = pts.reshape((2,2,3))
>>> apply_affine(aff, pts) #doctest: +ELLIPSIS
array([[[14, 14, 24],
        [16, 17, 28]],
<BLANKLINE>
       [[20, 23, 36],
        [24, 29, 44]]]...)

>>> a = [1, 2]
>>> np.asarray(a)
array([1, 2])

>>> a = np.array([1, 2])
>>> np.asarray(a) is a
True

>>> a = np.array([1, 2], dtype=np.float32)
>>> np.asarray(a, dtype=np.float32) is a
True
>>> np.asarray(a, dtype=np.float64) is a
False

>>> issubclass(np.recarray, np.ndarray)
True
>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
>>> np.asarray(a) is a
False
>>> np.asanyarray(a) is a
True

dm = cdist(XA, XB, lambda u, v: np.sqrt(((u-v)**2).sum()))

dm = cdist(XA, XB, sokalsneath)

dm = cdist(XA, XB, 'sokalsneath')

>>> from scipy.spatial import distance
>>> coords = [(35.0456, -85.2672),
...           (35.1174, -89.9711),
...           (35.9728, -83.9422),
...           (36.1667, -86.7833)]
>>> distance.cdist(coords, coords, 'euclidean')
array([[ 0.    ,  4.7044,  1.6172,  1.8856],
       [ 4.7044,  0.    ,  6.0893,  3.3561],
       [ 1.6172,  6.0893,  0.    ,  2.8477],
       [ 1.8856,  3.3561,  2.8477,  0.    ]])

>>> a = np.array([[0, 0, 0],
...               [0, 0, 1],
...               [0, 1, 0],
...               [0, 1, 1],
...               [1, 0, 0],
...               [1, 0, 1],
...               [1, 1, 0],
...               [1, 1, 1]])
>>> b = np.array([[ 0.1,  0.2,  0.4]])
>>> distance.cdist(a, b, 'cityblock')
array([[ 0.7],
       [ 0.9],
       [ 1.3],
       [ 1.5],
       [ 1.5],
       [ 1.7],
       [ 2.1],
       [ 2.3]])

>>> np.empty([2, 2])
array([[ -9.74499359e+001,   6.69583040e-309],
       [  2.13182611e-314,   3.06959433e-309]])         #random

>>> np.empty([2, 2], dtype=int)
array([[-1073741821, -1067949133],
       [  496041986,    19249760]])                     #random

>>> a = np.array([1, 2, 3, 4])
>>> np.negative.at(a, [0, 1])
>>> print(a)
array([-1, -2, 3, 4])

>>> a = np.array([1, 2, 3, 4])
>>> np.add.at(a, [0, 1, 2, 2], 1)
>>> print(a)
array([2, 3, 5, 4])

>>> a = np.array([1, 2, 3, 4])
>>> b = np.array([1, 2])
>>> np.add.at(a, [0, 1], b)
>>> print(a)
array([2, 4, 3, 4])

>>> mask = np.zeros((3,3,3), 'bool')
>>> mask[0,0,0] = 1
>>> random_seeds_from_mask(mask, np.eye(4), seeds_count=1,
... seed_count_per_voxel=True, random_seed=1)
array([[-0.0640051 , -0.47407377,  0.04966248]])
>>> random_seeds_from_mask(mask, np.eye(4), seeds_count=6,
... seed_count_per_voxel=True, random_seed=1)
array([[-0.0640051 , -0.47407377,  0.04966248],
       [ 0.0507979 ,  0.20814782, -0.20909526],
       [ 0.46702984,  0.04723225,  0.47268436],
       [-0.27800683,  0.37073231, -0.29328084],
       [ 0.39286015, -0.16802019,  0.32122912],
       [-0.42369171,  0.27991879, -0.06159077]])
>>> mask[0,1,2] = 1
>>> random_seeds_from_mask(mask, np.eye(4),
... seeds_count=2, seed_count_per_voxel=True, random_seed=1)
array([[-0.0640051 , -0.47407377,  0.04966248],
       [-0.27800683,  1.37073231,  1.70671916],
       [ 0.0507979 ,  0.20814782, -0.20909526],
       [-0.48962585,  1.00187459,  1.99577329]])

>>> arr = np.array([[3,6,6],[4,5,1]])
>>> np.ravel_multi_index(arr, (7,6))
array([22, 41, 37])
>>> np.ravel_multi_index(arr, (7,6), order='F')
array([31, 41, 13])
>>> np.ravel_multi_index(arr, (4,6), mode='clip')
array([22, 23, 19])
>>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))
array([12, 13, 13])

>>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))
1621

>>> labels = np.array([[1, 3, 9],
...                    [1, 3, 8],
...                    [1, 3, 7]])
>>> new_labels, lookup = reduce_labels(labels)
>>> lookup
array([1, 3, 7, 8, 9])
>>> new_labels #doctest: +ELLIPSIS
array([[0, 1, 4],
       [0, 1, 3],
       [0, 1, 2]]...)
>>> (lookup[new_labels] == labels).all()
True

>>> mask = np.zeros((3,3,3), 'bool')
>>> mask[0,0,0] = 1
>>> seeds_from_mask(mask, np.eye(4), [1,1,1])
array([[ 0.,  0.,  0.]])

>>> streamlines = [np.array([[0,0,0],[2,0,0],[5,0,0]])]
>>> list(subsegment(streamlines, 3.))
[array([[ 0.,  0.,  0.],
       [ 2.,  0.,  0.],
       [ 5.,  0.,  0.]])]
>>> list(subsegment(streamlines, 1))
[array([[ 0.,  0.,  0.],
       [ 1.,  0.,  0.],
       [ 2.,  0.,  0.],
       [ 3.,  0.,  0.],
       [ 4.,  0.,  0.],
       [ 5.,  0.,  0.]])]
>>> list(subsegment(streamlines, 1.6))
[array([[ 0. ,  0. ,  0. ],
       [ 1. ,  0. ,  0. ],
       [ 2. ,  0. ,  0. ],
       [ 3.5,  0. ,  0. ],
       [ 5. ,  0. ,  0. ]])]

`Streamlines`	alias of `nibabel.streamlines.array_sequence.ArraySequence`
`bench`([label, verbose, extra_argv])	Run benchmarks for module using nose.
`test`([label, verbose, extra_argv, doctests, …])	Run tests for module using nose.

`Streamlines`	alias of `nibabel.streamlines.array_sequence.ArraySequence`
`assert_array_almost_equal`(x, y[, decimal, …])	Raises an AssertionError if two objects are not equal up to desired precision.
`assert_array_equal`(x, y[, err_msg, verbose])	Raises an AssertionError if two array_like objects are not equal.
`bench_compress_streamlines`()
`bench_length`()
`bench_set_number_of_points`()
`compress_streamlines`	Compress streamlines by linearization as in [Presseau15].
`compress_streamlines_python`(streamline[, …])	Python version of the FiberCompression found on https://github.com/scilus/FiberCompression.
`generate_streamlines`(nb_streamlines, …)
`get_fnames`([name])	provides filenames of some test datasets or other useful parametrisations
`length`	Euclidean length of streamlines
`length_python`(xyz[, along])
`load_tractogram`(filename, reference[, …])	Load the stateful tractogram from any format (trk, tck, fib, dpy)
`measure`(code_str[, times, label])	Return elapsed time for executing code in the namespace of the caller.
`set_number_of_points`	Change the number of points of streamlines
`set_number_of_points_python`(xyz[, n_pols])
`setup`()

`detect_corresponding_tracks`(indices, …)	Detect corresponding tracks from list tracks1 to list tracks2 where tracks1 & tracks2 are lists of tracks
`detect_corresponding_tracks_plus`(indices, …)	Detect corresponding tracks from 1 to 2 where tracks1 & tracks2 are sequences of tracks

`FiberFit`(fiber_model, life_matrix, …)	A fit of the LiFE model to diffusion data
`FiberModel`(gtab)	A class for representing and solving predictive models based on tractography solutions.
`LifeSignalMaker`(gtab[, evals, sphere])	A class for generating signals from streamlines in an efficient and speedy manner.
`ReconstFit`(model, data)	Abstract class which holds the fit result of ReconstModel
`ReconstModel`(gtab)	Abstract class for signal reconstruction models
`grad_tensor`(grad, evals)	Calculate the 3 by 3 tensor for a given spatial gradient, given a canonical tensor shape (also as a 3 by 3), pointing at [1,0,0]
`gradient`(f)	Return the gradient of an N-dimensional array.
`streamline_gradients`(streamline)	Calculate the gradients of the streamline along the spatial dimension
`streamline_signal`(streamline, gtab[, evals])	The signal from a single streamline estimate along each of its nodes.
`streamline_tensors`(streamline[, evals])	The tensors generated by this fiber.
`transform_streamlines`(streamlines, mat[, …])	Apply affine transformation to streamlines
`unique_rows`(in_array[, dtype])	This (quickly) finds the unique rows in an array
`voxel2streamline`(streamline, affine[, …])	Maps voxels to streamlines and streamlines to voxels, for setting up the LiFE equations matrix

`AnatomicalStoppingCriterion`	Abstract class that takes as input included and excluded tissue maps.
`LocalTracking`(direction_getter, …[, …])
`ParticleFilteringTracking`(direction_getter, …)
`StreamlineStatus`	An enumeration.
`local_tracker`	Tracks one direction from a seed.
`pft_tracker`	Tracks one direction from a seed using the particle filtering algorithm.

`arbitrarypoint`(xyz, distance)	Select an arbitrary point along distance on the track (curve)
`bytes`(xyz)	Size of track in bytes.
`center_of_mass`(xyz)	Center of mass of streamline
`downsample`(xyz[, n_pols])	downsample for a specific number of points along the curve/track
`endpoint`(xyz)	Parameters
`frenet_serret`(xyz)	Frenet-Serret Space Curve Invariants
`generate_combinations`(items, n)	Combine sets of size n from items
`inside_sphere`(xyz, center, radius)	If any point of the track is inside a sphere of a specified center and radius return True otherwise False.
`inside_sphere_points`(xyz, center, radius)	If a track intersects with a sphere of a specified center and radius return the points that are inside the sphere otherwise False.
`intersect_sphere`(xyz, center, radius)	If any segment of the track is intersecting with a sphere of specific center and radius return True otherwise False
`length`(xyz[, along])	Euclidean length of track line
`longest_track_bundle`(bundle[, sort])	Return longest track or length sorted track indices in bundle
`magn`(xyz[, n])	magnitude of vector
`mean_curvature`(xyz)	Calculates the mean curvature of a curve
`mean_orientation`(xyz)	Calculates the mean orientation of a curve
`midpoint`(xyz)	Midpoint of track
`midpoint2point`(xyz, p)	Calculate distance from midpoint of a curve to arbitrary point p
`principal_components`(xyz)	We use PCA to calculate the 3 principal directions for a track
`splev`(x, tck[, der, ext])	Evaluate a B-spline or its derivatives.
`spline`(xyz[, s, k, nest])	Generate B-splines as documented in http://www.scipy.org/Cookbook/Interpolation
`splprep`(x[, w, u, ub, ue, k, task, s, t, …])	Find the B-spline representation of an N-dimensional curve.
`startpoint`(xyz)	First point of the track
`winding`(xyz)	Total turning angle projected.

`Streamlines`	alias of `nibabel.streamlines.array_sequence.ArraySequence`
`apply_affine`(aff, pts)	Apply affine matrix aff to points pts
`bundles_distances_mdf`	Calculate distances between list of tracks A and list of tracks B
`cdist`(XA, XB[, metric])	Compute distance between each pair of the two collections of inputs.
`center_streamlines`(streamlines)	Move streamlines to the origin
`cluster_confidence`(streamlines[, max_mdf, …])	Computes the cluster confidence index (cci), which is an estimation of the support a set of streamlines gives to a particular pathway.
`compress_streamlines`	Compress streamlines by linearization as in [Presseau15].
`deepcopy`(x[, memo, _nil])	Deep copy operation on arbitrary Python objects.
`deform_streamlines`(streamlines, …)	Apply deformation field to streamlines
`dist_to_corner`(affine)	Calculate the maximal distance from the center to a corner of a voxel, given an affine
`interpolate_scalar_3d`	Trilinear interpolation of a 3D scalar image
`interpolate_vector_3d`	Trilinear interpolation of a 3D vector field
`length`	Euclidean length of streamlines
`nbytes`(streamlines)
`orient_by_rois`(streamlines, affine, roi1, roi2)	Orient a set of streamlines according to a pair of ROIs
`orient_by_streamline`(streamlines, standard)	Orient a bundle of streamlines to a standard streamline.
`relist_streamlines`(points, offsets)	Given a representation of a set of streamlines as a large array and an offsets array return the streamlines as a list of shorter arrays.
`select_by_rois`(streamlines, affine, rois, …)	Select streamlines based on logical relations with several regions of interest (ROIs).
`select_random_set_of_streamlines`(…[, rng])	Select a random set of streamlines
`set_number_of_points`	Change the number of points of streamlines
`transform_streamlines`(streamlines, mat[, …])	Apply affine transformation to streamlines
`unlist_streamlines`(streamlines)	Return the streamlines not as a list but as an array and an offset
`values_from_volume`(data, streamlines, affine)	Extract values of a scalar/vector along each streamline from a volume.
`warn`	Issue a warning, or maybe ignore it or raise an exception.

`defaultdict`	defaultdict(default_factory[, …]) –> dict with default factory
`apply_affine`(aff, pts)	Apply affine matrix aff to points pts
`asarray`(a[, dtype, order])	Convert the input to an array.
`cdist`(XA, XB[, metric])	Compute distance between each pair of the two collections of inputs.
`connectivity_matrix`(streamlines, affine, …)	Counts the streamlines that start and end at each label pair.
`density_map`(streamlines, affine, vol_dims)	Counts the number of unique streamlines that pass through each voxel.
`dist_to_corner`(affine)	Calculate the maximal distance from the center to a corner of a voxel, given an affine
`empty`(shape[, dtype, order])	Return a new array of given shape and type, without initializing entries.
`length`(streamlines)	Calculate the lengths of many streamlines in a bundle.
`minimum_at`(a, indices[, b])	Performs unbuffered in place operation on operand ‘a’ for elements specified by ‘indices’.
`ndbincount`(x[, weights, shape])	Like bincount, but for nd-indices.
`near_roi`(streamlines, affine, region_of_interest)	Provide filtering criteria for a set of streamlines based on whether they fall within a tolerance distance from an ROI
`path_length`(streamlines, affine, aoi[, …])	Computes the shortest path, along any streamline, between aoi and each voxel.
`random_seeds_from_mask`(mask, affine[, …])	Create randomly placed seeds for fiber tracking from a binary mask.
`ravel_multi_index`(multi_index, dims[, mode, …])	Converts a tuple of index arrays into an array of flat indices, applying boundary modes to the multi-index.
`reduce_labels`(label_volume)	Reduces an array of labels to the integers from 0 to n with smallest possible n.
`reduce_rois`(rois, include)	Reduce multiple ROIs to one inclusion and one exclusion ROI.
`seeds_from_mask`(mask, affine[, density])	Create seeds for fiber tracking from a binary mask.
`streamline_near_roi`(streamline, roi_coords, tol)	Is a streamline near an ROI.
`subsegment`(streamlines, max_segment_length)	Splits the segments of the streamlines into small segments.
`target`(streamlines, affine, target_mask[, …])	Filters streamlines based on whether or not they pass through an ROI.
`target_line_based`(streamlines, affine, …)	Filters streamlines based on whether or not they pass through a ROI, using a line-based algorithm.
`transform_tracking_output`(tracking_output, …)	Applies a linear transformation, given by affine, to streamlines.
`unique_rows`(in_array[, dtype])	This (quickly) finds the unique rows in an array
`warn`	Issue a warning, or maybe ignore it or raise an exception.
`wraps`(wrapped[, assigned, updated])	Decorator factory to apply update_wrapper() to a wrapper function

`fit`(data, streamline, affine[, evals, sphere])	Fit the LiFE FiberModel for data and a set of streamlines associated with this data
`setup`(streamline, affine[, evals, sphere])	Set up the necessary components for the LiFE model: the matrix of fiber-contributions to the DWI signal, and the coordinates of voxels for which the equations will be solved

`clear`()
`copy`()
`fromkeys`($type, iterable[, value])	Returns a new dict with keys from iterable and values equal to value.
`get`(k[,d])
`items`()
`keys`()
`pop`(k[,d])	If key is not found, d is returned if given, otherwise KeyError is raised
`popitem`()	2-tuple; but raise KeyError if D is empty.
`setdefault`(k[,d])
`update`([E, ]**F)	If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]
`values`()

check_point
get_exclude
get_include

tracking¶

Module: tracking._utils¶

Module: tracking.benchmarks¶

Module: tracking.benchmarks.bench_streamline¶

Module: tracking.learning¶

Module: tracking.life¶

Module: tracking.local_tracking¶

Module: tracking.metrics¶

Module: tracking.streamline¶

Module: tracking.utils¶

Important Notes¶

bench¶

test¶

warn¶

assert_array_almost_equal¶

assert_array_equal¶

bench_compress_streamlines¶

bench_length¶

bench_set_number_of_points¶

compress_streamlines¶

compress_streamlines_python¶

generate_streamlines¶

get_fnames¶

length¶

length_python¶

load_tractogram¶

measure¶

set_number_of_points¶

set_number_of_points_python¶

setup¶

detect_corresponding_tracks¶

detect_corresponding_tracks_plus¶

grad_tensor¶

gradient¶

streamline_gradients¶

streamline_signal¶

streamline_tensors¶

transform_streamlines¶

unique_rows¶

voxel2streamline¶

local_tracker¶

pft_tracker¶

arbitrarypoint¶

bytes¶

center_of_mass¶

downsample¶

endpoint¶

frenet_serret¶

generate_combinations¶

inside_sphere¶

inside_sphere_points¶

intersect_sphere¶

length¶

longest_track_bundle¶

magn¶

mean_curvature¶

mean_orientation¶

midpoint¶

midpoint2point¶

principal_components¶

splev¶

spline¶

splprep¶

startpoint¶

winding¶

apply_affine¶

bundles_distances_mdf¶

cdist¶

center_streamlines¶

cluster_confidence¶

compress_streamlines¶

deepcopy¶

deform_streamlines¶

dist_to_corner¶

interpolate_scalar_3d¶

interpolate_vector_3d¶

length¶

nbytes¶

orient_by_rois¶

orient_by_streamline¶

`tracking`¶

Module: `tracking._utils`¶

Module: `tracking.benchmarks`¶

Module: `tracking.benchmarks.bench_streamline`¶

Module: `tracking.learning`¶

Module: `tracking.life`¶

Module: `tracking.local_tracking`¶

Module: `tracking.metrics`¶

Module: `tracking.streamline`¶

Module: `tracking.utils`¶