`segment`¶

class

import dipy.segment as dipysegment
dipysegment.bench()

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

>>> np.testing.assert_equal([4,5], [4,6])
Traceback (most recent call last):
    ...
AssertionError:
Items are not equal:
item=1
 ACTUAL: 5
 DESIRED: 6

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

>>> 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]

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]]]...)

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

>>> 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]

s1       s2

0*   a    *0
  \       |
   \      |
   1*     |
    |  b  *1
    |      \
    2*      \
        c    *2

s1       s2

0*   a    *0
  \       |
   \      |
   1*     |
    |  b  *1
    |      \
    2*      \
        c    *2

>>> from dipy.segment.clustering import QuickBundles
>>> from dipy.data import get_fnames
>>> from dipy.io.streamline import load_tractogram
>>> from dipy.tracking.streamline import Streamlines
>>> fname = get_fnames('fornix')
>>> fornix = load_tractogram(fname, 'same',
...                          bbox_valid_check=False).streamlines
>>> streamlines = Streamlines(fornix)
>>> # Segment fornix with a threshold of 10mm and streamlines resampled
>>> # to 12 points.
>>> qb = QuickBundles(threshold=10.)
>>> clusters = qb.cluster(streamlines)
>>> len(clusters)
4
>>> list(map(len, clusters))
[61, 191, 47, 1]
>>> # Resampling streamlines differently is done explicitly as follows.
>>> # Note this has an impact on the speed and the accuracy (tradeoff).
>>> from dipy.segment.metric import ResampleFeature
>>> from dipy.segment.metric import AveragePointwiseEuclideanMetric
>>> feature = ResampleFeature(nb_points=2)
>>> metric = AveragePointwiseEuclideanMetric(feature)
>>> qb = QuickBundles(threshold=10., metric=metric)
>>> clusters = qb.cluster(streamlines)
>>> len(clusters)
4
>>> list(map(len, clusters))
[58, 142, 72, 28]

>>> 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]

>>> from scipy import ndimage
>>> a = np.zeros((5, 5))
>>> a[2, 2] = 1
>>> a
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> ndimage.binary_dilation(a)
array([[False, False, False, False, False],
       [False, False,  True, False, False],
       [False,  True,  True,  True, False],
       [False, False,  True, False, False],
       [False, False, False, False, False]], dtype=bool)
>>> ndimage.binary_dilation(a).astype(a.dtype)
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> # 3x3 structuring element with connectivity 1, used by default
>>> struct1 = ndimage.generate_binary_structure(2, 1)
>>> struct1
array([[False,  True, False],
       [ True,  True,  True],
       [False,  True, False]], dtype=bool)
>>> # 3x3 structuring element with connectivity 2
>>> struct2 = ndimage.generate_binary_structure(2, 2)
>>> struct2
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]], dtype=bool)
>>> ndimage.binary_dilation(a, structure=struct1).astype(a.dtype)
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> ndimage.binary_dilation(a, structure=struct2).astype(a.dtype)
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> ndimage.binary_dilation(a, structure=struct1,\
... iterations=2).astype(a.dtype)
array([[ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  1.,  0.,  0.]])

>>> from scipy import ndimage
>>> struct = ndimage.generate_binary_structure(2, 1)
>>> struct
array([[False,  True, False],
       [ True,  True,  True],
       [False,  True, False]], dtype=bool)
>>> a = np.zeros((5,5))
>>> a[2, 2] = 1
>>> a
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> b = ndimage.binary_dilation(a, structure=struct).astype(a.dtype)
>>> b
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> ndimage.binary_dilation(b, structure=struct).astype(a.dtype)
array([[ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  1.,  0.,  0.]])
>>> struct = ndimage.generate_binary_structure(2, 2)
>>> struct
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]], dtype=bool)
>>> struct = ndimage.generate_binary_structure(3, 1)
>>> struct # no diagonal elements
array([[[False, False, False],
        [False,  True, False],
        [False, False, False]],
       [[False,  True, False],
        [ True,  True,  True],
        [False,  True, False]],
       [[False, False, False],
        [False,  True, False],
        [False, False, False]]], dtype=bool)

