`denoise`#

Module: `denoise._bias_correction`#

Cython backend for bias field correction.

Provides accelerated B-spline design matrix construction, Gram matrix accumulation, and Tukey biweight weight computation.

`compute_tukey_weights`(residuals, weights, *)	Compute Tukey biweight weights and multiply into `weights` in-place.
`evaluate_bspline_rows`(grid_coords, n_ctrl, ...)	Evaluate cubic B-spline basis for N masked voxels, filling CSR arrays.
`gram_matrix_csr`(data, indices, indptr, ...)	Accumulate weighted Gram matrix and right-hand side from a CSR matrix.
`masked_voxel_coords`(mask, out)	Extract (i, j, k) voxel coordinates of all nonzero mask entries.

Module: `denoise.adaptive_soft_matching`#

adaptive_soft_matching(ima, fimau, fimao, sigma)

Adaptive Soft Coefficient Matching

Module: `denoise.bias_correction`#

Bias field correction for diffusion MRI data.

Provides classical regression-based bias field correction via Legendre polynomial regression and cubic B-spline regression.

The bias field is estimated exclusively from the mean b0 volume in the log domain and applied uniformly to all DWI volumes.

`polynomial_bias_field_dwi`(data, gtab, *[, ...])	DWI bias field correction via multi-resolution Legendre polynomial regression.
`bias_field_correction`(data, gtab, *[, mask, ...])	Top-level DWI bias field correction via regression.

Module: `denoise.denspeed`#

`add_padding_reflection`(arr, padding)
`correspond_indices`(dim_size, padding)
`determine_num_threads`(num_threads)	Determine the effective number of threads to be used for OpenMP calls
`firdn`(image, h)	Applies the filter given by the convolution kernel 'h' columnwise to 'image', then subsamples by 2.
`nlmeans_3d`(arr[, mask, sigma, patch_radius, ...])	Non-local means for denoising 3D images with selectable algorithm
`nlmeans_3d_blockwise`(image, mask, ...[, ...])	Non-Local Means Denoising Using Blockwise Averaging.
`nlmeans_3d_classic`(arr[, mask, sigma, ...])	Non-local means for denoising 3D images
`remove_padding`(arr, padding)
`upfir`(image, h)	Upsamples the columns of the input image by 2, then applies the convolution kernel 'h' (again, columnwise).

Module: `denoise.enhancement_kernel`#

`EnhancementKernel`
`HemiSphere`(*[, x, y, z, theta, phi, xyz, ...])	Points on the unit sphere.
`Sphere`(*[, x, y, z, theta, phi, xyz, faces, ...])	Points on the unit sphere.
`ceil`(x, /)	Return the ceiling of x as an Integral.
`disperse_charges`(hemi, iters, *[, const])	Models electrostatic repulsion on the unit sphere
`get_sphere`(*[, name])	provide triangulated spheres
`gettempdir`()	Returns tempfile.tempdir as str.

Module: `denoise.gibbs`#

gibbs_removal(vol, *[, slice_axis, ...])

Suppresses Gibbs ringing artefacts of images volumes.

Module: `denoise.localpca`#

`dimensionality_problem_message`(arr, ...)	Message about the number of samples being smaller than one less the dimensionality of the data to be denoised.
`create_patch_radius_arr`(arr, pr)	Create the patch radius array from the data to be denoised and the patch radius.
`compute_patch_size`(patch_radius)	Compute patch size from the patch radius.
`compute_num_samples`(patch_size)	Compute the number of samples as the dot product of the elements.
`compute_suggested_patch_radius`(arr, patch_size)	Compute the suggested patch radius.
`genpca`(arr, *[, sigma, mask, patch_radius, ...])	General function to perform PCA-based denoising of diffusion datasets.
`localpca`(arr, *[, sigma, mask, ...])	Performs local PCA denoising.
`mppca`(arr, *[, mask, patch_radius, ...])	Performs PCA-based denoising using the Marcenko-Pastur distribution.

Module: `denoise.nlmeans`#

nlmeans(arr, sigma, *[, mask, patch_radius, ...])

Non-local means denoising for 3D and 4D images with selectable algorithms.

Module: `denoise.noise_estimate`#

`piesno`(data, N, *[, alpha, step, itermax, ...])	Probabilistic Identification and Estimation of Noise (PIESNO).
`estimate_sigma`(arr, *[, ...])	Standard deviation estimation from local patches

Module: `denoise.patch2self`#

`vol_denoise`(data_dict, b0_idx, dwi_idx, ...)	Denoise a single 3D volume using train and test phase.
`patch2self`(data, bvals, *[, patch_radius, ...])	Patch2Self Denoiser.

Module: `denoise.pca_noise_estimate`#

pca_noise_estimate(data, gtab[, ...])

PCA based local noise estimation.

Module: `denoise.shift_twist_convolution`#

`convolve`(odfs_sh, kernel, sh_order_max[, ...])	Perform the shift-twist convolution with the ODF data and the lookup-table of the kernel.
`convolve_sf`(odfs_sf, kernel[, test_mode, ...])	Perform the shift-twist convolution with the ODF data and the lookup-table of the kernel.
`deprecated_params`(old_name, *[, new_name, ...])	Deprecate a renamed or removed function argument.
`determine_num_threads`(num_threads)	Determine the effective number of threads to be used for OpenMP calls
`sf_to_sh`(sf, sphere, *[, sh_order_max, ...])	Spherical function to spherical harmonics (SH).
`sh_to_sf`(sh, sphere, *[, sh_order_max, ...])	Spherical harmonics (SH) to spherical function (SF).

compute_tukey_weights#

dipy.denoise._bias_correction.compute_tukey_weights(residuals, weights, *, c=4.685)#

Compute Tukey biweight weights and multiply into weights in-place.

Estimates the residual scale via the Median Absolute Deviation (MAD), then applies the Tukey bisquare function:

weights[i] *= (1 - (r_i / (c * MAD))^2)^2   if |r_i| < c * MAD
weights[i]  = 0                               otherwise

where MAD = median(|residuals|) / 0.6745.

Parameters:

residualsndarray: Regression residuals, C-contiguous float64, shape (N,).
weightsndarray: Existing per-voxel weights to update in-place, C-contiguous float64, shape (N,).
cfloat: Tukey breakdown constant. The default (4.685) gives 95 % efficiency under Gaussian noise.

Returns:

None: weights is modified in-place; nothing is returned.

evaluate_bspline_rows#

dipy.denoise._bias_correction.evaluate_bspline_rows(grid_coords, n_ctrl, row_ptr, col_idx, values)#

Evaluate cubic B-spline basis for N masked voxels, filling CSR arrays.

Parameters:

