nabu.utils module

nabu.utils.nextpow2(N, dtype=<class 'numpy.int32'>)

nabu.utils.previouspow2(N, dtype=<class 'numpy.int32'>)

nabu.utils.updiv(a, b)

nabu.utils.convert_index(idx, idx_max, default_val)

Convert an index (possibly negative or None) to a non-negative integer.

Parameters:

• idx (int or None) – Index

• idx_max (int) – Maximum value (upper bound) for the index.

• default_val (int) – Default value if idx is None

Examples

Given an integer M, J = convert_index(i, M, XX) returns an integer in the mathematical range [0, M] (or Python range(0, M)). J can then be used to define an upper bound of a range.

nabu.utils.get_folder_path(foldername='')

nabu.utils.get_cuda_srcfile(filename)

nabu.utils.get_opencl_srcfile(filename)

nabu.utils.get_resource_file(filename, subfolder=None)

nabu.utils.get_available_threads()

nabu.utils.is_writeable(location)

Return True if a file/location is writeable.

nabu.utils.is_int(num, eps=1e-07)

nabu.utils.get_ftype(url)

return supposed filetype of an url

nabu.utils.get_2D_3D_shape(shape)

nabu.utils.get_subregion(sub_region)

nabu.utils.get_3D_subregion(sub_region)

nabu.utils.to_3D_array(arr)

Turn an array to a (C-Contiguous) 3D array with the layout (n_arrays, n_y, n_x).

nabu.utils.view_as_images_stack(img)

View an image (2D array) as a stack of one image (3D array). No data is duplicated.

nabu.utils.rescale_integers(items, new_tot)

” From a given sequence of integers, create a new sequence where the sum of all items must be equal to “new_tot”. The relative contribution of each item to the new total is approximately kept.

Parameters:

• items (array-like) – Sequence of integers

• new_tot (int) – Integer indicating that the sum of the new array must be equal to this value

nabu.utils.merged_shape(shapes, axis=0)

nabu.utils.is_device_backend(backend)

nabu.utils.get_decay(curve, cutoff=1000.0, vmax=None)

Assuming a decreasing curve, get the first point below a certain threshold.

Parameters:

• curve (numpy.ndarray) – A 1D array

• cutoff (float, optional) – Threshold. Default is 1000.

• vmax (float, optional) – Curve maximum value

nabu.utils.generate_powers()

Generate a list of powers of [2, 3, 5, 7], up to (2**15)*(3**9)*(5**6)*(7**5).

nabu.utils.calc_padding_lengths1D(length, length_padded)

Compute the padding lengths at both side along one dimension.

Parameters:

• length (int) – Number of elements along one dimension of the original array

• length_padded (tuple) – Number of elements along one dimension of the padded array

Returns:

pad_lengths – A tuple under the form (padding_left, padding_right). These are the lengths needed to pad the original array.

Return type:

tuple

nabu.utils.calc_padding_lengths(shape, shape_padded)

Multi-dimensional version of calc_padding_lengths1D. Please refer to the documentation of calc_padding_lengths1D.

nabu.utils.partition_dict(dict_, n_partitions)

nabu.utils.subsample_dict(dic, subsampling_factor)

Subsample a dict where keys are integers.

nabu.utils.compare_dicts(dic1, dic2)

Compare two dictionaries. Return None if and only iff the dictionaries are the same.

Parameters:

• dic1 (dict) – First dictionary

• dic2 (dict) – Second dictionary

Returns:

res –

• None: it means that dictionaries are the same

• empty string (“”): the dictionaries do not have the same keys

• nonempty string: path to the first differing items

Return type:

result which can be the following:

nabu.utils.remove_items_from_list(list_, items_to_remove)

Remove items from a list and return the removed elements.

Parameters:

• list (list) – List containing items to remove

• items_to_remove (list) – List of items to remove

Returns:

• reduced_list (list) – List with removed items

• removed_items (dict) – Dictionary where the keys are the indices of removed items, and values are the items

nabu.utils.restore_items_in_list(list_, removed_items)