>>> from scipy import ndimage, misc
>>> import matplotlib.pyplot as plt
>>> fig = plt.figure()
>>> plt.gray()  # show the filtered result in grayscale
>>> ax1 = fig.add_subplot(121)  # left side
>>> ax2 = fig.add_subplot(122)  # right side
>>> ascent = misc.ascent()
>>> result = ndimage.median_filter(ascent, size=20)
>>> ax1.imshow(ascent)
>>> ax2.imshow(result)
>>> plt.show()

>>> from skimage.data import camera
>>> image = camera()
>>> thresh = threshold_otsu(image)
>>> binary = image <= thresh

s1       s2

0*   a    *0
  \       |
   \      |
   1*     |
    |  b  *1
    |      \
    2*      \
        c    *2

s1       s2

0*   a    *0
  \       |
   \      |
   1*     |
    |  b  *1
    |      \
    2*      \
        c    *2

s1       s2

0*   a    *0
  \       |
   \      |
   1*     |
    |  b  *1
    |      \
    2*      \
        c    *2

>>> signal = np.arange(800).reshape(2, 2, 2, 100)
>>> signal_w_noise = add_noise(signal, 10., 100., noise_type='rician')

`MDFpy`	Attributes
`Metric`	Computes a distance between two sequential data.
`QB_New`	alias of `dipy.segment.clustering.QuickBundles`
`Streamlines`	alias of `nibabel.streamlines.array_sequence.ArraySequence`
`assert_array_equal`(x, y[, err_msg, verbose])	Raises an AssertionError if two array_like objects are not equal.
`assert_arrays_equal`(arrays1, arrays2)
`assert_equal`(actual, desired[, err_msg, verbose])	Raises an AssertionError if two objects are not equal.
`bench_quickbundles`()
`get_fnames`([name])	provides filenames of some test datasets or other useful parametrisations
`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

`BundleMinDistanceAsymmetricMetric`([num_threads])	Asymmetric Bundle-based Minimum distance
`BundleMinDistanceMetric`([num_threads])	Bundle-based Minimum Distance aka BMD
`BundleSumDistanceMatrixMetric`([num_threads])	Bundle-based Sum Distance aka BMD
`RecoBundles`(streamlines[, greater_than, …])	Methods
`StreamlineLinearRegistration`([metric, x0, …])	Methods
`Streamlines`	alias of `nibabel.streamlines.array_sequence.ArraySequence`
`chain`	chain(*iterables) –> chain object
`apply_affine`(aff, pts)	Apply affine matrix aff to points pts
`bundle_adjacency`(dtracks0, dtracks1, threshold)	Find bundle adjacency between two given tracks/bundles
`bundles_distances_mam`	Calculate distances between list of tracks A and list of tracks B
`bundles_distances_mdf`	Calculate distances between list of tracks A and list of tracks B
`check_range`(streamline, gt, lt)
`length`	Euclidean length of streamlines
`nbytes`(streamlines)
`qbx_and_merge`(streamlines, thresholds[, …])	Run QuickBundlesX and then run again on the centroids of the last layer
`select_random_set_of_streamlines`(…[, rng])	Select a random set of streamlines
`set_number_of_points`	Change the number of points of streamlines
`time`()	Return the current time in seconds since the Epoch.

`ABCMeta`	Metaclass for defining Abstract Base Classes (ABCs).
`AveragePointwiseEuclideanMetric`	Computes the average of pointwise Euclidean distances between two sequential data.
`Cluster`([id, indices, refdata])	Provides functionalities for interacting with a cluster.
`ClusterCentroid`(centroid[, id, indices, refdata])	Provides functionalities for interacting with a cluster.
`ClusterMap`([refdata])	Provides functionalities for interacting with clustering outputs.
`ClusterMapCentroid`([refdata])	Provides functionalities for interacting with clustering outputs that have centroids.
`Clustering`	Methods
`Identity`	Provides identity indexing functionality.
`Metric`	Computes a distance between two sequential data.
`MinimumAverageDirectFlipMetric`	Computes the MDF distance (minimum average direct-flip) between two sequential data.
`QuickBundles`(threshold[, metric, …])	Clusters streamlines using QuickBundles [Garyfallidis12].
`QuickBundlesX`(thresholds[, metric])	Clusters streamlines using QuickBundlesX.
`ResampleFeature`	Extracts features from a sequential datum.
`TreeCluster`(threshold, centroid[, indices])	Attributes
`TreeClusterMap`(root)	Attributes
`abstractmethod`(funcobj)	A decorator indicating abstract methods.
`nbytes`(streamlines)
`qbx_and_merge`(streamlines, thresholds[, …])	Run QuickBundlesX and then run again on the centroids of the last layer
`set_number_of_points`	Change the number of points of streamlines
`time`()	Return the current time in seconds since the Epoch.

`applymask`(vol, mask)	Mask vol with mask.
`binary_dilation`(input[, structure, …])	Multi-dimensional binary dilation with the given structuring element.
`bounding_box`(vol)	Compute the bounding box of nonzero intensity voxels in the volume.
`clean_cc_mask`(mask)	Cleans a segmentation of the corpus callosum so no random pixels are included.
`color_fa`(fa, evecs)	Color fractional anisotropy of diffusion tensor
`crop`(vol, mins, maxs)	Crops the input volume.
`fractional_anisotropy`(evals[, axis])	Fractional anisotropy (FA) of a diffusion tensor.
`generate_binary_structure`(rank, connectivity)	Generate a binary structure for binary morphological operations.
`median_filter`(input[, size, footprint, …])	Calculate a multidimensional median filter.
`median_otsu`(input_volume[, vol_idx, …])	Simple brain extraction tool method for images from DWI data.
`multi_median`(input, median_radius, numpass)	Applies median filter multiple times on input data.
`otsu`(image[, nbins])	Return threshold value based on Otsu’s method.
`segment_from_cfa`(tensor_fit, roi, threshold)	Segment the cfa inside roi using the values from threshold as bounds.
`warn`	Issue a warning, or maybe ignore it or raise an exception.

`ArcLengthFeature`	Extracts features from a sequential datum.
`AveragePointwiseEuclideanMetric`	Computes the average of pointwise Euclidean distances between two sequential data.
`CenterOfMassFeature`	Extracts features from a sequential datum.
`CosineMetric`	Computes the cosine distance between two vectors.
`EuclideanMetric`	alias of `dipy.segment.metricspeed.SumPointwiseEuclideanMetric`
`Feature`	Extracts features from a sequential datum.
`IdentityFeature`	Extracts features from a sequential datum.
`Metric`	Computes a distance between two sequential data.
`MidpointFeature`	Extracts features from a sequential datum.
`MinimumAverageDirectFlipMetric`	Computes the MDF distance (minimum average direct-flip) between two sequential data.
`ResampleFeature`	Extracts features from a sequential datum.
`SumPointwiseEuclideanMetric`	Computes the sum of pointwise Euclidean distances between two sequential data.
`VectorOfEndpointsFeature`	Extracts features from a sequential datum.
`dist`	Computes a distance between datum1 and datum2.
`distance_matrix`	Computes the distance matrix between two lists of sequential data.
`mdf`(s1, s2)	Computes the MDF (Minimum average Direct-Flip) distance [Garyfallidis12] between two streamlines.

`otsu`(image[, nbins])	Return threshold value based on Otsu’s method.
`upper_bound_by_percent`(data[, percent])	Find the upper bound for visualization of medical images
`upper_bound_by_rate`(data[, rate])	Adjusts upper intensity boundary using rates

`ConstantObservationModel`	Observation model assuming that the intensity of each class is constant.
`IteratedConditionalModes`	Methods
`TissueClassifierHMRF`([save_history, verbose])	This class contains the methods for tissue classification using the Markov Random Fields modeling approach
`add_noise`(signal, snr, S0[, noise_type])	Add noise of specified distribution to the signal from a single voxel.

`are_compatible`(shape1, shape2)	Checks if features can be used by metric.dist based on their shape.
`dist`(features1, features2)	Computes a distance between two data points based on their features.

`are_compatible`	Checks if features can be used by metric.dist based on their shape.
`dist`	Computes a distance between two data points based on their features.

`distance`(xopt)	Distance calculated from this Metric
`setup`(static, moving)	Setup static and moving sets of streamlines

`evaluate_results`(model_bundle, …)	Compare the similiarity between two given bundles, model bundle, and extracted bundle.
`recognize`(model_bundle, model_clust_thr[, …])	Recognize the model_bundle in self.streamlines
`refine`(model_bundle, pruned_streamlines, …)	Refine and recognize the model_bundle in self.streamlines This method expects once pruned streamlines as input.

`__call__`($self, /, args, *kwargs)	Call self as a function.
`mro`()	return a type’s method resolution order
`register`(subclass)	Register a virtual subclass of an ABC.

`assign`(id_datum, features)	Assigns a data point to this cluster.
`update`()	Update centroid of this cluster.

`add_cluster`(*clusters)	Adds one or multiple clusters to this cluster map.
`clear`()	Remove all clusters from this cluster map.
`clusters_sizes`()	Gets the size of every cluster contained in this cluster map.
`get_large_clusters`(min_size)	Gets clusters which contains at least min_size elements.
`get_small_clusters`(max_size)	Gets clusters which contains at most max_size elements.
`remove_cluster`(*clusters)	Remove one or multiple clusters from this cluster map.
`size`()	Gets number of clusters contained in this cluster map.

`extract`	Extracts features from a sequential datum.
`infer_shape`	Infers the shape of features extracted from a sequential datum.

setup(static, moving)
distance(xopt)

setup(static, moving)
distance(xopt)

get_clusters
iter_preorder
traverse_postorder

`initialize_param_uniform`	Initializes the means and variances uniformly
`negloglikelihood`	Computes the gaussian negative log-likelihood of each class at each voxel of image assuming a gaussian distribution with means and variances given by mu and sigmasq, respectively (constant models along the full volume).
`prob_image`	Conditional probability of the label given the image
`seg_stats`	Mean and standard variation for N desired tissue classes
`update_param`	Updates the means and the variances in each iteration for all the labels.
`update_param_new`	Updates the means and the variances in each iteration for all the labels.

`icm_ising`	Executes one iteration of the ICM algorithm for MRF MAP estimation.
`initialize_maximum_likelihood`	Initializes the segmentation of an image with given
`prob_neighborhood`	Conditional probability of the label given the neighborhood Equation 2.18 of the Stan Z.

segment¶

Module: segment.benchmarks¶

Module: segment.benchmarks.bench_quickbundles¶

Module: segment.bundles¶

Module: segment.clustering¶

Module: segment.mask¶

Module: segment.metric¶

Module: segment.threshold¶

Module: segment.tissue¶

assert_array_equal¶

assert_arrays_equal¶

assert_equal¶

bench_quickbundles¶

get_fnames¶

load_tractogram¶

measure¶

set_number_of_points¶

apply_affine¶

bundle_adjacency¶

bundles_distances_mam¶

bundles_distances_mdf¶

check_range¶

length¶

nbytes¶

qbx_and_merge¶

select_random_set_of_streamlines¶

set_number_of_points¶

time¶

abstractmethod¶

nbytes¶

qbx_and_merge¶

set_number_of_points¶

time¶

applymask¶

binary_dilation¶

bounding_box¶

clean_cc_mask¶

color_fa¶

crop¶

fractional_anisotropy¶

generate_binary_structure¶

median_filter¶

median_otsu¶

multi_median¶

otsu¶

segment_from_cfa¶

warn¶

dist¶

distance_matrix¶

mdf¶

otsu¶

upper_bound_by_percent¶

upper_bound_by_rate¶

add_noise¶

`segment`¶

Module: `segment.benchmarks`¶

Module: `segment.benchmarks.bench_quickbundles`¶

Module: `segment.bundles`¶

Module: `segment.clustering`¶

Module: `segment.mask`¶

Module: `segment.metric`¶

Module: `segment.threshold`¶

Module: `segment.tissue`¶