grid_coordsndarray: Voxel positions in control grid space, shape (N, 3), C-contiguous, dtype float64. Axis order is (z, y, x).
n_ctrlndarray: Control grid dimensions (ns, nr, nc), shape (3,), dtype int64.
row_ptrndarray: Output CSR row pointers, shape (N+1,), dtype int64. Pre-allocated; written in-place.
col_idxndarray: Output CSR column indices, shape (N*64,), dtype int64. Pre-allocated; written in-place.
valuesndarray: Output CSR non-zero values, shape (N*64,), dtype float64. Pre-allocated; written in-place.

Returns:

nnzint: Actual number of non-zero entries written to col_idx and values. Always <= N * 64.

gram_matrix_csr#

dipy.denoise._bias_correction.gram_matrix_csr(data, indices, indptr, weights, y, A, b_vec)#

Accumulate weighted Gram matrix and right-hand side from a CSR matrix.

Computes in-place:

A[j, k]   += sum_i  w_i * X[i,j] * X[i,k]
b_vec[k]  += sum_i  w_i * y_i    * X[i,k]

Rows with weights[i] == 0 are skipped.

Parameters:

datandarray: CSR non-zero values, shape (nnz,), dtype float64.
indicesndarray: CSR column indices, shape (nnz,), dtype int32.
indptrndarray: CSR row pointers, shape (N+1,), dtype int32.
weightsndarray: Per-row regression weights, shape (N,), dtype float64.
yndarray: Target values, shape (N,), dtype float64.
Andarray: K x K Gram matrix, pre-allocated zeros, shape (K, K), dtype float64. Updated in-place.
b_vecndarray: Right-hand side vector, pre-allocated zeros, shape (K,), dtype float64. Updated in-place.

Returns:

None: A and b_vec are modified in-place; nothing is returned.

masked_voxel_coords#

dipy.denoise._bias_correction.masked_voxel_coords(mask, out)#

Extract (i, j, k) voxel coordinates of all nonzero mask entries.

Parameters:

maskndarray: 3D uint8 mask, C-contiguous, shape (S, R, C).
outndarray: Pre-allocated output array, shape (N_max, 3), dtype int64. Filled with (i, j, k) coordinates of nonzero voxels in row-major order.

Returns:

countint: Number of nonzero voxels found (actual rows written to out).

adaptive_soft_matching#

dipy.denoise.adaptive_soft_matching.adaptive_soft_matching(ima, fimau, fimao, sigma)[source]#

Adaptive Soft Coefficient Matching

Combines two filtered 3D-images at different resolutions and the original image. Returns the resulting combined image.

Parameters:

imandarray: Original (unfiltered) image
fimau3D double array,: filtered image with optimized non-local means using a small block (suggested:3x3), which corresponds to a “high resolution” filter.
fimao3D double array,: filtered image with optimized non-local means using a small block (suggested:5x5), which corresponds to a “low resolution” filter.
sigmathe estimated standard deviation of the Gaussian random variables: that explain the rician noise. Note: In [1] the rician noise was simulated as sqrt((f+x)^2 + (y)^2) where f is the pixel value and x and y are independent realizations of a random variable with Normal distribution, with mean=0 and standard deviation=h

Returns:

fima3D double array: output denoised array which is of the same shape as that of the input

References

polynomial_bias_field_dwi#

dipy.denoise.bias_correction.polynomial_bias_field_dwi(data, gtab, *, mask=None, order=3, pyramid_levels=(4, 2, 1), n_iter=4, lambda_reg=0.001, robust=True, gradient_weighting=True, zero_background=False)[source]#

DWI bias field correction via multi-resolution Legendre polynomial regression.

Estimates the bias field from the mean b0 volume in log space using coarse-to-fine Legendre polynomial regression, then applies the estimated field to all DWI volumes.

Parameters:

datandarray: 4D DWI data (X, Y, Z, N).
gtabGradientTable: Gradient table.
maskndarray, optional: 3D binary brain mask. Auto-computed via median_otsu if None.
orderint, optional: Maximum Legendre polynomial order (terms where i+j+k <= order).
pyramid_levelstuple of int, optional: Downsampling factors for coarse-to-fine pyramid (descending order).
n_iterint, optional: Reweighting iterations per pyramid level.
lambda_regfloat, optional: Ridge regularization strength.
robustbool, optional: Apply Tukey biweight robust reweighting.
gradient_weightingbool, optional: Apply gradient-based edge suppression.
zero_backgroundbool, optional: If True, set the bias field to 1.0 (no correction) outside the brain mask. If False, the raw extrapolated field values are preserved in the returned bias_field array. Has no effect on the corrected DWI data (background voxels are always zeroed by the brain mask).

Returns:

correctedndarray: Bias-corrected 4D DWI data, same dtype as input.
bias_fieldndarray: Estimated 3D multiplicative bias field.

bias_field_correction#

dipy.denoise.bias_correction.bias_field_correction(data, gtab, *, mask=None, method='bspline', order=3, n_control_points=(8, 8, 8), pyramid_levels=(4, 2, 1), n_iter=4, lambda_reg=0.001, robust=True, gradient_weighting=True, return_bias_field=False, zero_background=False)[source]#

Top-level DWI bias field correction via regression.

Estimates a smooth multiplicative bias field from the mean b0 volume using polynomial or B-spline regression in log space, then applies the correction uniformly to all DWI volumes.

Parameters:

datandarray

4D DWI data (X, Y, Z, N).

gtabGradientTable

Gradient table.

maskndarray, optional

3D binary brain mask. If None, computed via median_otsu.

methodstr, optional

Bias correction method:

"poly": Legendre polynomial regression — fast, low-parameter.
"bspline": Cubic B-spline regression — more flexible.
"auto": Run both methods and return the one with lower Coefficient of Variation within the brain mask. The chosen method is logged at INFO level.

orderint, optional

Maximum Legendre polynomial degree (used only for method=”poly”).

n_control_pointstuple of int, optional

Control grid dimensions at finest level (used only for method=”bspline”).

pyramid_levelstuple of int, optional

Downsampling factors for coarse-to-fine pyramid (descending order).

n_iterint, optional

Reweighting iterations per pyramid level.

lambda_regfloat, optional

Ridge regularization strength.

robustbool, optional

Apply Tukey biweight robust reweighting at each level.

gradient_weightingbool, optional

Weight regression by edge-suppression map derived from the image gradient.

return_bias_fieldbool, optional

If True, return the bias field alongside the corrected data.

zero_backgroundbool, optional

If True, set the bias field to 1.0 (no correction) outside the brain mask. If False, the raw extrapolated field values are preserved in the returned bias_field array. Has no effect on the corrected DWI data (background voxels are always zeroed by the brain mask).

Returns:

correctedndarray: Bias-corrected DWI, same dtype as input.
bias_fieldndarray: 3D multiplicative bias field (only returned if return_bias_field=True).

add_padding_reflection#

dipy.denoise.denspeed.add_padding_reflection(arr, padding)#

correspond_indices#

dipy.denoise.denspeed.correspond_indices(dim_size, padding)#

