dipy logo

Site Navigation

NIPY Community

Previous topic

dipy.tracking.propspeed

Next topic

dipy.tracking.vox2track

dipy.tracking.utils

dipy.tracking.utils.affine_from_fsl_mat_file(mat_affine, input_voxsz, output_voxsz)

It takes the affine matrix from flirt (FSLdot) and the voxel size of the input and output images and it returns the adjusted affine matrix for trackvis.

dipy.tracking.utils.connectivity_matrix(streamlines, label_volume, voxel_size, symmetric=False, return_mapping=False, mapping_as_streamlines=False)

Counts the streamlines that start and end at each label pair

symmetric means we don’t distiguish between start and end

dipy.tracking.utils.density_map(streamlines, vol_dims, voxel_size)

Counts the number of unique streamlines that pass though each voxel

Counts the number of points in each streamline that lie inside each voxel.

Parameters :

streamlines : iterable

A sequence of arrays, each streamline should a list of points in 3-space, where (0,0,0) is one corner of the first voxel in image volume, voxel_size the diagonal corner of the same voxel and voxel_size*vol_dims is the diagonal corner of the image.

vol_dims : 3 ints

The shape of the volume to be returned containing the streamlines counts

voxel_size : 3 floats

The size of the voxels in the image volume

Returns :

image_volume : ndarray, shape=vol_dims

The number of streamline points in each voxel of volume

Raises :

IndexError :

When the points of the streamlines lie outside of the return volume

Notes

A streamline can pass though a voxel even if one of the points of the streamline does not lie in the voxel. For example a step from [0,0,0] to [0,0,2] passes though [0,0,1]. Consider subsegmenting the streamlines when the edges of the voxels are smaller than the steps of the streamlines.

dipy.tracking.utils.length(streamlines)

Calculates the lenth of each streamline in a sequence of streamlines

Sums the lenths of each segment in a streamline to get the length of the streamline. Returns a generator.

Example: >>> streamlines = [np.array([[0., 0., 0.], ... [0., 0., 1.], ... [3., 4., 1.]]), ... np.array([[0., 0., 0.]])] >>> list(length(streamlines)) [6.0, 0.0]

dipy.tracking.utils.merge_streamlines(backward, forward)

Merges two sets of streamlines seeded at the same points

Because the first point of each streamline pair should be the same, only one is kept

Parameters :

backward : iterable

a sequence of streamlines, will be returned in reversed order in the result

forward : iterable

a sequence of streamlines, will be returned in same order in the result

Returns :

streamlines : generator

generator of merged streamlines

Examples

>>> A = [array([[0,0,0],[1,1,1],[2,2,2]])]
>>> B = [array([[0,0,0],[-1,-1,-1],[-2,-2,-2]])]
>>> list(merge_streamlines(A,B))
[array([[ 2,  2,  2],
       [ 1,  1,  1],
       [ 0,  0,  0],
       [-1, -1, -1],
       [-2, -2, -2]])]
>>> list(merge_streamlines(B,A))
[array([[-2, -2, -2],
       [-1, -1, -1],
       [ 0,  0,  0],
       [ 1,  1,  1],
       [ 2,  2,  2]])]
dipy.tracking.utils.move_streamlines(streamlines, affine)

Applies a linear transformation, given by affine, to streamlines

Parameters :

streamlines : sequence

A set of streamlines to be transformed.

affine : array (4, 4)

A linear tranformation to be applied to the streamlines. The last row of affine should be [0, 0, 0, 1].

Returns :

streamlines : generator

A sequence of transformed streamlines

dipy.tracking.utils.ndbincount(x, weights=None, shape=None)

Like bincount, but for nd-indicies

Parameters :

x : array_like (N, M)

M indices to a an Nd-array

weights : array_like (M,), optional

Weights associated with indices

shape : optional

the shape of the output

dipy.tracking.utils.ravel_multi_index(index, dims)

An alternate implementation of numpy.ravel_multi_index for older versions of numpy.

dipy.tracking.utils.reduce_labels(label_volume)

Reduces an array of labels to the integers from 0 to n with smallest possible n

Examples

>>> 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
array([[0, 1, 4],
       [0, 1, 3],
       [0, 1, 2]])
>>> (lookup[new_labels] == labels).all()
True
dipy.tracking.utils.reorder_voxels_affine(input_ornt, output_ornt, shape, voxel_size)

Calculates a linear tranformation equivelent to chaning voxel order

