_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q264300 | get_rcfile_section | validation | def get_rcfile_section(app_name, section_name):
""" Return the dictionary containing the rcfile section configuration
variables.
Parameters
----------
section_name: str
Name of the section in the rcfiles.
app_name: str
Name of the application to | python | {
"resource": ""
} |
q264301 | get_rcfile_variable_value | validation | def get_rcfile_variable_value(var_name, app_name, section_name=None):
""" Return the value of the variable in the section_name section of the
app_name rc file.
Parameters
----------
var_name: str
Name of the variable to be searched for.
section_name: str
Name of | python | {
"resource": ""
} |
q264302 | find_in_sections | validation | def find_in_sections(var_name, app_name):
""" Return the section and the value of the variable where the first
var_name is found in the app_name rcfiles.
Parameters
----------
var_name: str
Name of the variable to be searched for.
app_name: str
Name of the application to look for its rcfiles.
Returns
-------
section_name: str
Name of the section in the rcfiles where var_name was first found.
var_value: str
The value of the first variable with given var_name.
"""
sections = get_sections(app_name)
if not sections:
raise ValueError('No sections found in {} rcfiles.'.format(app_name))
for s in sections: | python | {
"resource": ""
} |
q264303 | filter_list | validation | def filter_list(lst, pattern):
"""
Filters the lst using pattern.
If pattern starts with '(' it will be considered a re regular expression,
otherwise it will use fnmatch filter.
:param lst: list of strings
:param pattern: string
:return: list of strings
Filtered list of strings
"""
if is_fnmatch_regex(pattern) and not is_regex(pattern):
#use fnmatch
| python | {
"resource": ""
} |
q264304 | get_subdict | validation | def get_subdict(adict, path, sep=os.sep):
"""
Given a nested dictionary adict.
This returns its childen just below the path.
The path is a string composed of adict keys separated by sep.
:param adict: nested dict
:param path: str
:param sep: str
| python | {
"resource": ""
} |
q264305 | get_dict_leaves | validation | def get_dict_leaves(data):
"""
Given a nested dictionary, this returns all its leave elements in a list.
:param adict:
:return: list
"""
result = | python | {
"resource": ""
} |
q264306 | get_possible_paths | validation | def get_possible_paths(base_path, path_regex):
"""
Looks for path_regex within base_path. Each match is append
in the returned list.
path_regex may contain subfolder structure.
If any part of the folder structure is a
:param base_path: str
:param path_regex: str
:return list of strings
"""
if not path_regex:
return []
if len(path_regex) < 1:
return []
if path_regex[0] == os.sep:
path_regex = path_regex[1:]
rest_files = ''
if os.sep in path_regex:
#split by os.sep
node_names = path_regex.partition(os.sep)
first_node = node_names[0]
rest_nodes = node_names[2]
| python | {
"resource": ""
} |
q264307 | FileTreeMap.create_folder | validation | def create_folder(dirpath, overwrite=False):
""" Will create dirpath folder. If dirpath already exists and overwrite is False,
will append a '+' | python | {
"resource": ""
} |
q264308 | FileTreeMap._import_config | validation | def _import_config(filepath):
"""
Imports filetree and root_path variable values from the filepath.
:param filepath:
:return: root_path and filetree
"""
if not op.isfile(filepath):
raise IOError('Data config file not found. | python | {
"resource": ""
} |
q264309 | FileTreeMap.remove_nodes | validation | def remove_nodes(self, pattern, adict):
"""
Remove the nodes that match the pattern.
"""
mydict = self._filetree if adict is None else adict
if isinstance(mydict, dict):
for nom in mydict.keys():
if isinstance(mydict[nom], dict):
matchs = filter_list(mydict[nom], pattern)
for nom in matchs:
mydict | python | {
"resource": ""
} |
q264310 | FileTreeMap.count_node_match | validation | def count_node_match(self, pattern, adict=None):
"""
Return the number of nodes that match the pattern.
:param pattern:
:param adict:
:return: int
"""
mydict = self._filetree if adict is None | python | {
"resource": ""
} |
q264311 | as_float_array | validation | def as_float_array(X, copy=True, force_all_finite=True):
"""Converts an array-like to an array of floats
The new dtype will be np.float32 or np.float64, depending on the original
type. The function can create a copy or modify the argument depending
on the argument copy.
Parameters
----------
X : {array-like, sparse matrix}
copy : bool, optional
If True, a copy of X will be created. If False, a copy may still be
returned if X's dtype is not a floating point type.
Returns | python | {
"resource": ""
} |
q264312 | indexable | validation | def indexable(*iterables):
"""Make arrays indexable for cross-validation.
Checks consistent length, passes through None, and ensures that everything
can be indexed by converting sparse matrices to csr and converting
non-interable objects to arrays.
Parameters
----------
iterables : lists, dataframes, arrays, | python | {
"resource": ""
} |
q264313 | check_array | validation | def check_array(array, accept_sparse=None, dtype=None, order=None, copy=False,
force_all_finite=True, ensure_2d=True, allow_nd=False):
"""Input validation on an array, list, sparse matrix or similar.
By default, the input is converted to an at least 2nd numpy array.
Parameters
----------
array : object
Input object to check / convert.
accept_sparse : string, list of string or None (default=None)
String[s] representing allowed sparse matrix formats, such as 'csc',
'csr', etc. None means that sparse matrix input will raise an error.
If the input is sparse but not in the allowed format, it will be
converted to the first listed format.
order : 'F', 'C' or None (default=None)
Whether an array will be forced to be fortran or c-style.
copy : boolean (default=False)
Whether a forced copy will be triggered. If copy=False, a copy might
be triggered by a conversion.
force_all_finite : boolean (default=True)
Whether to raise an error on np.inf and np.nan in X.
ensure_2d : boolean (default=True)
Whether to make X at least 2d.
allow_nd : boolean (default=False)
Whether to allow X.ndim > 2.
Returns
-------
X_converted : object
| python | {
"resource": ""
} |
q264314 | check_X_y | validation | def check_X_y(X, y, accept_sparse=None, dtype=None, order=None, copy=False,
force_all_finite=True, ensure_2d=True, allow_nd=False,
multi_output=False):
"""Input validation for standard estimators.
Checks X and y for consistent length, enforces X 2d and y 1d.
Standard input checks are only applied to y. For multi-label y,
set multi_ouput=True to allow 2d and sparse y.
Parameters
----------
X : nd-array, list or sparse matrix
Input data.
y : nd-array, list or sparse matrix
Labels.
accept_sparse : string, list of string or None (default=None)
String[s] representing allowed sparse matrix formats, such as 'csc',
'csr', etc. None means that sparse matrix input will raise an error.
If the input is sparse but not in the allowed format, it will be
converted to the first listed format.
order : 'F', 'C' or None (default=None)
Whether an array will be forced to be fortran or c-style.
copy : boolean (default=False)
Whether a forced copy will be triggered. If copy=False, a copy might
be triggered by a conversion.
force_all_finite : boolean (default=True)
Whether to raise an error on np.inf and np.nan in X.
| python | {
"resource": ""
} |
q264315 | column_or_1d | validation | def column_or_1d(y, warn=False):
""" Ravel column or 1d numpy array, else raises an error
Parameters
----------
y : array-like
Returns
-------
y : array
"""
shape = np.shape(y)
if len(shape) == 1:
return np.ravel(y)
if len(shape) == 2 and shape[1] == 1:
if warn:
warnings.warn("A column-vector y was passed when a 1d array was"
" expected. Please change the shape of y to | python | {
"resource": ""
} |
q264316 | warn_if_not_float | validation | def warn_if_not_float(X, estimator='This algorithm'):
"""Warning utility function to check that data type is floating point.
Returns True if a warning was raised (i.e. the input is not float) and
False otherwise, for easier | python | {
"resource": ""
} |
q264317 | as_ndarray | validation | def as_ndarray(arr, copy=False, dtype=None, order='K'):
"""Convert an arbitrary array to numpy.ndarray.
In the case of a memmap array, a copy is automatically made to break the
link with the underlying file (whatever the value of the "copy" keyword).
The purpose of this function is mainly to get rid of memmap objects, but
it can be used for other purposes. In particular, combining copying and
casting can lead to performance improvements in some cases, by avoiding
unnecessary copies.
If not specified, input array order is preserved, in all cases, even when
a copy is requested.
Caveat: this function does not copy during bool to/from 1-byte dtype
conversions. This can lead to some surprising results in some rare cases.
Example:
a = numpy.asarray([0, 1, 2], dtype=numpy.int8)
b = as_ndarray(a, dtype=bool) # array([False, True, True], dtype=bool)
c = as_ndarray(b, dtype=numpy.int8) # array([0, 1, 2], dtype=numpy.int8)
The usually expected result for the last line would be array([0, 1, 1])
because True evaluates to 1. Since there is no copy made here, the original
array is recovered.
Parameters
----------
arr: array-like
input array. Any value accepted by numpy.asarray is valid.
copy: bool
if True, force a copy of the array. Always True when arr is a memmap.
dtype: any numpy dtype
dtype of the returned array. Performing copy and type conversion at the
same time can in some cases avoid an additional copy.
order: string
gives the order of the returned array.
Valid values are: "C", "F", "A", "K", None.
default is "K". See ndarray.copy() for more information.
Returns
-------
ret: np.ndarray
Numpy array containing the same data as arr, always of class
numpy.ndarray, and with no link to any underlying file.
"""
if order not in ('C', 'F', 'A', 'K', None):
raise ValueError("Invalid value for 'order': {}".format(str(order)))
if isinstance(arr, np.memmap):
if dtype is None:
if order in ('K', 'A', None):
ret = np.array(np.asarray(arr), copy=True)
else:
ret = np.array(np.asarray(arr), copy=True, order=order)
| python | {
"resource": ""
} |
q264318 | xfm_atlas_to_functional | validation | def xfm_atlas_to_functional(atlas_filepath, anatbrain_filepath, meanfunc_filepath,
atlas2anat_nonlin_xfm_filepath, is_atlas2anat_inverted,
anat2func_lin_xfm_filepath,
atlasinanat_out_filepath, atlasinfunc_out_filepath,
interp='nn', rewrite=True, parallel=False):
"""Call FSL tools to apply transformations to a given atlas to a functional image.
Given the transformation matrices.
Parameters
----------
atlas_filepath: str
Path to the 3D atlas volume file.
anatbrain_filepath: str
Path to the anatomical brain volume file (skull-stripped and registered to the same space as the atlas,
e.g., MNI).
meanfunc_filepath: str
Path to the average functional image to be used as reference in the last applywarp step.
atlas2anat_nonlin_xfm_filepath: str
Path to the atlas to anatomical brain linear transformation .mat file.
If you have the inverse transformation, i.e., anatomical brain to atlas, set is_atlas2anat_inverted to True.
is_atlas2anat_inverted: bool
If False will have to calculate the inverse atlas2anat transformation to apply the transformations.
This step will be performed with FSL invwarp.
anat2func_lin_xfm_filepath: str
Path to the anatomical to functional .mat linear transformation file.
atlasinanat_out_filepath: str
Path to output file which will contain the 3D atlas in the subject anatomical space.
atlasinfunc_out_filepath: str
Path to output file which will contain the 3D atlas in the subject functional space.
verbose: bool
If verbose will show DEBUG log info.
rewrite: bool
If True will re-run all the commands overwriting any existing file. Otherwise will check if
each file exists and if it does won't run the command.
parallel: bool
If True will launch the commands using ${FSLDIR}/fsl_sub to use the cluster infrastructure you have setup
with FSL (SGE or HTCondor).
"""
if is_atlas2anat_inverted:
# I already have the inverted fields I need
anat_to_mni_nl_inv = atlas2anat_nonlin_xfm_filepath
else:
# I am creating the inverted fields then...need output file path:
output_dir = op.abspath (op.dirname(atlasinanat_out_filepath))
ext = get_extension(atlas2anat_nonlin_xfm_filepath)
anat_to_mni_nl_inv = op.join(output_dir, remove_ext(op.basename(atlas2anat_nonlin_xfm_filepath)) + '_inv' + ext)
# setup the commands to be called
invwarp_cmd = op.join('${FSLDIR}', 'bin', 'invwarp')
applywarp_cmd = op.join('${FSLDIR}', 'bin', 'applywarp')
fslsub_cmd = op.join('${FSLDIR}', 'bin', 'fsl_sub')
# add fsl_sub before the commands
if parallel:
invwarp_cmd = fslsub_cmd + ' ' + invwarp_cmd
applywarp_cmd = fslsub_cmd + ' ' + applywarp_cmd
| python | {
"resource": ""
} |
q264319 | fwhm2sigma | validation | def fwhm2sigma(fwhm):
"""Convert a FWHM value to sigma in a Gaussian kernel.
Parameters
----------
fwhm: float or numpy.array
| python | {
"resource": ""
} |
q264320 | sigma2fwhm | validation | def sigma2fwhm(sigma):
"""Convert a sigma in a Gaussian kernel to a FWHM value.
Parameters
----------
sigma: float or numpy.array
sigma value or values
Returns
-------
fwhm: float or numpy.array
| python | {
"resource": ""
} |
q264321 | _smooth_data_array | validation | def _smooth_data_array(arr, affine, fwhm, copy=True):
"""Smooth images with a a Gaussian filter.
Apply a Gaussian filter along the three first dimensions of arr.
Parameters
----------
arr: numpy.ndarray
3D or 4D array, with image number as last dimension.
affine: numpy.ndarray
Image affine transformation matrix for image.
fwhm: scalar, numpy.ndarray
Smoothing kernel size, as Full-Width at Half Maximum (FWHM) in millimeters.
If a scalar is given, kernel width is identical on all three directions.
A numpy.ndarray must have 3 elements, giving the FWHM along each axis.
copy: bool
if True, will make a copy of the input array. Otherwise will directly smooth the input array.
Returns
-------
smooth_arr: numpy.ndarray
"""
if arr.dtype.kind == 'i':
if arr.dtype == np.int64:
arr = arr.astype(np.float64)
else:
arr = arr.astype(np.float32)
if copy:
arr = arr.copy()
# Zeroe possible NaNs and Inf in the image.
arr[np.logical_not(np.isfinite(arr))] = 0 | python | {
"resource": ""
} |
q264322 | smooth_imgs | validation | def smooth_imgs(images, fwhm):
"""Smooth images using a Gaussian filter.
Apply a Gaussian filter along the three first dimensions of each image in images.
In all cases, non-finite values in input are zeroed.
Parameters
----------
imgs: str or img-like object or iterable of img-like objects
See boyle.nifti.read.read_img
Image(s) to smooth.
fwhm: scalar or numpy.ndarray
Smoothing kernel size, as Full-Width at Half Maximum (FWHM) in millimeters.
If a scalar is given, kernel width is identical on all three directions.
A numpy.ndarray must have 3 elements, giving the FWHM along each axis.
Returns
-------
smooth_imgs: nibabel.Nifti1Image or list of.
Smooth input image/s.
"""
if fwhm <= | python | {
"resource": ""
} |
q264323 | _smooth_array | validation | def _smooth_array(arr, affine, fwhm=None, ensure_finite=True, copy=True, **kwargs):
"""Smooth images by applying a Gaussian filter.
Apply a Gaussian filter along the three first dimensions of arr.
This is copied and slightly modified from nilearn:
https://github.com/nilearn/nilearn/blob/master/nilearn/image/image.py
Added the **kwargs argument.
Parameters
==========
arr: numpy.ndarray
4D array, with image number as last dimension. 3D arrays are also
accepted.
affine: numpy.ndarray
(4, 4) matrix, giving affine transformation for image. (3, 3) matrices
are also accepted (only these coefficients are used).
If fwhm='fast', the affine is not used and can be None
fwhm: scalar, numpy.ndarray, 'fast' or None
Smoothing strength, as a full-width at half maximum, in millimeters.
If a scalar is given, width is identical on all three directions.
A numpy.ndarray must have 3 elements, giving the FWHM along each axis.
If fwhm == 'fast', a fast smoothing will be performed with
a filter [0.2, 1, 0.2] in each direction and a normalisation
to preserve the local average value.
If fwhm is None, no filtering is performed (useful when just removal
of non-finite values is needed).
ensure_finite: bool
if True, replace every non-finite values (like NaNs) by zero before
filtering.
copy: bool
if True, input array is not modified. False by default: the filtering
is performed in-place.
kwargs: keyword-arguments
| python | {
"resource": ""
} |
q264324 | smooth_img | validation | def smooth_img(imgs, fwhm, **kwargs):
"""Smooth images by applying a Gaussian filter.
Apply a Gaussian filter along the three first dimensions of arr.
In all cases, non-finite values in input image are replaced by zeros.
This is copied and slightly modified from nilearn:
https://github.com/nilearn/nilearn/blob/master/nilearn/image/image.py
Added the **kwargs argument.
Parameters
==========
imgs: Niimg-like object or iterable of Niimg-like objects
See http://nilearn.github.io/manipulating_images/manipulating_images.html#niimg.
Image(s) to smooth.
fwhm: scalar, numpy.ndarray, 'fast' or None
Smoothing strength, as a Full-Width at Half Maximum, in millimeters.
If a scalar is given, width is identical on all three directions.
A numpy.ndarray must have 3 elements, giving the FWHM along each axis.
If fwhm == 'fast', a fast smoothing will be performed with
a filter [0.2, 1, 0.2] in each direction and a normalisation
to preserve the scale.
If fwhm is None, no filtering is performed (useful when just removal
of non-finite values is needed)
Returns
=======
filtered_img: nibabel.Nifti1Image or list of.
Input image, filtered. If imgs is an iterable, then filtered_img is a
| python | {
"resource": ""
} |
q264325 | ClientCertAuthentication.signed_session | validation | def signed_session(self, session=None):
"""Create requests session with any required auth headers
applied.
:rtype: requests.Session.
"""
if session:
session = super(ClientCertAuthentication, self).signed_session(session)
else:
session = super(ClientCertAuthentication, self).signed_session()
if | python | {
"resource": ""
} |
q264326 | AdalAuthentication.signed_session | validation | def signed_session(self, session=None):
"""Create requests session with AAD auth headers
:rtype: requests.Session.
"""
from sfctl.config import (aad_metadata, aad_cache)
if session:
session = super(AdalAuthentication, self).signed_session(session)
else:
session = super(AdalAuthentication, self).signed_session()
if self.no_verify:
session.verify = False
authority_uri, cluster_id, client_id = aad_metadata()
existing_token, existing_cache = aad_cache()
context = adal.AuthenticationContext(authority_uri,
| python | {
"resource": ""
} |
q264327 | voxspace_to_mmspace | validation | def voxspace_to_mmspace(img):
""" Return a grid with coordinates in 3D physical space for `img`."""
shape, affine = img.shape[:3], img.affine
coords = np.array(np.meshgrid(*(range(i) for i in shape), indexing='ij'))
coords = | python | {
"resource": ""
} |
q264328 | get_3D_coordmap | validation | def get_3D_coordmap(img):
'''
Gets a 3D CoordinateMap from img.
Parameters
----------
img: nib.Nifti1Image or nipy Image
Returns
-------
nipy.core.reference.coordinate_map.CoordinateMap
'''
if isinstance(img, nib.Nifti1Image):
img = nifti2nipy(img)
if img.ndim == 4:
| python | {
"resource": ""
} |
q264329 | get_img_info | validation | def get_img_info(image):
"""Return the header and affine matrix from a Nifti file.
Parameters
----------
image: img-like object or str
Can either be:
- a file path to a Nifti image
- any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.
If niimg is a string, consider it as a path to Nifti image and
call nibabel.load on it. If it is an object, check if get_data()
| python | {
"resource": ""
} |
q264330 | get_img_data | validation | def get_img_data(image, copy=True):
"""Return the voxel matrix of the Nifti file.
If safe_mode will make a copy of the img before returning the data, so the input image is not modified.
Parameters
----------
image: img-like object or str
Can either be:
- a file path to a Nifti image
- any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.
If niimg is a string, consider it as a path to Nifti image and
call nibabel.load on it. If it is an object, check if get_data()
and get_affine() methods are present, raise TypeError otherwise.
copy: bool
If safe_mode will make a copy of the img before returning the data, so | python | {
"resource": ""
} |
q264331 | load_nipy_img | validation | def load_nipy_img(nii_file):
"""Read a Nifti file and return as nipy.Image
Parameters
----------
param nii_file: str
Nifti file path
Returns
-------
nipy.Image
"""
# delayed import because could not install nipy on Python 3 on OSX
import nipy
if not os.path.exists(nii_file):
raise FileNotFound(nii_file) | python | {
"resource": ""
} |
q264332 | niftilist_to_array | validation | def niftilist_to_array(img_filelist, outdtype=None):
"""
From the list of absolute paths to nifti files, creates a Numpy array
with the data.
Parameters
----------
img_filelist: list of str
List of absolute file paths to nifti files. All nifti files must have
the same shape.
outdtype: dtype
Type of the elements of the array, if not set will obtain the dtype from
the first nifti file.
Returns
-------
outmat: Numpy array with shape N x prod(vol.shape)
containing the N files as flat vectors.
vol_shape: Tuple with shape of the volumes, for reshaping.
"""
try:
first_img = img_filelist[0]
vol = get_img_data(first_img)
| python | {
"resource": ""
} |
q264333 | _crop_img_to | validation | def _crop_img_to(image, slices, copy=True):
"""Crops image to a smaller size
Crop img to size indicated by slices and modify the affine accordingly.
Parameters
----------
image: img-like object or str
Can either be:
- a file path to a Nifti image
- any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.
If niimg is a string, consider it as a path to Nifti image and
call nibabel.load on it. If it is an object, check if get_data()
and get_affine() methods are present, raise TypeError otherwise.
Image to be cropped.
slices: list of slices
Defines the range of the crop.
E.g. [slice(20, 200), slice(40, 150), slice(0, 100)]
defines a 3D cube
If slices has less entries than image has dimensions,
the slices will be applied to the first len(slices) dimensions.
copy: boolean
Specifies whether cropped data is to be copied or not.
Default: True
Returns
-------
cropped_img: img-like object
Cropped version of the input image
"""
img = | python | {
"resource": ""
} |
q264334 | crop_img | validation | def crop_img(image, rtol=1e-8, copy=True):
"""Crops img as much as possible
Will crop img, removing as many zero entries as possible
without touching non-zero entries. Will leave one voxel of
zero padding around the obtained non-zero area in order to
avoid sampling issues later on.
Parameters
----------
image: img-like object or str
Can either be:
- a file path to a Nifti image
- any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.
If niimg is a string, consider it as a path to Nifti image and
call nibabel.load on it. If it is an object, check if get_data()
and get_affine() methods are present, raise TypeError otherwise.
Image to be cropped.
rtol: float
relative tolerance (with respect to maximal absolute
value of the image), under which values are considered
negligeable and thus croppable.
copy: boolean
Specifies whether cropped data is copied or not.
Returns
-------
cropped_img: image
Cropped version of the input image
"""
img = check_img(image)
| python | {
"resource": ""
} |
q264335 | new_img_like | validation | def new_img_like(ref_niimg, data, affine=None, copy_header=False):
"""Create a new image of the same class as the reference image
Parameters
----------
ref_niimg: image
Reference image. The new image will be of the same type.
data: numpy array
Data to be stored in the image
affine: 4x4 numpy array, optional
Transformation matrix
copy_header: boolean, optional
Indicated if the header of the reference image should be used to
create the new image
Returns
-------
new_img: image
A loaded image with the same type (and header) as the reference image.
"""
# Hand-written loading code to avoid too much memory consumption
if not (hasattr(ref_niimg, 'get_data')
and hasattr(ref_niimg,'get_affine')):
if isinstance(ref_niimg, _basestring):
ref_niimg = nib.load(ref_niimg)
elif operator.isSequenceType(ref_niimg):
ref_niimg = nib.load(ref_niimg[0])
else:
raise TypeError(('The reference image should be a niimg, %r '
'was passed') % ref_niimg )
if affine is None:
| python | {
"resource": ""
} |
q264336 | get_h5file | validation | def get_h5file(file_path, mode='r'):
""" Return the h5py.File given its file path.
Parameters
----------
file_path: string
HDF5 file path
mode: string
r Readonly, file must exist
r+ Read/write, file must exist
w Create file, truncate if | python | {
"resource": ""
} |
q264337 | extract_datasets | validation | def extract_datasets(h5file, h5path='/'):
""" Return all dataset contents from h5path group in h5file in an OrderedDict.
Parameters
----------
h5file: h5py.File
HDF5 file object
h5path: str
HDF5 group path to read datasets from
Returns
-------
datasets: OrderedDict
Dict with variables contained in file_path/h5path
"""
if isinstance(h5file, str):
_h5file = h5py.File(h5file, mode='r')
else:
_h5file = h5file
_datasets = get_datasets(_h5file, h5path)
datasets = OrderedDict()
try:
for | python | {
"resource": ""
} |
q264338 | _get_node_names | validation | def _get_node_names(h5file, h5path='/', node_type=h5py.Dataset):
"""Return the node of type node_type names within h5path of h5file.
Parameters
----------
h5file: h5py.File
HDF5 file object
h5path: str
HDF5 group path to get the group names from
node_type: h5py object type
HDF5 object type
Returns
-------
names: list of str
List of names
"""
if isinstance(h5file, str):
_h5file = get_h5file(h5file, mode='r')
else:
_h5file = h5file
if not h5path.startswith('/'):
h5path = '/' + h5path
| python | {
"resource": ""
} |
q264339 | NeuroImageSet.mask | validation | def mask(self, image):
""" self.mask setter
Parameters
----------
image: str or img-like object.
See NeuroImage constructor docstring.
| python | {
"resource": ""
} |
q264340 | NeuroImageSet._load_images_and_labels | validation | def _load_images_and_labels(self, images, labels=None):
"""Read the images, load them into self.items and set the labels."""
if not isinstance(images, (list, tuple)):
raise ValueError('Expected an iterable (list or tuple) of strings or img-like objects. '
'Got a {}.'.format(type(images)))
if not len(images) > 0:
raise ValueError('Expected an iterable (list or tuple) of strings or img-like objects '
'of size higher than 0. Got {} items.'.format(len(images)))
| python | {
"resource": ""
} |
q264341 | NeuroImageSet.to_file | validation | def to_file(self, output_file, smooth_fwhm=0, outdtype=None):
"""Save the Numpy array created from to_matrix function to the output_file.
Will save into the file: outmat, mask_indices, vol_shape and self.others (put here whatever you want)
data: Numpy array with shape N x prod(vol.shape)
containing the N files as flat vectors.
mask_indices: matrix with indices of the voxels in the mask
vol_shape: Tuple with shape of the volumes, for reshaping.
Parameters
----------
output_file: str
Path to the output file. The extension of the file will be taken into account for the file format.
Choices of extensions: '.pyshelf' or '.shelf' (Python shelve)
'.mat' (Matlab archive),
'.hdf5' or '.h5' (HDF5 file)
smooth_fwhm: int
Integer indicating the size of the FWHM Gaussian smoothing kernel
to smooth the subject volumes before creating the data matrix
outdtype: | python | {
"resource": ""
} |
q264342 | die | validation | def die(msg, code=-1):
"""Writes msg to stderr and | python | {
"resource": ""
} |
q264343 | check_call | validation | def check_call(cmd_args):
"""
Calls the command
Parameters
----------
cmd_args: list of str
Command name to call and | python | {
"resource": ""
} |
q264344 | call_command | validation | def call_command(cmd_name, args_strings):
"""Call CLI command with arguments and returns its return value.
Parameters
----------
cmd_name: str
Command name or full path to the binary file.
arg_strings: list of str
Argument strings list.
Returns
-------
return_value
Command return value.
"""
if not op.isabs(cmd_name):
cmd_fullpath = which(cmd_name)
else:
cmd_fullpath = cmd_name
try:
cmd_line = [cmd_fullpath] + args_strings
log.info('Calling: {}.'.format(cmd_line))
retval = subprocess.check_call(cmd_line)
except | python | {
"resource": ""
} |
q264345 | condor_call | validation | def condor_call(cmd, shell=True):
"""
Tries to submit cmd to HTCondor, if it does not succeed, it will
be called with subprocess.call.
Parameters
----------
cmd: string
Command to be submitted
Returns
| python | {
"resource": ""
} |
q264346 | condor_submit | validation | def condor_submit(cmd):
"""
Submits cmd to HTCondor queue
Parameters
----------
cmd: string
Command to be submitted
Returns
-------
int
returncode value from calling the submission command.
"""
is_running = subprocess.call('condor_status', shell=True) == 0
if not is_running:
raise CalledProcessError('HTCondor is not running.')
| python | {
"resource": ""
} |
q264347 | clean | validation | def clean(ctx):
"""Clean previously built package artifacts.
"""
ctx.run(f'python | python | {
"resource": ""
} |
q264348 | upload | validation | def upload(ctx, repo):
"""Upload the package to an index server.
This implies cleaning and re-building the package.
:param repo: Required. Name of the index server to upload to, as specifies
in your .pypirc configuration file.
"""
artifacts = ' '.join(
| python | {
"resource": ""
} |
q264349 | SFCommandLoader.load_command_table | validation | def load_command_table(self, args): #pylint: disable=too-many-statements
"""Load all Service Fabric commands"""
# Need an empty client for the select and upload operations
with CommandSuperGroup(__name__, self,
'rcctl.custom_cluster#{}') as super_group:
with super_group.group('cluster') as group:
group.command('select', 'select')
with CommandSuperGroup(__name__, self, 'rcctl.custom_reliablecollections#{}',
client_factory=client_create) as super_group:
with super_group.group('dictionary') as group:
group.command('query', 'query_reliabledictionary')
group.command('execute', 'execute_reliabledictionary')
group.command('schema', 'get_reliabledictionary_schema')
group.command('list', 'get_reliabledictionary_list')
group.command('type-schema', 'get_reliabledictionary_type_schema') | python | {
"resource": ""
} |
q264350 | open_volume_file | validation | def open_volume_file(filepath):
"""Open a volumetric file using the tools following the file extension.
Parameters
----------
filepath: str
Path to a volume file
Returns
-------
volume_data: np.ndarray
Volume data
pixdim: 1xN np.ndarray
Vector with the description of the voxels physical size (usually in mm) for each volume dimension.
Raises
------
IOError
In case the file is not found.
"""
# check if the file exists
if not op.exists(filepath):
raise IOError('Could not find file {}.'.format(filepath))
# define helper functions
def open_nifti_file(filepath):
return NiftiImage(filepath)
def open_mhd_file(filepath):
return MedicalImage(filepath)
vol_data, hdr_data = load_raw_data_with_mhd(filepath)
# TODO: convert vol_data and hdr_data into MedicalImage
return vol_data, hdr_data
def open_mha_file(filepath):
raise NotImplementedError('This | python | {
"resource": ""
} |
q264351 | rename_file_group_to_serial_nums | validation | def rename_file_group_to_serial_nums(file_lst):
"""Will rename all files in file_lst to a padded serial
number plus its extension
:param file_lst: list of path.py paths
"""
file_lst.sort()
c = 1
for f in file_lst:
dirname = get_abspath(f.dirname())
fdest = | python | {
"resource": ""
} |
q264352 | DicomFileSet._store_dicom_paths | validation | def _store_dicom_paths(self, folders):
"""Search for dicoms in folders and save file paths into
self.dicom_paths set.
:param folders: str or list of str
"""
if isinstance(folders, str):
folders = [folders]
| python | {
"resource": ""
} |
q264353 | DicomFileSet.from_set | validation | def from_set(self, fileset, check_if_dicoms=True):
"""Overwrites self.items with the given set of files.
Will filter the fileset and keep only Dicom files.
Parameters
----------
fileset: iterable of str
| python | {
"resource": ""
} |
q264354 | DicomFileSet.update | validation | def update(self, dicomset):
"""Update this set with the union of itself and dicomset.
Parameters
----------
dicomset: DicomFileSet
| python | {
"resource": ""
} |
q264355 | DicomFileSet.copy_files_to_other_folder | validation | def copy_files_to_other_folder(self, output_folder, rename_files=True,
mkdir=True, verbose=False):
"""
Copies all files within this set to the output_folder
Parameters
----------
output_folder: str
Path of the destination folder of the files
rename_files: bool
Whether or not rename the files to a sequential format
mkdir: bool
Whether to make the folder if it does not exist
verbose: bool
Whether to print to stdout the files that are beind copied
"""
import shutil
if not os.path.exists(output_folder):
os.mkdir(output_folder)
if not rename_files:
for dcmf in self.items:
outf = os.path.join(output_folder, os.path.basename(dcmf))
if verbose:
print('{} -> {}'.format(dcmf, outf))
| python | {
"resource": ""
} |
q264356 | DicomGenericSet.get_dcm_reader | validation | def get_dcm_reader(store_metadata=True, header_fields=None):
"""
Creates a lambda function to read DICOM files.
If store_store_metadata is False, will only return the file path.
Else if you give header_fields, will return only the set of of
header_fields within a DicomFile object or the whole DICOM file if
None.
:return: function
This function has only one parameter: file_path
"""
if not store_metadata:
return lambda fpath: | python | {
"resource": ""
} |
q264357 | DicomGenericSet.scrape_all_files | validation | def scrape_all_files(self):
"""
Generator that yields one by one the return value for self.read_dcm
for each file within this set
"""
try:
for dcmf in self.items:
| python | {
"resource": ""
} |
q264358 | get_unique_field_values | validation | def get_unique_field_values(dcm_file_list, field_name):
"""Return a set of unique field values from a list of DICOM files
Parameters
----------
dcm_file_list: iterable of DICOM file paths
field_name: str
Name of the field from where to get each value
Returns
-------
| python | {
"resource": ""
} |
q264359 | find_all_dicom_files | validation | def find_all_dicom_files(root_path):
"""
Returns a list of the dicom files within root_path
Parameters
----------
root_path: str
Path to the directory to be recursively searched for DICOM files.
Returns
| python | {
"resource": ""
} |
q264360 | is_dicom_file | validation | def is_dicom_file(filepath):
"""
Tries to read the file using dicom.read_file,
if the file exists and dicom.read_file does not raise
and Exception returns True. False otherwise.
:param filepath: str
Path to DICOM file
:return: bool
"""
if not os.path.exists(filepath):
raise IOError('File {} not found.'.format(filepath))
filename = os.path.basename(filepath)
if filename == 'DICOMDIR':
| python | {
"resource": ""
} |
q264361 | group_dicom_files | validation | def group_dicom_files(dicom_paths, hdr_field='PatientID'):
"""Group in a dictionary all the DICOM files in dicom_paths
separated by the given `hdr_field` tag value.
Parameters
----------
dicom_paths: str
Iterable of DICOM file paths.
hdr_field: str
Name of the DICOM tag whose values will be used as key for the group.
Returns
-------
dicom_groups: dict of dicom_paths
"""
dicom_groups = defaultdict(list)
try:
for dcm in dicom_paths:
hdr = dicom.read_file(dcm)
| python | {
"resource": ""
} |
q264362 | DicomFile.get_attributes | validation | def get_attributes(self, attributes, default=''):
"""Return the attributes values from this DicomFile
Parameters
----------
attributes: str or list of str
DICOM field names
default: str
Default value if the attribute | python | {
"resource": ""
} |
q264363 | merge_images | validation | def merge_images(images, axis='t'):
""" Concatenate `images` in the direction determined in `axis`.
Parameters
----------
images: list of str or img-like object.
See NeuroImage constructor docstring.
axis: str
't' : concatenate images in time
'x' : concatenate images in the x direction
'y' : concatenate images in the y direction
'z' : concatenate images in the z direction
Returns
-------
merged: img-like object
"""
# check if images is not empty
if not images:
return None
# the given axis name to axis idx
axis_dim = {'x': 0,
'y': 1,
'z': 2,
't': 3,
}
# check if the given axis name is valid
if axis not in axis_dim:
raise ValueError('Expected `axis` to be one of ({}), got {}.'.format(set(axis_dim.keys()), axis))
# check if all images are compatible with each other
img1 = images[0]
for img in images:
check_img_compatibility(img1, img)
# read the data of | python | {
"resource": ""
} |
q264364 | nifti_out | validation | def nifti_out(f):
""" Picks a function whose first argument is an `img`, processes its
data and returns a numpy array. This decorator wraps this numpy array
into a nibabel.Nifti1Image."""
@wraps(f)
def wrapped(*args, **kwargs):
r = f(*args, **kwargs)
| python | {
"resource": ""
} |
q264365 | div_img | validation | def div_img(img1, div2):
""" Pixelwise division or divide by a number """
if is_img(div2):
return img1.get_data()/div2.get_data()
elif isinstance(div2, (float, int)):
return img1.get_data()/div2
| python | {
"resource": ""
} |
q264366 | apply_mask | validation | def apply_mask(img, mask):
"""Return the image with the given `mask` applied."""
from .mask | python | {
"resource": ""
} |
q264367 | abs_img | validation | def abs_img(img):
""" Return an image with the binarised version of the data of `img`."""
bool_img | python | {
"resource": ""
} |
q264368 | icc_img_to_zscore | validation | def icc_img_to_zscore(icc, center_image=False):
""" Return a z-scored version of `icc`.
This function is based on GIFT `icatb_convertImageToZScores` function.
"""
vol = read_img(icc).get_data()
v2 = vol[vol != 0]
if center_image:
v2 = detrend(v2, axis=0)
| python | {
"resource": ""
} |
q264369 | spatial_map | validation | def spatial_map(icc, thr, mode='+'):
""" Return the thresholded | python | {
"resource": ""
} |
q264370 | write_meta_header | validation | def write_meta_header(filename, meta_dict):
""" Write the content of the `meta_dict` into `filename`.
Parameters
----------
filename: str
Path to the output file
meta_dict: dict
Dictionary with the fields of the metadata .mhd file
"""
header = ''
# do not use tags = meta_dict.keys() because the order of tags | python | {
"resource": ""
} |
q264371 | dump_raw_data | validation | def dump_raw_data(filename, data):
""" Write the data into a raw format file. Big endian is always used.
Parameters
----------
filename: str
Path to the output file
data: numpy.ndarray
n-dimensional image data array.
"""
if data.ndim == 3:
# Begin 3D fix
data | python | {
"resource": ""
} |
q264372 | write_mhd_file | validation | def write_mhd_file(filename, data, shape=None, meta_dict=None):
""" Write the `data` and `meta_dict` in two files with names
that use `filename` as a prefix.
Parameters
----------
filename: str
Path to the output file.
This is going to be used as a preffix.
Two files will be created, one with a '.mhd' extension
and another with '.raw'. If `filename` has any of these already
they will be taken into account to build the filenames.
data: numpy.ndarray
n-dimensional image data array.
shape: tuple
Tuple describing the shape of `data`
Default: data.shape
meta_dict: dict
Dictionary with the fields of the metadata .mhd file
Default: {}
Returns
-------
mhd_filename: str
Path to the .mhd file
raw_filename: str
Path to the .raw file
"""
# check its extension
ext = get_extension(filename)
fname = op.basename(filename)
if ext != '.mhd' or ext != '.raw':
mhd_filename = fname + '.mhd'
raw_filename = fname + '.raw'
| python | {
"resource": ""
} |
q264373 | copy_mhd_and_raw | validation | def copy_mhd_and_raw(src, dst):
"""Copy .mhd and .raw files to dst.
If dst is a folder, won't change the file, but if dst is another filepath,
will modify the ElementDataFile field in the .mhd to point to the
new renamed .raw file.
Parameters
----------
src: str
Path to the .mhd file to be copied
dst: str
Path to the destination of the .mhd and .raw files.
If a new file name is given, the extension will be ignored.
Returns
-------
dst: str
"""
# check if src exists
if not op.exists(src):
raise IOError('Could not find file {}.'.format(src))
# check its extension
ext = get_extension(src)
if ext != '.mhd':
msg = 'The src file path must be a .mhd file. Given: {}.'.format(src)
raise ValueError(msg)
# get the raw file for this src mhd file
meta_src = _read_meta_header(src)
# get the source raw file
src_raw = meta_src['ElementDataFile']
if not op.isabs(src_raw):
src_raw = op.join(op.dirname(src), src_raw)
# check if dst is dir
if op.isdir(dst):
# copy the mhd and raw file to its destiny
shutil.copyfile(src, dst)
shutil.copyfile(src_raw, dst)
return dst
# build raw file dst file name
dst_raw = op.join(op.dirname(dst), remove_ext(op.basename(dst))) + '.raw'
# add extension to the dst path
if get_extension(dst) != '.mhd': | python | {
"resource": ""
} |
q264374 | sav_to_pandas_rpy2 | validation | def sav_to_pandas_rpy2(input_file):
"""
SPSS .sav files to Pandas DataFrame through Rpy2
:param input_file: string
:return:
"""
import pandas.rpy.common | python | {
"resource": ""
} |
q264375 | sav_to_pandas_savreader | validation | def sav_to_pandas_savreader(input_file):
"""
SPSS .sav files to Pandas DataFrame through savreader module
:param input_file: string
:return:
"""
from savReaderWriter import SavReader
lines = []
with SavReader(input_file, returnHeader=True) | python | {
"resource": ""
} |
q264376 | ExportData.save_varlist | validation | def save_varlist(filename, varnames, varlist):
"""
Valid extensions '.pyshelf', '.mat', '.hdf5' or '.h5'
@param filename: string
@param varnames: list of strings
Names of the variables
@param varlist: list of objects
The objects | python | {
"resource": ""
} |
q264377 | cli | validation | def cli():
"""Create CLI environment"""
return VersionedCLI(cli_name=SF_CLI_NAME,
config_dir=SF_CLI_CONFIG_DIR,
config_env_var_prefix=SF_CLI_ENV_VAR_PREFIX,
| python | {
"resource": ""
} |
q264378 | drain_rois | validation | def drain_rois(img):
"""Find all the ROIs in img and returns a similar volume with the ROIs
emptied, keeping only their border voxels.
This is useful for DTI tractography.
Parameters
----------
img: img-like object or str
Can either be:
- a file path to a Nifti image
- any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.
If niimg is a string, consider it as a path to Nifti image and
call nibabel.load on it. If it is an object, check if get_data()
and get_affine() methods are present, raise TypeError otherwise.
Returns
-------
np.ndarray
an array of same shape | python | {
"resource": ""
} |
q264379 | largest_connected_component | validation | def largest_connected_component(volume):
"""Return the largest connected component of a 3D array.
Parameters
-----------
volume: numpy.array
3D boolean array.
Returns
--------
volume: numpy.array
3D boolean array with only one connected component.
"""
# We use asarray to be able to work with masked arrays.
volume = np.asarray(volume)
labels, num_labels = scn.label(volume)
if | python | {
"resource": ""
} |
q264380 | large_clusters_mask | validation | def large_clusters_mask(volume, min_cluster_size):
""" Return as mask for `volume` that includes only areas where
the connected components have a size bigger than `min_cluster_size`
in number of voxels.
Parameters
-----------
volume: numpy.array
3D boolean array.
min_cluster_size: int
Minimum size in voxels that the connected component | python | {
"resource": ""
} |
q264381 | create_rois_mask | validation | def create_rois_mask(roislist, filelist):
"""Look for the files in filelist containing the names in roislist, these files will be opened, binarised
and merged in one mask.
Parameters
----------
roislist: list of strings
Names of the ROIs, which will have to be in the names of the files in filelist.
filelist: list of strings
List of paths to the volume files containing the ROIs.
Returns
-------
numpy.ndarray
Mask volume
"""
roifiles = []
for roi in | python | {
"resource": ""
} |
q264382 | get_unique_nonzeros | validation | def get_unique_nonzeros(arr):
""" Return a sorted list of the non-zero unique values of arr.
Parameters
----------
arr: numpy.ndarray
The data array
Returns
-------
list of items of arr.
| python | {
"resource": ""
} |
q264383 | get_rois_centers_of_mass | validation | def get_rois_centers_of_mass(vol):
"""Get the center of mass for each ROI in the given volume.
Parameters
----------
vol: numpy ndarray
Volume with different values for each ROI.
Returns
-------
OrderedDict
Each entry in the dict has the ROI value as key and the center_of_mass coordinate as value.
"""
from scipy.ndimage.measurements import center_of_mass | python | {
"resource": ""
} |
q264384 | _partition_data | validation | def _partition_data(datavol, roivol, roivalue, maskvol=None, zeroe=True):
""" Extracts the values in `datavol` that are in the ROI with value `roivalue` in `roivol`.
The ROI can be masked by `maskvol`.
Parameters
----------
datavol: numpy.ndarray
4D timeseries volume or a 3D volume to be partitioned
roivol: numpy.ndarray
3D ROIs volume
roivalue: int or float
A value from roivol that represents the ROI to be used for extraction.
maskvol: numpy.ndarray
3D mask volume
zeroe: bool
If true will remove the null timeseries voxels. Only applied to timeseries (4D) data.
Returns
-------
values: np.array
An array of the values in the indicated ROI.
| python | {
"resource": ""
} |
q264385 | get_3D_from_4D | validation | def get_3D_from_4D(image, vol_idx=0):
"""Pick one 3D volume from a 4D nifti image file
Parameters
----------
image: img-like object or str
Volume defining different ROIs.
Can either be:
- a file path to a Nifti image
- any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.
If niimg is a string, consider it as a path to Nifti image and
call nibabel.load on it. If it is an object, check if get_data()
and get_affine() methods are present, raise TypeError otherwise.
vol_idx: int
Index of the 3D volume to be extracted from the 4D volume.
Returns
-------
vol, hdr, aff
The data array, the image header and the affine transform matrix.
"""
| python | {
"resource": ""
} |
q264386 | HdfDataBuffer.get_dataset | validation | def get_dataset(self, ds_name, mode='r'):
"""
Returns a h5py dataset given its registered name.
:param ds_name: string
Name of the dataset to be returned.
:return:
"""
| python | {
"resource": ""
} |
q264387 | HdfDataBuffer.create_empty_dataset | validation | def create_empty_dataset(self, ds_name, dtype=np.float32):
"""
Creates a Dataset with unknown size.
Resize it before using.
:param ds_name: string
:param dtype: dtype
Datatype of the dataset
:return: h5py DataSet
"""
if ds_name in self._datasets: | python | {
"resource": ""
} |
q264388 | HdfDataBuffer.create_dataset | validation | def create_dataset(self, ds_name, data, attrs=None, dtype=None):
"""
Saves a Numpy array in a dataset in the HDF file, registers it as
ds_name and returns the h5py dataset.
:param ds_name: string
Registration name of the dataset to be registered.
:param data: Numpy ndarray
:param dtype: dtype
Datatype of the dataset
:return: h5py dataset
| python | {
"resource": ""
} |
q264389 | HdfDataBuffer.save | validation | def save(self, ds_name, data, dtype=None):
"""
See create_dataset.
"""
| python | {
"resource": ""
} |
q264390 | NumpyHDFStore._fill_missing_values | validation | def _fill_missing_values(df, range_values, fill_value=0, fill_method=None):
"""
Will get the names of the index colums of df, obtain their ranges from
range_values dict and return a reindexed version of df with the given
range values.
:param df: pandas DataFrame
:param range_values: dict or array-like
Must contain for each index column of df an entry with all the values
within the range of the column.
:param fill_value: scalar or 'nearest', default 0
Value to use for missing values. Defaults to 0, but can be any
"compatible" value, e.g., NaN.
| python | {
"resource": ""
} |
q264391 | NumpyHDFStore.get | validation | def get(self, key):
"""
Retrieve pandas object or group of Numpy ndarrays
stored in file
Parameters
----------
key : object
Returns
-------
obj : type of object stored in file
"""
node = self.get_node(key)
if node is | python | {
"resource": ""
} |
q264392 | NumpyHDFStore.put | validation | def put(self, key, value, attrs=None, format=None, append=False, **kwargs):
"""
Store object in HDFStore
Parameters
----------
key : str
value : {Series, DataFrame, Panel, Numpy ndarray}
format : 'fixed(f)|table(t)', default is 'fixed'
fixed(f) : Fixed format
Fast writing/reading. Not-appendable, nor searchable
table(t) : Table format
Write as a PyTables Table structure which may perform worse but allow more flexible operations
like searching/selecting subsets of the data
append : boolean, default False
This will force Table format, append the input data to the
existing.
encoding : default None, provide an encoding for strings
"""
if not isinstance(value, np.ndarray):
super(NumpyHDFStore, self).put(key, value, | python | {
"resource": ""
} |
q264393 | NumpyHDFStore.put_df_as_ndarray | validation | def put_df_as_ndarray(self, key, df, range_values, loop_multiindex=False,
unstack=False, fill_value=0, fill_method=None):
"""Returns a PyTables HDF Array from df in the shape given by its index columns range values.
:param key: string object
:param df: pandas DataFrame
:param range_values: dict or array-like
Must contain for each index column of df an entry with all the values
within the range of the column.
:param loop_multiindex: bool
Will loop through the first index in a multiindex dataframe, extract a
dataframe only for one value, complete and fill the missing values and
store in the HDF.
If this is True, it will not use unstack.
This is as fast as unstacking.
:param unstack: bool
Unstack means that this will use the first index name to
unfold the DataFrame, and will create a group with as many datasets
as valus has this first index.
Use this if you think the filled dataframe won't fit in your RAM memory.
If set to False, this will transform the dataframe in memory first
and only then save it.
:param fill_value: scalar or 'nearest', default 0
Value to use for missing values. Defaults to 0, but can be any
"compatible" value, e.g., NaN.
The 'nearest' mode will fill the missing value with the nearest value in
the column.
:param fill_method: {'backfill', 'bfill', 'pad', 'ffill', None}, default None
Method to use for filling holes in reindexed DataFrame
'pad' / 'ffill': propagate last valid observation forward to next valid
'backfill' / 'bfill': use NEXT valid observation to fill gap
:return: PyTables data node
"""
idx_colnames = df.index.names
#idx_colranges = [range_values[x] for x in idx_colnames]
#dataset group name if not given
if key is None:
key = idx_colnames[0]
if loop_multiindex:
idx_values = df.index.get_level_values(0).unique()
for idx in idx_values:
vals, _ = self._fill_missing_values(df.xs((idx,), level=idx_colnames[0]),
range_values,
| python | {
"resource": ""
} |
q264394 | MedicalImage.smooth_fwhm | validation | def smooth_fwhm(self, fwhm):
""" Set a smoothing Gaussian kernel given its FWHM in mm. """
if fwhm != self._smooth_fwhm:
| python | {
"resource": ""
} |
q264395 | MedicalImage.apply_mask | validation | def apply_mask(self, mask_img):
"""First set_mask and the get_masked_data.
Parameters
----------
mask_img: nifti-like image, NeuroImage or str
3D mask array: True where a voxel should be used.
Can either be:
- a file path to a Nifti image
- any object with get_data() and | python | {
"resource": ""
} |
q264396 | MedicalImage.set_mask | validation | def set_mask(self, mask_img):
"""Sets a mask img to this. So every operation to self, this mask will be taken into account.
Parameters
----------
mask_img: nifti-like image, NeuroImage or str
3D mask array: True where a voxel should be used.
Can either be:
- a file path to a Nifti image
- any object with get_data() and get_affine() methods, e.g., nibabel.Nifti1Image.
If niimg is a string, consider it as a path to Nifti image and
call nibabel.load on it. If it is an object, check if get_data()
and get_affine() methods are present, raise TypeError otherwise.
| python | {
"resource": ""
} |
q264397 | MedicalImage._mask_data | validation | def _mask_data(self, data):
"""Return the data masked with self.mask
Parameters
----------
data: np.ndarray
Returns
-------
masked np.ndarray
Raises
------
ValueError if the data and mask dimensions are not compatible.
| python | {
"resource": ""
} |
q264398 | MedicalImage.apply_smoothing | validation | def apply_smoothing(self, smooth_fwhm):
"""Set self._smooth_fwhm and then smooths the data.
See boyle.nifti.smooth.smooth_imgs.
Returns
-------
the smoothed data deepcopied.
"""
if smooth_fwhm <= 0:
| python | {
"resource": ""
} |
q264399 | MedicalImage.mask_and_flatten | validation | def mask_and_flatten(self):
"""Return a vector of the masked data.
Returns
-------
np.ndarray, tuple of indices (np.ndarray), tuple of | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.