determine_num_threads#

dipy.denoise.denspeed.determine_num_threads(num_threads)#

Determine the effective number of threads to be used for OpenMP calls

For num_threads = None, - if the OMP_NUM_THREADS environment variable is set, return that value - otherwise, return the maximum number of cores retrieved by openmp.opm_get_num_procs().
For num_threads > 0, return this value.
For num_threads < 0, return the maximal number of threads minus |num_threads + 1|. In particular num_threads = -1 will use as many threads as there are available cores on the machine.
For num_threads = 0 a ValueError is raised.

Parameters:

num_threadsint or None: Desired number of threads to be used.

firdn#

dipy.denoise.denspeed.firdn(image, h)#

Applies the filter given by the convolution kernel ‘h’ columnwise to ‘image’, then subsamples by 2. This is a special case of the matlab’s ‘upfirdn’ function, ported to python. Returns the filtered image.

Parameters:

image: 2D array of doubles: the input image to be filtered
h: double array: the convolution kernel

nlmeans_3d#

dipy.denoise.denspeed.nlmeans_3d(arr, mask=None, sigma=None, patch_radius=1, block_radius=5, rician=True, num_threads=None, method='classic')#

Non-local means for denoising 3D images with selectable algorithm

Parameters:

arr3D ndarray: The array to be denoised
mask3D ndarray
sigmafloat or 3D array: standard deviation of the noise estimated from the data
patch_radiusint: patch size is 2 x patch_radius + 1. Default is 1.
block_radiusint: block size is 2 x block_radius + 1. Default is 5.
ricianboolean: If True the noise is estimated as Rician, otherwise Gaussian noise is assumed.
num_threadsint, optional: Number of threads to be used for OpenMP parallelization. If None (default) the value of OMP_NUM_THREADS environment variable is used if it is set, otherwise all available threads are used. If < 0 the maximal number of threads minus \(|num_threads + 1|\) is used (enter -1 to use as many threads as possible). 0 raises an error.
methodstr, optional: Algorithm method to use. ‘classic’ for original algorithm, ‘blockwise’ for improved blockwise algorithm. Default is ‘classic’.

Returns:

denoised_arrndarray: the denoised arr which has the same shape as arr.

nlmeans_3d_blockwise#

dipy.denoise.denspeed.nlmeans_3d_blockwise(image, mask, patch_radius, block_radius, noise_sigma, is_rician, num_threads=None)#

Non-Local Means Denoising Using Blockwise Averaging.

This implementation uses efficient memory management and parallel processing for high-performance denoising of 3D images.

See [2] and [1] for further details about the method.

Parameters:

image3D array of doubles, shape (height, width, depth): Input image corrupted with noise. Uses standard array indexing [y, x, z].
mask3D array of doubles, shape (height, width, depth): Binary mask indicating which voxels to process (1) or skip (0).
patch_radiusint: Radius for local patch comparisons. Search is performed within a (2*patch_radius + 1)^3 neighborhood around each voxel.
block_radiusint: Radius for the blocks used in weighted averaging. Each block has size (2*block_radius + 1)^3.
noise_sigmadouble: Estimated noise standard deviation in the input image.
is_ricianint: 1 if Rician noise model should be used, 0 for Gaussian noise model.
num_threadsint, optional: Number of OpenMP threads to use. If None, uses all available threads.

Returns:

denoised_image3D array of doubles: Denoised output image with the same shape as input.

References

nlmeans_3d_classic#

dipy.denoise.denspeed.nlmeans_3d_classic(arr, mask=None, sigma=None, patch_radius=1, block_radius=5, rician=True, num_threads=None)#

Non-local means for denoising 3D images

Parameters:

arr3D ndarray: The array to be denoised
mask3D ndarray
sigmafloat or 3D array: standard deviation of the noise estimated from the data
patch_radiusint: patch size is 2 x patch_radius + 1. Default is 1.
block_radiusint: block size is 2 x block_radius + 1. Default is 5.
ricianboolean: If True the noise is estimated as Rician, otherwise Gaussian noise is assumed.
num_threadsint, optional: Number of threads to be used for OpenMP parallelization. If None (default) the value of OMP_NUM_THREADS environment variable is used if it is set, otherwise all available threads are used. If < 0 the maximal number of threads minus \(|num_threads + 1|\) is used (enter -1 to use as many threads as possible). 0 raises an error.

Returns:

denoised_arrndarray: the denoised arr which has the same shape as arr.

remove_padding#

dipy.denoise.denspeed.remove_padding(arr, padding)#

upfir#

dipy.denoise.denspeed.upfir(image, h)#

Upsamples the columns of the input image by 2, then applies the convolution kernel ‘h’ (again, columnwise). This is a special case of the matlab’s ‘upfirdn’ function, ported to python. Returns the filtered image.

Parameters:

image: 2D array of doubles: the input image to be filtered
h: double array: the convolution kernel

`EnhancementKernel`#

class dipy.denoise.enhancement_kernel.EnhancementKernel#

Bases: object

Methods

`evaluate_kernel`(x, y, r, v)	Evaluate the kernel at position x relative to position y, with orientation r relative to orientation v.
`get_lookup_table`()	Return the computed look-up table.
`get_orientations`()	Return the orientations.
`get_sphere`()	Get the sphere corresponding with the orientations

evaluate_kernel(x, y, r, v)#

Evaluate the kernel at position x relative to position y, with orientation r relative to orientation v.

Parameters:

x1D ndarray: Position x
y1D ndarray: Position y
r1D ndarray: Orientation r
v1D ndarray: Orientation v

Returns:

kernel_valuedouble

get_lookup_table()#: Return the computed look-up table.

get_orientations()#: Return the orientations.

get_sphere()#: Get the sphere corresponding with the orientations

`HemiSphere`#

class dipy.denoise.enhancement_kernel.HemiSphere(*, x=None, y=None, z=None, theta=None, phi=None, xyz=None, faces=None, edges=None, tol=1e-05)[source]#

Bases: Sphere

Points on the unit sphere.

A HemiSphere is similar to a Sphere but it takes antipodal symmetry into account. Antipodal symmetry means that point v on a HemiSphere is the same as the point -v. Duplicate points are discarded when constructing a HemiSphere (including antipodal duplicates). edges and faces are remapped to the remaining points as closely as possible.

The HemiSphere can be constructed using one of three conventions:

HemiSphere(x, y, z)
HemiSphere(xyz=xyz)
HemiSphere(theta=theta, phi=phi)

Parameters:

x, y, z1-D array_like: Vertices as x-y-z coordinates.
theta, phi1-D array_like: Vertices as spherical coordinates. Theta and phi are the inclination and azimuth angles respectively.
xyz(N, 3) ndarray: Vertices as x-y-z coordinates.
faces(N, 3) ndarray: Indices into vertices that form triangular faces. If unspecified, the faces are computed using a Delaunay triangulation.
edges(N, 2) ndarray: Edges between vertices. If unspecified, the edges are derived from the faces.
tolfloat: Angle in degrees. Vertices that are less than tol degrees apart are treated as duplicates.