Undo the effect of the function remove_items_from_list

Parameters:

• list (list) – List where items were removed

• removed_items (dict) – Dictionary where the keys are the indices of removed items, and values are the items

nabu.utils.check_supported(param_value, available, param_desc)

nabu.utils.check_supported_enum(param_value, enum_cls, param_desc)

nabu.utils.check_shape(shape, expected_shape, name)

nabu.utils.copy_dict_items(dict_, keys)

Perform a shallow copy of a subset of a dictionary. The subset if done by a list of keys.

nabu.utils.recursive_copy_dict(dict_)

Perform a shallow copy of a dictionary of dictionaries. This is NOT a deep copy ! Only reference to objects are kept.

nabu.utils.subdivide_into_overlapping_segment(N, window_width, half_overlap)

Divide a segment into a number of possibly-overlapping sub-segments.

Parameters:

• N (int) – Total segment length

• window_width (int) – Length of each segment

• half_overlap (int) – Half-length of the overlap between each sub-segment.

Returns:

segments – A list where each item is in the form (left_margin_start, inner_segment_start, inner_segment_end, right_margin_end)

Return type:

list

nabu.utils.get_num_threads(n=None)

Get a number of threads (ex. to be used by fftw). If the argument is None, returns the total number of CPU threads. If the argument is negative, the total number of available threads plus this number is returned.

Parameters:

n (int, optional) –

• If an positive integer n is provided, then n threads are used

• If a negative integer n is provided, then n_avail + n threads are used (so -1 to use all available threads minus one)

class nabu.utils.DictToObj(dictio)

Bases: object

utility class to transform a dictionary into an object with dictionary items as members. Example:

>>> a=DictToObj( dict(i=1,j=1))
... a.j+a.i

nabu.utils.remove_parenthesis_or_brackets(input_str)

clear string from left and or roght parenthesis / braquets

nabu.utils.filter_str_def(elmt)

clean elemt if is a string defined from a text file. Remove some character that could have be put on left or right and some empty spaces

nabu.utils.convert_str_to_tuple(input_str: str, none_if_empty: bool = False) → None | tuple

Parameters:

• input_str (str) – string to convert

• none_if_empty (bool) – if true and the conversion is an empty tuple return None instead of an empty tuple

class nabu.utils.Progress(name: str)

Bases: object

Simple interface for defining advancement on a 100 percentage base

set_name(name)

reset(max_: None | int = None) → None

reset the advancement to n and max advancement to max_ :param int max_:

start_process() → None

set_advancement(value: int) → None

Parameters:

value (int) – set advancement to value

end_process() → None

Set advancement to 100 %

set_max_advancement(n: int) → None

Parameters:

n (int) – number of steps contained by the advancement. When

advancement reach this value, advancement will be 100 %

increase_advancement(i: int = 1) → None

Parameters:

i (int) – increase the advancement of n step

nabu.utils.concatenate_dict(dict_1, dict_2) → dict

update dict which has dict as values. And we want concatenate those values to

nabu.utils.generate_coords(img_shp, center=None)

nabu.utils.clip_circle(img, center=None, radius=None)

nabu.utils.extend_image_onepixel(img)

nabu.utils.median2(img)

3x3 median filter for 2D arrays, with “reflect” boundary mode. Roughly same speed as scipy median filter, but more memory demanding.

nabu.utils.measure_time(func)

nabu.utils.wip(func)

nabu.utils.warning(msg)

nabu.utils.deprecated(msg, do_print=False)

nabu.utils.deprecated_class(msg, do_print=False)

nabu.utils.deprecation_warning(message, do_print=True, func_name=None)

nabu.utils.docstring(origin)

Decorator to initialize the docstring from another source.

This is useful to duplicate a docstring for inheritance and composition.

If origin is a method or a function, it copies its docstring. If origin is a class, the docstring is copied from the method of that class which has the same name as the method/function being decorated.

Parameters:

origin – The method, function or class from which to get the docstring

Raises:

ValueError – If the origin class has not method n case the