Calculates a linear tranformation A such that [a, b, c, 1] = A[x, y, z, 1]. where [x, y, z] is a point in the coordinate system defined by input_ornt and [a, b, c] is the same point in the coordinate system defined by output_ornt.

Parameters :

input_ornt : array (n, 2)

A description of the orientation of a point in n-space. See nibabel.orientation or dipy.io.bvectxt for more information.

output_ornt : array (n, 2)

A description of the orientation of a point in n-space.

shape : tuple of int

Shape of the image in the input orientation. map = ornt_mapping(input_ornt, output_ornt)

voxel_size : int

Voxel size of the image in the input orientation.

Returns :

A : array (n+1, n+1)

Affine matrix of the transformation between input_ornt and output_ornt.

dipy.tracking.utils.seeds_from_mask(mask, density, voxel_size=(1, 1, 1))

Takes a binary mask and returns seeds in voxels != 0

places evanly spaced points in nonzero voxels of mask, spaces the points based on density. For example if density is [1, 2, 3], there will be 6 points in each voxel, at x=.5, y=[.25, .75] and z=[.166, .5, .833]. density=a is the same as density = [a, a, a]

Examples

>>> mask = zeros((3,3,3), 'bool')
>>> mask[0,0,0] = 1
>>> seeds_from_mask(mask, [1,1,1], [1,1,1])
array([[ 0.5,  0.5,  0.5]])
>>> seeds_from_mask(mask, [1,2,3], [1,1,1])
array([[ 0.5       ,  0.25      ,  0.16666667],
       [ 0.5       ,  0.25      ,  0.5       ],
       [ 0.5       ,  0.25      ,  0.83333333],
       [ 0.5       ,  0.75      ,  0.16666667],
       [ 0.5       ,  0.75      ,  0.5       ],
       [ 0.5       ,  0.75      ,  0.83333333]])
>>> mask[0,1,2] = 1
>>> seeds_from_mask(mask, [1,1,2], [1.1,1.1,2.5])
array([[ 0.55 ,  0.55 ,  0.625],
       [ 0.55 ,  0.55 ,  1.875],
       [ 0.55 ,  1.65 ,  5.625],
       [ 0.55 ,  1.65 ,  6.875]])
dipy.tracking.utils.streamline_mapping(streamlines, voxel_size, mapping_as_streamlines=False)

Creates a mapping from voxel indices to streamlines

Returns a dictionary where each key is a 3d voxel index and the associated value is a list of the streamlines that pass through that voxel.

Examples

>>> streamlines = [np.array([[0., 0., 0.],
...                          [1., 1., 1.],
...                          [2., 3., 4.]]),
...                np.array([[0., 0., 0.],
...                          [1., 2., 3.]])]
>>> mapping = streamline_mapping(streamlines, (1, 1, 1))
>>> mapping[0, 0, 0]
[0, 1]
>>> mapping[1, 1, 1]
[0]
>>> mapping[1, 2, 3]
[1]
>>> mapping.get((3, 2, 1), 'no streamlines')
'no streamlines'
>>> mapping = streamline_mapping(streamlines, (1, 1, 1),
...                              mapping_as_streamlines=True)
>>> mapping[1, 2, 3][0] is streamlines[1]
True
dipy.tracking.utils.subsegment(streamlines, max_segment_length)

Splits the segments of the streamlines into small segments

Replaces each segment of each of the streamlines with the smallest possible number ofequally sized smaller segments such that no segmentment is longer than max_segment_length. Among other things, this can useful for getting streamline counts on a grid that is smaller than the length of the streamline segments.

Parameters :

streamlines : sequence of ndarrays

The streamlines to be subsegmented.

max_segment_length : float

The longest allowable segment length.

Returns :

output_streamlines : generator

A set of streamlines.

Notes

Segments of 0 length are removed. If unchanged

Examples

>>> streamlines = [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. ]])]
dipy.tracking.utils.target(streamlines, target_mask, voxel_size)

Retain tracks that pass though target_mask

This function loops over the streamlines and returns streamlines that pass though target_mask.

Parameters :

streamlines : iterable

A squence of streamlines. Each streamline should be a (N, 3) array, where N is the length of the streamline.

target_mask : array-like

A mask used as a target

voxel_size :

Size of the voxels in the target_mask

Returns :

streamlines : generator

A sequence of streamlines that pass though target_mask

Raises :

IndexError :

When the points of the streamlines lie outside of the target_mask

See also

density_map