Attributes:

x
y
z

Methods

`find_closest`(xyz)	Find the index of the vertex in the Sphere closest to the input vector, taking into account antipodal symmetry
`from_sphere`(sphere, *[, tol])	Create instance from a Sphere
`mirror`()	Create a full Sphere from a HemiSphere
`subdivide`(*[, n])	Create a more subdivided HemiSphere

edges
faces
vertices

`Sphere`#

class dipy.denoise.enhancement_kernel.Sphere(*, x=None, y=None, z=None, theta=None, phi=None, xyz=None, faces=None, edges=None)[source]#

Bases: object

Points on the unit sphere.

The sphere can be constructed using one of three conventions:

Sphere(x, y, z)
Sphere(xyz=xyz)
Sphere(theta=theta, phi=phi)

Parameters:

x, y, z1-D array_like: Vertices as x-y-z coordinates.
theta, phi1-D array_like: Vertices as spherical coordinates. Theta and phi are the inclination and azimuth angles respectively.
xyz(N, 3) ndarray: Vertices as x-y-z coordinates.
faces(N, 3) ndarray: Indices into vertices that form triangular faces. If unspecified, the faces are computed using a Delaunay triangulation.
edges(N, 2) ndarray: Edges between vertices. If unspecified, the edges are derived from the faces.

Attributes:

x
y
z

Methods

`find_closest`(xyz)	Find the index of the vertex in the Sphere closest to the input vector
`subdivide`(*[, n])	Subdivides each face of the sphere into four new faces.

edges
faces
vertices

find_closest(xyz)[source]#

Find the index of the vertex in the Sphere closest to the input vector

Parameters:

xyzarray-like, 3 elements: A unit vector

Returns:

idxint: The index into the Sphere.vertices array that gives the closest vertex (in angle).

subdivide(*, n=1)[source]#

Subdivides each face of the sphere into four new faces.

New vertices are created at a, b, and c. Then each face [x, y, z] is divided into faces [x, a, c], [y, a, b], [z, b, c], and [a, b, c].

      y
      /\
     /  \
   a/____\b
   /\    /\
  /  \  /  \
 /____\/____\
x      c     z

Parameters:

nint, optional: The number of subdivisions to perform.

Returns:

new_sphereSphere: The subdivided sphere.

ceil#

dipy.denoise.enhancement_kernel.ceil(x, /)#

Return the ceiling of x as an Integral.

This is the smallest integer >= x.

disperse_charges#

dipy.denoise.enhancement_kernel.disperse_charges(hemi, iters, *, const=0.2)[source]#

Models electrostatic repulsion on the unit sphere

Places charges on a sphere and simulates the repulsive forces felt by each one. Allows the charges to move for some number of iterations and returns their final location as well as the total potential of the system at each step.

Parameters:

hemiHemiSphere: Points on a unit sphere.
itersint: Number of iterations to run.
constfloat: Using a smaller const could provide a more accurate result, but will need more iterations to converge.

Returns:

hemiHemiSphere: Distributed points on a unit sphere.
potentialndarray: The electrostatic potential at each iteration. This can be useful to check if the repulsion converged to a minimum.

Notes

This function is meant to be used with diffusion imaging so antipodal symmetry is assumed. Therefore, each charge must not only be unique, but if there is a charge at +x, there cannot be a charge at -x. These are treated as the same location and because the distance between the two charges will be zero, the result will be unstable.

get_sphere#

dipy.denoise.enhancement_kernel.get_sphere(*, name='symmetric362')[source]#

provide triangulated spheres

Parameters:

namestr: which sphere - one of: * ‘symmetric362’ * ‘symmetric642’ * ‘symmetric724’ * ‘repulsion724’ * ‘repulsion100’ * ‘repulsion200’

Returns:

spherea dipy.core.sphere.Sphere class instance

Examples

>>> import numpy as np
>>> from dipy.data import get_sphere
>>> sphere = get_sphere(name="symmetric362")
>>> verts, faces = sphere.vertices, sphere.faces
>>> verts.shape == (362, 3)
True
>>> faces.shape == (720, 3)
True
>>> verts, faces = get_sphere(name="not a sphere name")
Traceback (most recent call last):
    ...
DataError: No sphere called "not a sphere name"

gettempdir#

dipy.denoise.enhancement_kernel.gettempdir()[source]#: Returns tempfile.tempdir as str.

gibbs_removal#

dipy.denoise.gibbs.gibbs_removal(vol, *, slice_axis=2, n_points=3, inplace=True, num_processes=1)[source]#

Suppresses Gibbs ringing artefacts of images volumes.

See [3] and [4] for further details about the method.

Parameters:

volndarray ([X, Y]), ([X, Y, Z]) or ([X, Y, Z, g]): Matrix containing one volume (3D) or multiple (4D) volumes of images.
slice_axisint (0, 1, or 2): Data axis corresponding to the number of acquired slices.
n_pointsint, optional: Number of neighbour points to access local TV (see note).
inplacebool, optional: If True, the input data is replaced with results. Otherwise, returns a new array.
num_processesint or None, optional: Split the calculation to a pool of children processes. This only applies to 3D or 4D data arrays. Default is 1. If < 0 the maximal number of cores minus num_processes + 1 is used (enter -1 to use as many cores as possible). 0 raises an error.

Returns:

volndarray ([X, Y]), ([X, Y, Z]) or ([X, Y, Z, g]): Matrix containing one volume (3D) or multiple (4D) volumes of corrected images.

Notes

For 4D matrix last element should always correspond to the number of diffusion gradient directions.

References

dimensionality_problem_message#

dipy.denoise.localpca.dimensionality_problem_message(arr, num_samples, spr)[source]#

Message about the number of samples being smaller than one less the dimensionality of the data to be denoised.

Parameters:

arrndarray: Data to be denoised.
num_samplesint: Number of samples.
sprint: Suggested patch radius.

Returns:

str: Message.

create_patch_radius_arr#

dipy.denoise.localpca.create_patch_radius_arr(arr, pr)[source]#

Create the patch radius array from the data to be denoised and the patch radius.

Parameters:

arrndarray: Data to be denoised.
print or ndarray: Patch radius.

Returns:

patch_radiusndarray: Number of samples.

compute_patch_size#

dipy.denoise.localpca.compute_patch_size(patch_radius)[source]#

Compute patch size from the patch radius.

it is twice the radius plus one.

Parameters:

patch_radiusndarray: Patch radius.

Returns:

int: Number of samples.

compute_num_samples#

dipy.denoise.localpca.compute_num_samples(patch_size)[source]#

Compute the number of samples as the dot product of the elements.

Parameters:

patch_sizendarray: Patch size.

Returns:

int: Number of samples.

compute_suggested_patch_radius#

dipy.denoise.localpca.compute_suggested_patch_radius(arr, patch_size)[source]#

Compute the suggested patch radius.

Parameters:

arrndarray: Data to be denoised.
patch_sizendarray: Patch size.

Returns:

int: Suggested patch radius.

genpca#

dipy.denoise.localpca.genpca(arr, *, sigma=None, mask=None, patch_radius=2, pca_method='eig', tau_factor=None, return_sigma=False, out_dtype=None, suppress_warning=False)[source]#

General function to perform PCA-based denoising of diffusion datasets.

Parameters:

arr4D array

Array of data to be denoised. The dimensions are (X, Y, Z, N), where N are the diffusion gradient directions. The first 3 dimension must have size >= 2 * patch_radius + 1 or size = 1.

sigmafloat or 3D array, optional

Standard deviation of the noise estimated from the data. If no sigma is given, this will be estimated based on random matrix theory [5], [6].

mask3D boolean array, optional

A mask with voxels that are true inside the brain and false outside of it. The function denoises within the true part and returns zeros outside of those voxels.

patch_radiusint or 1D array, optional

The radius of the local patch to be taken around each voxel (in voxels). E.g. patch_radius=2 gives 5x5x5 patches.

pca_method‘eig’ or ‘svd’, optional

Use either eigenvalue decomposition (eig) or singular value decomposition (svd) for principal component analysis. The default method is ‘eig’ which is faster. However, occasionally ‘svd’ might be more accurate.

tau_factorfloat, optional

Thresholding of PCA eigenvalues is done by nulling out eigenvalues that are smaller than:

\[\tau = (\tau_{factor} \sigma)^2\]

\(\tau_{factor}\) can be set to a predefined values (e.g. \(\tau_{factor} = 2.3\) [7]), or automatically calculated using random matrix theory (in case that \(\tau_{factor}\) is set to None).

return_sigmabool, optional

If true, the Standard deviation of the noise will be returned.

out_dtypestr or dtype, optional

The dtype for the output array. Default: output has the same dtype as the input.

suppress_warningbool, optional

If true, suppress warning caused by patch_size < arr.shape[-1].

Returns:

denoised_arr4D array: This is the denoised array of the same size as that of the input data, clipped to non-negative values.

References

localpca#

dipy.denoise.localpca.localpca(arr, *, sigma=None, mask=None, patch_radius=2, gtab=None, patch_radius_sigma=1, pca_method='eig', tau_factor=2.3, return_sigma=False, correct_bias=True, out_dtype=None, suppress_warning=False)[source]#

Performs local PCA denoising.

The method follows the algorithm in Manjón et al.[7].

Parameters:

arr4D array

Array of data to be denoised. The dimensions are (X, Y, Z, N), where N are the diffusion gradient directions.

sigmafloat or 3D array, optional

Standard deviation of the noise estimated from the data. If not given, calculate using method in Manjón et al.[7].

mask3D boolean array, optional

A mask with voxels that are true inside the brain and false outside of it. The function denoises within the true part and returns zeros outside of those voxels.

patch_radiusint or 1D array, optional

The radius of the local patch to be taken around each voxel (in voxels). E.g. patch_radius=2 gives 5x5x5 patches.

gtab: gradient table object (optional if sigma is provided)

gradient information for the data gives us the bvals and bvecs of diffusion data, which is needed to calculate noise level if sigma is not provided.

patch_radius_sigmaint, optional

The radius of the local patch to be taken around each voxel (in voxels) for estimating sigma. E.g. patch_radius_sigma=2 gives 5x5x5 patches.

pca_method‘eig’ or ‘svd’, optional

Use either eigenvalue decomposition (eig) or singular value decomposition (svd) for principal component analysis. The default method is ‘eig’ which is faster. However, occasionally ‘svd’ might be more accurate.

tau_factorfloat, optional

Thresholding of PCA eigenvalues is done by nulling out eigenvalues that are smaller than:

\[\tau = (\tau_{factor} \sigma)^2\]

tau_{factor} can be change to adjust the relationship between the noise standard deviation and the threshold tau. If tau_{factor} is set to None, it will be automatically calculated using the Marcenko-Pastur distribution [6]. Default: 2.3 according to Manjón et al.[7].

return_sigmabool, optional

If true, a noise standard deviation estimate based on the Marcenko-Pastur distribution is returned [6].

correct_biasbool, optional

Whether to correct for bias due to Rician noise. This is an implementation of equation 8 in [7].

out_dtypestr or dtype, optional

The dtype for the output array. Default: output has the same dtype as the input.

suppress_warningbool, optional

If true, suppress warning caused by patch_size < arr.shape[-1].

Returns:

denoised_arr4D array: This is the denoised array of the same size as that of the input data, clipped to non-negative values

References

mppca#

dipy.denoise.localpca.mppca(arr, *, mask=None, patch_radius=2, pca_method='eig', return_sigma=False, out_dtype=None, suppress_warning=False)[source]#

Performs PCA-based denoising using the Marcenko-Pastur distribution.

See [6] for further details about the method.

Parameters:

arr4D array: Array of data to be denoised. The dimensions are (X, Y, Z, N), where N are the diffusion gradient directions.
mask3D boolean array, optional: A mask with voxels that are true inside the brain and false outside of it. The function denoises within the true part and returns zeros outside of those voxels.
patch_radiusint or 1D array, optional: The radius of the local patch to be taken around each voxel (in voxels). E.g. patch_radius=2 gives 5x5x5 patches.
pca_method‘eig’ or ‘svd’, optional: Use either eigenvalue decomposition (eig) or singular value decomposition (svd) for principal component analysis. The default method is ‘eig’ which is faster. However, occasionally ‘svd’ might be more accurate.
return_sigmabool, optional: If true, a noise standard deviation estimate based on the Marcenko-Pastur distribution is returned [5].
out_dtypestr or dtype, optional: The dtype for the output array. Default: output has the same dtype as the input.
suppress_warningbool, optional: If true, suppress warning caused by patch_size < arr.shape[-1].

Returns:

denoised_arr4D array: This is the denoised array of the same size as that of the input data, clipped to non-negative values
sigma3D array (when return_sigma=True): Estimate of the spatial varying standard deviation of the noise

References

nlmeans#

dipy.denoise.nlmeans.nlmeans(arr, sigma, *, mask=None, patch_radius=1, block_radius=None, rician=True, num_threads=None, method='blockwise')[source]#

Non-local means denoising for 3D and 4D images with selectable algorithms.

This implementation provides two different algorithms for non-local means denoising: the classic approach and an improved blockwise algorithm. The blockwise method offers better coordinate handling, memory efficiency, and performance through advanced parallelization and statistical pre-filtering.

See [8] for further details about the classic method. See [2] and [1] for further details about the blockwise method.

Parameters:

arr3D or 4D ndarray

The array to be denoised. For 3D arrays, shape should be (height, width, depth). For 4D arrays, shape should be (height, width, depth, volumes) where the last dimension represents different volumes (e.g., DWI directions).

sigmafloat or 1D ndarray

Standard deviation of the noise estimated from the data. For 3D arrays, this should be a scalar. For 4D arrays, this can be either a scalar (same noise level for all volumes) or a 1D array with length equal to the number of volumes.

mask3D ndarray, optional

Binary mask indicating which voxels to process. Should have shape (height, width, depth). Voxels with mask value 0 are set to 0 in output. If None, all voxels are processed.

patch_radiusint, optional

Radius for similarity search neighborhoods. Patches of size (2*patch_radius + 1)³ around each voxel are compared to find similar structures.

block_radiusint, optional

Radius for weighted averaging blocks. Each block has size (2*block_radius + 1)³. Larger blocks provide more smoothing but increase computational cost. If None, defaults are:

method=’classic’: 5 (11*11*11 blocks)
method=’blockwise’: 2 (5*5*5 blocks)

ricianbool, optional

If True, assumes Rician noise model (appropriate for magnitude MRI data). If False, assumes Gaussian noise model.

num_threadsint, optional

Number of OpenMP threads to use for parallel processing. If None, uses all available CPU threads. Set to 1 to disable parallel processing.

methodstr, optional

Algorithm method to use:

‘blockwise’: Improved algorithm with better coordinate handling, memory efficiency, and statistical pre-filtering
‘classic’: Original algorithm with traditional implementation

Added in version 1.12.0.

Returns:

denoised_arrndarray: The denoised array with the same shape and dtype as the input arr. Values are clipped to non-negative range for Rician noise model.

Notes

Due to coordinate bug fixes in the blockwise method, equivalent denoising quality may require different parameters between methods: - Classic patch_radius=3 ≈ Blockwise patch_radius=2 - Block_radius can be smaller for blockwise due to efficiency improvements

References

Examples

>>> import numpy as np
>>> from dipy.denoise.nlmeans import nlmeans
>>> # Create synthetic noisy data
>>> clean_data = np.random.rand(50, 50, 50) * 100
>>> noisy_data = clean_data + np.random.randn(50, 50, 50) * 10
>>> # Denoise a 3D image with default blockwise method
>>> denoised_data = nlmeans(noisy_data, sigma=10.0)
>>> # Use classic method for compatibility:
>>> denoised_classic = nlmeans(noisy_data, sigma=10.0, method='classic')
>>> # Denoise 4D DWI data with different noise levels per volume:
>>> dwi_data = np.random.rand(64, 64, 40, 30) * 1000  # 30 DWI directions
>>> noise_levels = np.linspace(50, 100, 30)  # Varying noise
>>> denoised_dwi = nlmeans(dwi_data, sigma=noise_levels)

piesno#

dipy.denoise.noise_estimate.piesno(data, N, *, alpha=0.01, step=100, itermax=100, eps=1e-05, return_mask=False)[source]#

Probabilistic Identification and Estimation of Noise (PIESNO).

See [9] and [10] for further details about the method.

Parameters:

datandarray: The magnitude signals to analyse. The last dimension must contain the same realisation of the volume, such as dMRI or fMRI data.
Nint: The number of phase array coils of the MRI scanner. If your scanner does a SENSE reconstruction, ALWAYS use N=1, as the noise profile is always Rician. If your scanner does a GRAPPA reconstruction, set N as the number of phase array coils.
alphafloat: Probabilistic estimation threshold for the gamma function.
stepint: number of initial estimates for sigma to try.
itermaxint: Maximum number of iterations to execute if convergence is not reached.
epsfloat: Tolerance for the convergence criterion. Convergence is reached if two subsequent estimates are smaller than eps.
return_maskbool: If True, return a mask identifying all the pure noise voxel that were found.

Returns:

sigmafloat: The estimated standard deviation of the gaussian noise.
maskndarray, optional: A boolean mask indicating the voxels identified as pure noise.

Notes

This function assumes two things : 1. The data has a noisy, non-masked background and 2. The data is a repetition of the same measurements along the last axis, i.e. dMRI or fMRI data, not structural data like T1/T2.

This function processes the data slice by slice, as originally designed in the paper. Use it to get a slice by slice estimation of the noise, as in spinal cord imaging for example.

References

estimate_sigma#

dipy.denoise.noise_estimate.estimate_sigma(arr, *, disable_background_masking=False, N=0)[source]#

Standard deviation estimation from local patches

Parameters:

arr3D or 4D ndarray: The array to be estimated
disable_background_maskingbool, optional: If True, uses all voxels for the estimation, otherwise, only non-zeros voxels are used. Useful if the background is masked by the scanner.
Nint, optional: Number of coils of the receiver array. Use N = 1 in case of a SENSE reconstruction (Philips scanners) or the number of coils for a GRAPPA reconstruction (Siemens and GE). Use 0 to disable the correction factor, as for example if the noise is Gaussian distributed. See [11] for more information.

Returns:

sigmandarray: standard deviation of the noise, one estimation per volume.

Notes

This function is the same as manually taking the standard deviation of the background and gives one value for the whole 3D array. It also includes the coil-dependent correction factor from Koay and Basser[11] (see equation 18 in [11]) with theta = 0. Since this function was introduced in [2] for T1 imaging, it is expected to perform ok on diffusion MRI data, but might oversmooth some regions and leave others un-denoised for spatially varying noise profiles. Consider using piesno() to estimate sigma instead if visual inaccuracies are apparent in the denoised result.

References

vol_denoise#

dipy.denoise.patch2self.vol_denoise(data_dict, b0_idx, dwi_idx, model, alpha, b0_denoising, verbose, tmp_dir)[source]#

Denoise a single 3D volume using train and test phase.

Parameters:

data_dictdict

Dictionary containing the following:

data_namestr: The name of the memmap file containing the memmaped data.
data_dtypedtype: The dtype of the data.
data_shapetuple: The shape of the data.
data_b0sndarray: Array of all 3D patches flattened out to be 2D for b0 volumes.
data_dwindarray: Array of all 3D patches flattened out to be 2D for dwi volumes.

b0_idxndarray

The indices of the b0 volumes.

dwi_idxndarray

The indices of the dwi volumes.

modelsklearn.base.RegressorMixin

This is the model that is initialized from the _fit_denoising_model function.

alphafloat

Regularization parameter only for ridge and lasso regression models.

b0_denoisingbool

Skips denoising b0 volumes if set to False.

verbosebool

Show progress of Patch2Self and time taken.

tmp_dirstr

The directory to save the temporary files.

Returns:

denoised_arr.namestr: The name of the memmap file containing the denoised array.
denoised_arr.dtypedtype: The dtype of the denoised array.
denoised_arr.shapetuple: The shape of the denoised array.

patch2self#

dipy.denoise.patch2self.patch2self(data, bvals, *, patch_radius=(0, 0, 0), model='ols', b0_threshold=50, out_dtype=None, alpha=1.0, verbose=False, b0_denoising=True, clip_negative_vals=False, shift_intensity=True, tmp_dir=None, version=3)[source]#

Patch2Self Denoiser.

See [12] for further details about the method. See [13] for further details about the new method.

Parameters:

datandarray: The 4D noisy DWI data to be denoised.
bvalsarray of shape (N,): Array of the bvals from the DWI acquisition
patch_radiusint or array of shape (3,), optional: The radius of the local patch to be taken around each voxel (in voxels).
modelstring, or sklearn.base.RegressorMixin, optional: This will determine the algorithm used to solve the set of linear equations underlying this model. If it is a string it needs to be one of the following: {‘ols’, ‘ridge’, ‘lasso’}. Otherwise, it can be an object that inherits from dipy.optimize.SKLearnLinearSolver or an object with a similar interface from Scikit-Learn: sklearn.linear_model.LinearRegression, sklearn.linear_model.Lasso or sklearn.linear_model.Ridge and other objects that inherit from sklearn.base.RegressorMixin.
b0_thresholdint, optional: Threshold for considering volumes as b0.
out_dtypestr or dtype, optional: The dtype for the output array. Default: output has the same dtype as the input.
alphafloat, optional: Regularization parameter only for ridge regression model.
verbosebool, optional: Show progress of Patch2Self and time taken.
b0_denoisingbool, optional: Skips denoising b0 volumes if set to False.
clip_negative_valsbool, optional: Sets negative values after denoising to 0 using np.clip.
shift_intensitybool, optional: Shifts the distribution of intensities per volume to give non-negative values.
tmp_dirstr, optional: The directory to save the temporary files. If None, the temporary files are saved in the system’s default temporary directory.
versionint, optional: Version 1 or 3 of Patch2Self to use.

Returns:

denoised arrayndarray: This is the denoised array of the same size as that of the input data, clipped to non-negative values.

References

pca_noise_estimate#

dipy.denoise.pca_noise_estimate.pca_noise_estimate(data, gtab, patch_radius=1, correct_bias=True, smooth=2, images_as_samples=False)#

PCA based local noise estimation.

Parameters:

data4D array: the input dMRI data. The first 3 dimension must have size >= 2 * patch_radius + 1 or size = 1.
gtabgradient table object: gradient information for the data gives us the bvals and bvecs of diffusion data, which is needed here to select between the noise estimation methods.
patch_radiusint: The radius of the local patch to be taken around each voxel (in voxels). Default: 1 (estimate noise in blocks of 3x3x3 voxels).
correct_biasbool: Whether to correct for bias due to Rician noise. This is an implementation of equation 8 in [7].
smoothint: Radius of a Gaussian smoothing filter to apply to the noise estimate before returning. Default: 2.
images_as_samplesbool, optional: Whether to use images as rows (samples) for PCA (algorithm in [7]) or to use images as columns (features).

Returns:

sigma_corr: 3D array: The local noise standard deviation estimate.

Notes

In [7], images are used as samples, so voxels are features, therefore eigenvectors are image-shaped. However, Manjón et al.[7] is not clear on how to use these eigenvectors to determine the noise level, so here eigenvalues (variance over samples explained by eigenvectors) are used to scale the eigenvectors. Use images_as_samples=True to use this algorithm. Alternatively, voxels can be used as samples using images_as_samples=False. This is not the canonical algorithm of Manjón et al.[7].

References

convolve#

dipy.denoise.shift_twist_convolution.convolve(odfs_sh, kernel, sh_order_max, test_mode=False, num_threads=None, normalize=True)#

Perform the shift-twist convolution with the ODF data and the lookup-table of the kernel.

See [14], [15], [16] and [17] for further details about the method.

Parameters:

odfsarray of double: The ODF data in spherical harmonics format
kernelarray of double: The 5D lookup table
sh_order_maxinteger: Maximal spherical harmonics order (l)
test_modeboolean: Reduced convolution in one direction only for testing
num_threadsint, optional: Number of threads to be used for OpenMP parallelization. If None (default) the value of OMP_NUM_THREADS environment variable is used if it is set, otherwise all available threads are used. If < 0 the maximal number of threads minus \(|num_threads + 1|\) is used (enter -1 to use as many threads as possible). 0 raises an error.
normalizeboolean: Apply max-normalization to the output such that its value range matches the input ODF data.

Returns:

outputarray of double: The ODF data after convolution enhancement in spherical harmonics format

References

convolve_sf#

dipy.denoise.shift_twist_convolution.convolve_sf(odfs_sf, kernel, test_mode=False, num_threads=None, normalize=True)#

Perform the shift-twist convolution with the ODF data and the lookup-table of the kernel.

Parameters:

odfsarray of double: The ODF data sampled on a sphere
kernelarray of double: The 5D lookup table
test_modeboolean: Reduced convolution in one direction only for testing
num_threadsint, optional: Number of threads to be used for OpenMP parallelization. If None (default) the value of OMP_NUM_THREADS environment variable is used if it is set, otherwise all available threads are used. If < 0 the maximal number of threads minus \(|num_threads + 1|\) is used (enter -1 to use as many threads as possible). 0 raises an error.
normalizeboolean: Apply max-normalization to the output such that its value range matches the input ODF data.

Returns:

outputarray of double: The ODF data after convolution enhancement, sampled on a sphere

deprecated_params#

dipy.denoise.shift_twist_convolution.deprecated_params(old_name, *, new_name=None, since='', until='', version_comparator=<function cmp_pkg_version>, arg_in_kwargs=False, warn_class=<class 'dipy.utils.deprecator.ArgsDeprecationWarning'>, error_class=<class 'dipy.utils.deprecator.ExpiredDeprecationError'>, alternative='')[source]#

Deprecate a renamed or removed function argument.

The decorator assumes that the argument with the old_name was removed from the function signature and the new_name replaced it at the same position in the signature. If the old_name argument is given when calling the decorated function the decorator will catch it and issue a deprecation warning and pass it on as new_name argument.

Parameters:

old_namestr or list/tuple thereof: The old name of the argument.
new_namestr or list/tuple thereof or None, optional: The new name of the argument. Set this to None to remove the argument old_name instead of renaming it.
sincestr or number or list/tuple thereof, optional: The release at which the old argument became deprecated.
untilstr or number or list/tuple thereof, optional: Last released version at which this function will still raise a deprecation warning. Versions higher than this will raise an error.
version_comparatorcallable: Callable accepting string as argument, and return 1 if string represents a higher version than encoded in the version_comparator, 0 if the version is equal, and -1 if the version is lower. For example, the version_comparator may compare the input version string to the current package version string.
arg_in_kwargsbool or list/tuple thereof, optional: If the argument is not a named argument (for example it was meant to be consumed by **kwargs) set this to True. Otherwise the decorator will throw an Exception if the new_name cannot be found in the signature of the decorated function. Default is False.
warn_classwarning, optional: Warning to be issued.
error_classException, optional: Error to be issued
alternativestr, optional: An alternative function or class name that the user may use in place of the deprecated object if new_name is None. The deprecation warning will tell the user about this alternative if provided.

Raises:

TypeError: If the new argument name cannot be found in the function signature and arg_in_kwargs was False or if it is used to deprecate the name of the *args-, **kwargs-like arguments. At runtime such an Error is raised if both the new_name and old_name were specified when calling the function and “relax=False”.

Notes

This function is based on the Astropy (major modification). astropy/astropy. See COPYING file distributed along with the astropy package for the copyright and license terms.

Examples

The deprecation warnings are not shown in the following examples. To deprecate a positional or keyword argument:: >>> from dipy.utils.deprecator import deprecated_params >>> @deprecated_params(‘sig’, new_name=’sigma’, since=’0.3’) … def test(sigma): … return sigma >>> test(2) 2 >>> test(sigma=2) 2 >>> test(sig=2) # doctest: +SKIP 2

It is also possible to replace multiple arguments. The old_name, new_name and since have to be tuple or list and contain the same number of entries:: >>> @deprecated_params([‘a’, ‘b’], new_name=[‘alpha’, ‘beta’], … since=[‘0.2’, 0.4]) … def test(alpha, beta): … return alpha, beta >>> test(a=2, b=3) # doctest: +SKIP (2, 3)

determine_num_threads#

dipy.denoise.shift_twist_convolution.determine_num_threads(num_threads)#

Determine the effective number of threads to be used for OpenMP calls

For num_threads = None, - if the OMP_NUM_THREADS environment variable is set, return that value - otherwise, return the maximum number of cores retrieved by openmp.opm_get_num_procs().
For num_threads > 0, return this value.
For num_threads < 0, return the maximal number of threads minus |num_threads + 1|. In particular num_threads = -1 will use as many threads as there are available cores on the machine.
For num_threads = 0 a ValueError is raised.

Parameters:

num_threadsint or None: Desired number of threads to be used.

sf_to_sh#

dipy.denoise.shift_twist_convolution.sf_to_sh(sf, sphere, *, sh_order_max=4, basis_type=None, full_basis=False, legacy=True, smooth=0.0)[source]#

Spherical function to spherical harmonics (SH).

Parameters:

sfndarray: Values of a function on the given sphere.
sphereSphere: The points on which the sf is defined.
sh_order_maxint, optional: Maximum SH order (l) in the SH fit. For sh_order_max, there will be (sh_order_max + 1) * (sh_order_max + 2) / 2 SH coefficients for a symmetric basis and (sh_order_max + 1) * (sh_order_max + 1) coefficients for a full SH basis.
basis_type{None, ‘tournier07’, ‘descoteaux07’}, optional: None for the default DIPY basis, tournier07 for the Tournier 2007 [18], [19] basis, descoteaux07 for the Descoteaux 2007 [20] basis, (None defaults to descoteaux07).
full_basis: bool, optional: True for using a SH basis containing even and odd order SH functions. False for using a SH basis consisting only of even order SH functions.
legacy: bool, optional: True to use a legacy basis definition for backward compatibility with previous tournier07 and descoteaux07 implementations.
smoothfloat, optional: Lambda-regularization in the SH fit.

Returns:

shndarray: SH coefficients representing the input function.

References

sh_to_sf#

dipy.denoise.shift_twist_convolution.sh_to_sf(sh, sphere, *, sh_order_max=4, basis_type=None, full_basis=False, legacy=True)[source]#

Spherical harmonics (SH) to spherical function (SF).

Parameters:

shndarray: SH coefficients representing a spherical function.
sphereSphere: The points on which to sample the spherical function.
sh_order_maxint, optional: Maximum SH order (l) in the SH fit. For sh_order_max, there will be (sh_order_max + 1) * (sh_order_max + 2) / 2 SH coefficients for a symmetric basis and (sh_order_max + 1) * (sh_order_max + 1) coefficients for a full SH basis.
basis_type{None, ‘tournier07’, ‘descoteaux07’}, optional: None for the default DIPY basis, tournier07 for the Tournier 2007 [18], [19] basis, descoteaux07 for the Descoteaux 2007 [20] basis, (None defaults to descoteaux07).
full_basis: bool, optional: True to use a SH basis containing even and odd order SH functions. Else, use a SH basis consisting only of even order SH functions.
legacy: bool, optional: True to use a legacy basis definition for backward compatibility with previous tournier07 and descoteaux07 implementations.

Returns:

sfndarray: Spherical function values on the sphere.

References

denoise#

Module: denoise._bias_correction#

Module: denoise.adaptive_soft_matching#

Module: denoise.bias_correction#

Module: denoise.denspeed#

Module: denoise.enhancement_kernel#

Module: denoise.gibbs#

Module: denoise.localpca#

Module: denoise.nlmeans#

Module: denoise.noise_estimate#

Module: denoise.patch2self#

Module: denoise.pca_noise_estimate#

Module: denoise.shift_twist_convolution#

compute_tukey_weights#

evaluate_bspline_rows#

gram_matrix_csr#

masked_voxel_coords#

adaptive_soft_matching#

polynomial_bias_field_dwi#

bias_field_correction#

add_padding_reflection#

correspond_indices#

determine_num_threads#

firdn#

nlmeans_3d#

nlmeans_3d_blockwise#

nlmeans_3d_classic#

remove_padding#

upfir#

EnhancementKernel#

HemiSphere#

Sphere#

ceil#

disperse_charges#

get_sphere#

gettempdir#

gibbs_removal#

dimensionality_problem_message#

create_patch_radius_arr#

compute_patch_size#

compute_num_samples#

compute_suggested_patch_radius#

genpca#

localpca#

mppca#

nlmeans#

piesno#

estimate_sigma#

vol_denoise#

patch2self#

pca_noise_estimate#

convolve#

convolve_sf#

deprecated_params#

determine_num_threads#

sf_to_sh#

sh_to_sf#

`denoise`#

Module: `denoise._bias_correction`#

Module: `denoise.adaptive_soft_matching`#

Module: `denoise.bias_correction`#

Module: `denoise.denspeed`#

Module: `denoise.enhancement_kernel`#

Module: `denoise.gibbs`#

Module: `denoise.localpca`#

Module: `denoise.nlmeans`#

Module: `denoise.noise_estimate`#

Module: `denoise.patch2self`#

Module: `denoise.pca_noise_estimate`#

Module: `denoise.shift_twist_convolution`#

`EnhancementKernel`#

`HemiSphere`#

`Sphere`#