ChessAnalysisPipeline 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

CHAP/utils/general.py

@@ -26,13 +26,57 @@ from sys import float_info
 import numpy as np
 try:
     import matplotlib.pyplot as plt
-    from matplotlib.widgets import AxesWidget, RadioButtons
-    from matplotlib import cbook
 except ImportError:
     pass
 
 logger = getLogger(__name__)
 
+tiny = np.finfo(np.float64).resolution
+
+def gformat(val, length=11):
+    """
+    Format a number with '%g'-like format, while:
+      - the length of the output string will be of the requested length
+      - positive numbers will have a leading blank
+      - the precision will be as high as possible
+      - trailing zeros will not be trimmed
+    """
+    # Code taken from lmfit library
+    if val is None or isinstance(val, bool):
+        return f'{repr(val):>{length}s}'
+    try:
+        expon = int(np.log10(abs(val)))
+    except (OverflowError, ValueError):
+        expon = 0
+    except TypeError:
+        return f'{repr(val):>{length}s}'
+
+    length = max(length, 7)
+    form = 'e'
+    prec = length - 7
+    if abs(expon) > 99:
+        prec -= 1
+    elif ((expon > 0 and expon < (prec+4)) or
+          (expon <= 0 and -expon < (prec-1))):
+        form = 'f'
+        prec += 4
+        if expon > 0:
+            prec -= expon
+    return f'{val:{length}.{prec}{form}}'
+
+
+def getfloat_attr(obj, attr, length=11):
+    """Format an attribute of an object for printing."""
+    # Code taken from lmfit library
+    val = getattr(obj, attr, None)
+    if val is None:
+        return 'unknown'
+    if isinstance(val, int):
+        return f'{val}'
+    if isinstance(val, float):
+        return gformat(val, length=length).strip()
+    return repr(val)
+
 
 def depth_list(_list):
     """Return the depth of a list."""
@@ -88,6 +132,13 @@ def illegal_combination(
         raise ValueError(error_msg)
 
 
+def not_zero(value):
+    """Return value with a minimal absolute size of tiny,
+    preserving the sign.
+    """
+    return float(np.copysign(max(tiny, abs(value)), value))
+
+
 def test_ge_gt_le_lt(
         ge, gt, le, lt, func, location=None, raise_error=False, log=True):
     """
@@ -449,8 +500,8 @@ def index_nearest_down(a, value):
     return index
 
 
-def index_nearest_upp(a, value):
-    """Return index of nearest array value, rounded upp."""
+def index_nearest_up(a, value):
+    """Return index of nearest array value, rounded up."""
     a = np.asarray(a)
     if a.ndim > 1:
         raise ValueError(
@@ -479,14 +530,14 @@ def get_consecutive_int_range(a):
 
 
 def round_to_n(x, n=1):
-    """Round to a specific number of decimals."""
+    """Round to a specific number of sig figs ."""
     if x == 0.0:
         return 0
     return type(x)(round(x, n-1-int(np.floor(np.log10(abs(x))))))
 
 
 def round_up_to_n(x, n=1):
-    """Round up to a specific number of decimals."""
+    """Round up to a specific number of sig figs."""
     x_round = round_to_n(x, n)
     if abs(x/x_round) > 1.0:
         x_round += np.sign(x) * 10**(np.floor(np.log10(abs(x)))+1-n)
@@ -494,7 +545,7 @@ def round_up_to_n(x, n=1):
 
 
 def trunc_to_n(x, n=1):
-    """Truncate to a specific number of decimals."""
+    """Truncate to a specific number of sig figs."""
     x_round = round_to_n(x, n)
     if abs(x_round/x) > 1.0:
         x_round -= np.sign(x) * 10**(np.floor(np.log10(abs(x)))+1-n)
@@ -512,7 +563,9 @@ def almost_equal(a, b, sig_figs):
         f'b: {b}, {type(b)})')
 
 
-def string_to_list(s, split_on_dash=True, remove_duplicates=True, sort=True):
+def string_to_list(
+        s, split_on_dash=True, remove_duplicates=True, sort=True,
+        raise_error=False):
     """
     Return a list of numbers by splitting/expanding a string on any
     combination of commas, whitespaces, or dashes (when
@@ -526,8 +579,11 @@ def string_to_list(s, split_on_dash=True, remove_duplicates=True, sort=True):
         return []
     try:
         list1 = re_split(r'\s+,\s+|\s+,|,\s+|\s+|,', s.strip())
-    except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError):
-        return None
+    except (ValueError, TypeError, SyntaxError, MemoryError,
+            RecursionError) as e:
+        if not raise_error:
+            return None
+        raise e
     if split_on_dash:
         try:
             l_of_i = []
@@ -542,8 +598,10 @@ def string_to_list(s, split_on_dash=True, remove_duplicates=True, sort=True):
                 else:
                     raise ValueError
         except (ValueError, TypeError, SyntaxError, MemoryError,
-                RecursionError):
-            return None
+                RecursionError) as e:
+            if not raise_error:
+                return None
+            raise e
     else:
         l_of_i = [literal_eval(x) for x in list1]
     if remove_duplicates:
@@ -655,8 +713,8 @@ def _input_int_or_num(
 
 
 def input_int_list(
-        s=None, ge=None, le=None, split_on_dash=True, remove_duplicates=True,
-        sort=True, raise_error=False, log=True):
+        s=None, num_max=None, ge=None, le=None, split_on_dash=True,
+        remove_duplicates=True, sort=True, raise_error=False, log=True):
     """
     Prompt the user to input a list of interger and split the entered
     string on any combination of commas, whitespaces, or dashes (when
@@ -669,13 +727,13 @@ def input_int_list(
     return None upon an illegal input
     """
     return _input_int_or_num_list(
-        'int', s, ge, le, split_on_dash, remove_duplicates, sort, raise_error,
-        log)
+        'int', s, num_max, ge, le, split_on_dash, remove_duplicates, sort,
+        raise_error, log)
 
 
 def input_num_list(
-        s=None, ge=None, le=None, remove_duplicates=True, sort=True,
-        raise_error=False, log=True):
+        s=None, num_max=None, ge=None, le=None, remove_duplicates=True,
+        sort=True, raise_error=False, log=True):
     """
     Prompt the user to input a list of numbers and split the entered
     string on any combination of commas or whitespaces.
@@ -687,11 +745,12 @@ def input_num_list(
     return None upon an illegal input
     """
     return _input_int_or_num_list(
-        'num', s, ge, le, False, remove_duplicates, sort, raise_error, log)
+        'num', s, num_max, ge, le, False, remove_duplicates, sort, raise_error,
+        log)
 
 
 def _input_int_or_num_list(
-        type_str, s=None, ge=None, le=None, split_on_dash=True,
+        type_str, s=None, num_max=None, ge=None, le=None, split_on_dash=True,
         remove_duplicates=True, sort=True, raise_error=False, log=True):
     # RV do we want a limit on max dimension?
     if type_str == 'int':
@@ -707,6 +766,9 @@ def _input_int_or_num_list(
     else:
         illegal_value(type_str, 'type_str', '_input_int_or_num_list')
         return None
+    if (num_max is not None
+            and not is_int(num_max, gt=0, raise_error=raise_error, log=log)):
+        return None
     v_range = f'{range_string_ge_gt_le_lt(ge=ge, le=le)}'
     if v_range:
         v_range = f' (each value in {v_range})'
@@ -721,14 +783,17 @@ def _input_int_or_num_list(
     except:
         print('Unexpected error')
         raise
-    if (not isinstance(_list, list) or any(
-            not _is_int_or_num(v, type_str, ge=ge, le=le) for v in _list)):
+    if (not isinstance(_list, list)
+            or (num_max is not None and len(_list) > num_max)
+            or any(
+                not _is_int_or_num(v, type_str, ge=ge, le=le) for v in _list)):
+        num = '' if num_max is None else f'up to {num_max} '
         if split_on_dash:
-            print('Invalid input: enter a valid set of dash/comma/whitespace '
-                  'separated integers e.g. 1 3,5-8 , 12')
+            print(f'Invalid input: enter a valid set of {num}dash/comma/'
+                  'whitespace separated numbers e.g. 1 3,5-8 , 12')
         else:
-            print('Invalid input: enter a valid set of comma/whitespace '
-                  'separated integers e.g. 1 3,5 8 , 12')
+            print(f'Invalid input: enter a valid set of {num}comma/whitespace '
+                  'separated numbers e.g. 1 3,5 8 , 12')
         _list = _input_int_or_num_list(
             type_str, s, ge, le, split_on_dash, remove_duplicates, sort,
             raise_error, log)
@@ -897,11 +962,255 @@ def file_exists_and_readable(f):
     return f
 
 
+def rolling_average(
+        y, x=None, dtype=None, start=0, end=None, width=None,
+        stride=None, num=None, average=True, mode='valid',
+        use_convolve=None):
+    """
+    Returns the rolling sum or average of an array over the last
+    dimension.
+    """
+    y = np.asarray(y)
+    y_shape = y.shape
+    if y.ndim == 1:
+        y = np.expand_dims(y, 0)
+    else:
+        y = y.reshape((np.prod(y.shape[0:-1]), y.shape[-1]))
+    if x is not None:
+        x = np.asarray(x)
+        if x.ndim != 1:
+            raise ValueError('Parameter "x" must be a 1D array-like')
+        if x.size != y.shape[1]:
+            raise ValueError(f'Dimensions of "x" and "y[1]" do not '
+                             f'match ({x.size} vs {y.shape[1]})')
+    if dtype is None:
+        if average:
+            dtype = y.dtype
+        else:
+            dtype = np.float32
+    if width is None and stride is None and num is None:
+        raise ValueError('Invalid input parameters, specify at least one of '
+                         '"width", "stride" or "num"')
+    if width is not None and not is_int(width, ge=1):
+        raise ValueError(f'Invalid "width" parameter ({width})')
+    if stride is not None and not is_int(stride, ge=1):
+        raise ValueError(f'Invalid "stride" parameter ({stride})')
+    if num is not None and not is_int(num, ge=1):
+        raise ValueError(f'Invalid "num" parameter ({num})')
+    if not isinstance(average, bool):
+        raise ValueError(f'Invalid "average" parameter ({average})')
+    if mode not in ('valid', 'full'):
+        raise ValueError(f'Invalid "mode" parameter ({mode})')
+    size = y.shape[1]
+    if size < 2:
+        raise ValueError(f'Invalid y[1] dimension ({size})')
+    if not is_int(start, ge=0, lt=size):
+        raise ValueError(f'Invalid "start" parameter ({start})')
+    if end is None:
+        end = size
+    elif not is_int(end, gt=start, le=size):
+        raise ValueError(f'Invalid "end" parameter ({end})')
+    if use_convolve is None:
+        if len(y_shape) ==1:
+            use_convolve = True
+        else:
+            use_convolve = False
+    if use_convolve and (start or end < size):
+        y = np.take(y, range(start, end), axis=1)
+        if x is not None:
+            x = x[start:end]
+        size = y.shape[1]
+    else:
+        size = end-start
+
+    if stride is None:
+        if width is None:
+            width = max(1, int(size/num))
+            stride = width
+        else:
+            width = min(width, size)
+            if num is None:
+                stride = width
+            else:
+                stride = max(1, int((size-width) / (num-1)))
+    else:
+        stride = min(stride, size-stride)
+        if width is None:
+            width = stride
+
+    if mode == 'valid':
+        num = 1 + max(0, int((size-width) / stride))
+    else:
+        num = int(size/stride)
+        if num*stride < size:
+            num += 1
+
+    if use_convolve:
+        n_start = 0
+        n_end = width
+        weight = np.empty((num))
+        for n in range(num):
+            n_num = n_end-n_start
+            weight[n] = n_num
+            n_start += stride
+            n_end = min(size, n_end+stride)
+
+        window = np.ones((width))
+        if x is not None:
+            if mode == 'valid':
+                rx = np.convolve(x, window)[width-1:1-width:stride]
+            else:
+                rx = np.convolve(x, window)[width-1::stride]
+            rx /= weight
+
+        ry = []
+        if mode == 'valid':
+            for i in range(y.shape[0]):
+                ry.append(np.convolve(y[i], window)[width-1:1-width:stride])
+        else:
+            for i in range(y.shape[0]):
+                ry.append(np.convolve(y[i], window)[width-1::stride])
+        ry = np.reshape(ry, (*y_shape[0:-1], num))
+        if len(y_shape) == 1:
+            ry = np.squeeze(ry)
+        if average:
+            ry = (np.asarray(ry).astype(np.float32)/weight).astype(dtype)
+        elif mode != 'valid':
+            weight = np.where(weight < width, width/weight, 1.0)
+            ry = (np.asarray(ry).astype(np.float32)*weight).astype(dtype)
+    else:
+        ry = np.zeros((num, y.shape[0]), dtype=y.dtype)
+        if x is not None:
+            rx = np.zeros(num, dtype=x.dtype)
+        n_start = start
+        n_end = n_start+width
+        for n in range(num):
+            y_sum = np.sum(y[:,n_start:n_end], 1)
+            n_num = n_end-n_start
+            if n_num < width:
+                y_sum *= width/n_num
+            ry[n] = y_sum
+            if x is not None:
+                rx[n] = np.sum(x[n_start:n_end])/n_num
+            n_start += stride
+            n_end = min(start+size, n_end+stride)
+        ry = np.reshape(ry.T, (*y_shape[0:-1], num))
+        if len(y_shape) == 1:
+            ry = np.squeeze(ry)
+        if average:
+            ry = (ry.astype(np.float32)/width).astype(dtype)
+
+    if x is None:
+        return ry
+    return ry, rx
+
+
+def baseline_arPLS(
+        y, mask=None, w=None, tol=1.e-8, lam=1.e6, max_iter=20,
+        full_output=False):
+    """Returns the smoothed baseline estimate of a spectrum.
+
+    Based on S.-J. Baek, A. Park, Y.-J Ahn, and J. Choo,
+    "Baseline correction using asymmetrically reweighted penalized
+    least squares smoothing", Analyst, 2015,140, 250-257
+
+    :param y: The spectrum.
+    :type y: array-like
+    :param mask: A mask to apply to the spectrum before baseline
+       construction, default to `None`.
+    :type mask: array-like, optional
+    :param w: The weights (allows restart for additional ieterations),
+        defaults to None.
+    :type w: numpy.array, optional
+    :param tol: The convergence tolerence, defaults to `1.e-8`.
+    :type tol: float, optional
+    :param lam: The &lambda (smoothness) parameter (the balance
+        between the residual of the data and the baseline and the
+        smoothness of the baseline). The suggested range is between
+        100 and 10^8, defaults to `10^6`.
+    :type lam: float, optional
+    :param max_iter: The maximum number of iterations,
+        defaults to `20`.
+    :type max_iter: int, optional
+    :param full_output: Whether or not to also output the baseline
+        corrected spectrum, the number of iterations and error in the
+        returned result, defaults to `False`.
+    :type full_output: bool, optional
+    :return: The smoothed baseline, with optionally the baseline
+        corrected spectrum, the weights, the number of iterations and
+        the error in the returned result.
+    :rtype: numpy.array [, numpy.array, int, float]
+    """
+    # With credit to: Daniel Casas-Orozco
+    # https://stackoverflow.com/questions/29156532/python-baseline-correction-library
+    # System modules
+    from sys import float_info
+
+    # Third party modules
+    from scipy.sparse import (
+        spdiags,
+        linalg,
+    )
+
+    if not is_num(tol, gt=0):
+        raise ValueError(f'Invalid tol parameter ({tol})')
+    if not is_num(lam, gt=0):
+        raise ValueError(f'Invalid lam parameter ({lam})')
+    if not is_int(max_iter, gt=0):
+        raise ValueError(f'Invalid max_iter parameter ({max_iter})')
+    if not isinstance(full_output, bool):
+        raise ValueError(f'Invalid full_output parameter ({max_iter})')
+    y = np.asarray(y)
+    if mask is not None:
+        mask = mask.astype(bool)
+        y_org = y
+        y = y[mask]
+    num = y.size
+
+    diag = np.ones((num-2))
+    D = spdiags([diag, -2*diag, diag], [0, -1, -2], num, num-2)
+
+    H = lam * D.dot(D.T)
+
+    if w is None:
+        w = np.ones(num)
+    W = spdiags(w, 0, num, num)
+
+    error = 1
+    num_iter = 0
+
+    exp_max = int(np.log(float_info.max))
+    while error > tol and num_iter < max_iter:
+        z = linalg.spsolve(W + H, W * y)
+        d = y - z
+        dn = d[d < 0]
+
+        m = np.mean(dn)
+        s = np.std(dn)
+
+        w_new = 1.0 / (1.0 + np.exp(
+            np.clip(2.0 * (d - (2.0*s - m))/s, None, exp_max)))
+        error = np.linalg.norm(w_new - w) / np.linalg.norm(w)
+        num_iter += 1
+        w = w_new
+        W.setdiag(w)
+
+    if mask is not None:
+        zz = np.zeros(y_org.size)
+        zz[mask] = z
+        z = zz
+        if full_output:
+            d = y_org - z
+    if full_output:
+        return z, d, w, num_iter, float(error)
+    return z
+
+
 def select_mask_1d(
         y, x=None, label=None, ref_data=[], preselected_index_ranges=None,
         preselected_mask=None, title=None, xlabel=None, ylabel=None,
         min_num_index_ranges=None, max_num_index_ranges=None,
-        interactive=True):
+        interactive=True, filename=None):
     """Display a lineplot and have the user select a mask.
 
     :param y: One-dimensional data array for which a mask will be
@@ -940,18 +1249,21 @@ def select_mask_1d(
         ranges, defaults to `None`.
     :type max_num_index_ranges: int, optional
     :param interactive: Show the plot and allow user interactions with
-        the matplotlib figure, defults to `True`.
+        the matplotlib figure, defaults to `True`.
     :type interactive: bool, optional
-    :return: A Matplotlib figure, a boolean mask array and the list of
-        selected index ranges.
-    :rtype: matplotlib.figure.Figure, numpy.ndarray,
-        list[tuple(int, int)]
+    :param filename: Save a .png of the plot to filename, defaults to
+        `None`, in which case the plot is not saved.
+    :type filename: str, optional
+    :return: A boolean mask array and the list of selected index
+        ranges.
+    :rtype: numpy.ndarray, list[tuple(int, int)]
     """
     # Third party modules
-    from matplotlib.patches import Patch
-    from matplotlib.widgets import Button, SpanSelector
+    if interactive or filename is not None:
+        from matplotlib.patches import Patch
+        from matplotlib.widgets import Button, SpanSelector
 
-    # local modules
+    # Local modules
     from CHAP.utils.general import index_nearest
 
     def change_fig_title(title):
@@ -1105,23 +1417,26 @@ def select_mask_1d(
                        for v in preselected_index_ranges)):
             raise ValueError('Invalid parameter preselected_index_ranges '
                              f'({preselected_index_ranges})')
-        if (min_num_index_ranges is not None
-                and len(preselected_index_ranges) < min_num_index_ranges):
-            raise ValueError(
-                'Invalid parameter preselected_index_ranges '
-                f'({preselected_index_ranges}), number of selected index '
-                f'ranges must be >= {min_num_index_ranges}')
-        if (max_num_index_ranges is not None
-                and len(preselected_index_ranges) > max_num_index_ranges):
-            raise ValueError(
-                'Invalid parameter preselected_index_ranges '
-                f'({preselected_index_ranges}), number of selected index '
-                f'ranges must be <= {max_num_index_ranges}')
+
+    # Setup the preselected mask and index ranges if provided
+    if preselected_mask is not None:
+        preselected_index_ranges = update_index_ranges(
+            update_mask(
+                np.copy(np.asarray(preselected_mask, dtype=bool)),
+                preselected_index_ranges))
+
+    if not interactive and filename is None:
+
+        # Update the mask with the preselected index ranges
+        selected_mask = update_mask(len(x)*[False], preselected_index_ranges)
+
+        return selected_mask, preselected_index_ranges
 
     spans = []
     fig_title = []
     error_texts = []
 
+    # Setup the Matplotlib figure
     title_pos = (0.5, 0.95)
     title_props = {'fontsize': 'xx-large', 'horizontalalignment': 'center',
                    'verticalalignment': 'bottom'}
@@ -1145,12 +1460,7 @@ def select_mask_1d(
     ax.set_xlim(x[0], x[-1])
     fig.subplots_adjust(bottom=0.0, top=0.85)
 
-    # Setup the preselected mask and index ranges if provided
-    if preselected_mask is not None:
-        preselected_index_ranges = update_index_ranges(
-            update_mask(
-                np.copy(np.asarray(preselected_mask, dtype=bool)),
-                preselected_index_ranges))
+    # Add the preselected index ranges
     for min_, max_ in preselected_index_ranges:
         add_span(None, xrange_init=(x[min_], x[min(max_, num_data-1)]))
 
@@ -1165,7 +1475,8 @@ def select_mask_1d(
         fig.subplots_adjust(bottom=0.2)
 
         # Setup "Add span" button
-        add_span_btn = Button(plt.axes([0.15, 0.05, 0.15, 0.075]), 'Add span')
+        add_span_btn = Button(
+            plt.axes([0.15, 0.05, 0.15, 0.075]), 'Add span')
         add_span_cid = add_span_btn.on_clicked(add_span)
 
         # Setup "Reset" button
@@ -1191,21 +1502,22 @@ def select_mask_1d(
         plt.subplots_adjust(bottom=0.0)
 
     selected_index_ranges = get_selected_index_ranges()
-    if not selected_index_ranges:
-        selected_index_ranges = None
 
     # Update the mask with the currently selected index ranges
     selected_mask = update_mask(len(x)*[False], selected_index_ranges)
 
-    fig_title[0].set_in_layout(True)
-    fig.tight_layout(rect=(0, 0, 1, 0.95))
+    if filename is not None:
+        fig_title[0].set_in_layout(True)
+        fig.tight_layout(rect=(0, 0, 1, 0.95))
+        fig.savefig(filename)
+    plt.close()
 
-    return fig, selected_mask, selected_index_ranges
+    return selected_mask, selected_index_ranges
 
 
 def select_roi_1d(
         y, x=None, preselected_roi=None, title=None, xlabel=None, ylabel=None,
-        interactive=True):
+        interactive=True, filename=None):
     """Display a 2D plot and have the user select a single region
     of interest.
 
@@ -1226,8 +1538,11 @@ def select_roi_1d(
         defaults to `None`.
     :type ylabel: str, optional
     :param interactive: Show the plot and allow user interactions with
-        the matplotlib figure, defults to `True`.
+        the matplotlib figure, defaults to `True`.
     :type interactive: bool, optional
+    :param filename: Save a .png of the plot to filename, defaults to
+        `None`, in which case the plot is not saved.
+    :type filename: str, optional
     :return: The selected region of interest as array indices and a
         matplotlib figure.
     :rtype: matplotlib.figure.Figure, tuple(int, int)
@@ -1242,16 +1557,17 @@ def select_roi_1d(
                              f'({preselected_roi})')
         preselected_roi = [preselected_roi]
 
-    fig, mask, roi = select_mask_1d(
+    mask, roi = select_mask_1d(
         y, x=x, preselected_index_ranges=preselected_roi, title=title,
         xlabel=xlabel, ylabel=ylabel, min_num_index_ranges=1,
-        max_num_index_ranges=1, interactive=interactive)
+        max_num_index_ranges=1, interactive=interactive, filename=filename)
 
-    return fig, tuple(roi[0])
+    return tuple(roi[0])
 
 def select_roi_2d(
         a, preselected_roi=None, title=None, title_a=None,
-        row_label='row index', column_label='column index', interactive=True):
+        row_label='row index', column_label='column index', interactive=True,
+        filename=None):
     """Display a 2D image and have the user select a single rectangular
        region of interest.
 
@@ -1274,12 +1590,15 @@ def select_roi_2d(
     :param interactive: Show the plot and allow user interactions with
         the matplotlib figure, defaults to `True`.
     :type interactive: bool, optional
-    :return: The selected region of interest as array indices and a
-        matplotlib figure.
-    :rtype: matplotlib.figure.Figure, tuple(int, int, int, int)
+    :param filename: Save a .png of the plot to filename, defaults to
+        `None`, in which case the plot is not saved.
+    :type filename: str, optional
+    :return: The selected region of interest as array indices.
+    :rtype: tuple(int, int, int, int)
     """
     # Third party modules
-    from matplotlib.widgets import Button, RectangleSelector
+    if interactive or filename is not None:
+        from matplotlib.widgets import Button, RectangleSelector
 
     # Local modules
     from CHAP.utils.general import index_nearest
@@ -1290,46 +1609,52 @@ def select_roi_2d(
             fig_title.pop()
         fig_title.append(plt.figtext(*title_pos, title, **title_props))
 
-    def change_error_text(error):
-        if error_texts:
-            error_texts[0].remove()
-            error_texts.pop()
-        error_texts.append(plt.figtext(*error_pos, error, **error_props))
+    def change_subfig_title(error):
+        if subfig_title:
+            subfig_title[0].remove()
+            subfig_title.pop()
+        subfig_title.append(plt.figtext(*error_pos, error, **error_props))
+
+    def clear_selection():
+        rects[0].set_visible(False)
+        rects.pop()
+        rects.append(
+            RectangleSelector(
+                ax, on_rect_select, props=rect_props,
+                useblit=True, interactive=interactive, drag_from_anywhere=True,
+                ignore_event_outside=False))
 
     def on_rect_select(eclick, erelease):
         """Callback function for the RectangleSelector widget."""
-        change_error_text(
-            f'Selected ROI: {tuple(int(v) for v in rects[0].extents)}')
+        if (not int(rects[0].extents[1]) - int(rects[0].extents[0]) 
+                or not int(rects[0].extents[3]) - int(rects[0].extents[2])):
+            clear_selection()
+            change_subfig_title(
+                f'Selected ROI too small, try again')
+        else:
+            change_subfig_title(
+                f'Selected ROI: {tuple(int(v) for v in rects[0].extents)}')
         plt.draw()
 
     def reset(event):
         """Callback function for the "Reset" button."""
-        if error_texts:
-            error_texts[0].remove()
-            error_texts.pop()
-        rects[0].set_visible(False)
-        rects.pop()
-        rects.append(
-            RectangleSelector(
-                ax, on_rect_select, props=rect_props, useblit=True,
-                interactive=interactive, drag_from_anywhere=True,
-                ignore_event_outside=False))
+        if subfig_title:
+            subfig_title[0].remove()
+            subfig_title.pop()
+        clear_selection()
         plt.draw()
 
     def confirm(event):
         """Callback function for the "Confirm" button."""
-        if error_texts:
-            error_texts[0].remove()
-            error_texts.pop()
+        if subfig_title:
+            subfig_title[0].remove()
+            subfig_title.pop()
         roi = tuple(int(v) for v in rects[0].extents)
         if roi[1]-roi[0] < 1 or roi[3]-roi[2] < 1:
             roi = None
         change_fig_title(f'Selected ROI: {roi}')
         plt.close()
 
-    fig_title = []
-    error_texts = []
-
     # Check inputs
     a = np.asarray(a)
     if a.ndim != 2:
@@ -1342,6 +1667,12 @@ def select_roi_2d(
     if title is None:
         title = 'Click and drag to select or adjust a region of interest (ROI)'
 
+    if not interactive and filename is None:
+        return preselected_roi
+
+    fig_title = []
+    subfig_title = []
+
     title_pos = (0.5, 0.95)
     title_props = {'fontsize': 'xx-large', 'horizontalalignment': 'center',
                    'verticalalignment': 'bottom'}
@@ -1370,14 +1701,15 @@ def select_roi_2d(
 
     if not interactive:
 
-        change_fig_title(
-            f'Selected ROI: {tuple(int(v) for v in preselected_roi)}')
+        if preselected_roi is not None:
+            change_fig_title(
+                f'Selected ROI: {tuple(int(v) for v in preselected_roi)}')
 
     else:
 
         change_fig_title(title)
         if preselected_roi is not None:
-            change_error_text(
+            change_subfig_title(
                 f'Preselected ROI: {tuple(int(v) for v in preselected_roi)}')
         fig.subplots_adjust(bottom=0.2)
 
@@ -1400,20 +1732,26 @@ def select_roi_2d(
         reset_btn.ax.remove()
         confirm_btn.ax.remove()
 
-    fig_title[0].set_in_layout(True)
-    fig.tight_layout(rect=(0, 0, 1, 0.95))
+    if filename is not None:
+        if fig_title:
+            fig_title[0].set_in_layout(True)
+            fig.tight_layout(rect=(0, 0, 1, 0.95))
+        else:
+            fig.tight_layout(rect=(0, 0, 1, 1))
 
-    # Remove the handles before returning the figure
-    if interactive:
-        rects[0]._center_handle.set_visible(False)
-        rects[0]._corner_handles.set_visible(False)
-        rects[0]._edge_handles.set_visible(False)
+        # Remove the handles
+        if interactive:
+            rects[0]._center_handle.set_visible(False)
+            rects[0]._corner_handles.set_visible(False)
+            rects[0]._edge_handles.set_visible(False)
+        fig.savefig(filename)
+    plt.close()
 
     roi = tuple(int(v) for v in rects[0].extents)
     if roi[1]-roi[0] < 1 or roi[3]-roi[2] < 1:
         roi = None
 
-    return fig, roi
+    return roi
 
 
 def select_image_indices(
@@ -1436,7 +1774,7 @@ def select_image_indices(
     :param preselected_indices: Preselected image indices,
         defaults to `None`.
     :type preselected_indices: tuple(int), list(int), optional
-    :param axis_index_offset: Offset in axes index range and
+    :param axis_index_offset: Offset in axis index range and
         preselected indices, defaults to `0`.
     :type axis_index_offset: int, optional
     :param min_range: The minimal range spanned by the selected 
@@ -1535,7 +1873,7 @@ def select_image_indices(
         try:
             index = int(expression)
             if (index < axis_index_offset
-                    or index >= axis_index_offset+a.shape[axis]):
+                    or index > axis_index_offset+a.shape[axis]):
                 raise ValueError
         except ValueError:
             change_error_text(
@@ -1872,3 +2210,128 @@ def quick_plot(
         if save_fig:
             plt.savefig(path)
         plt.show(block=block)
+
+
+def nxcopy(
+        nxobject, exclude_nxpaths=None, nxpath_prefix=None,
+        nxpathabs_prefix=None, nxpath_copy_abspath=None):
+    """
+    Function that returns a copy of a nexus object, optionally exluding
+    certain child items.
+
+    :param nxobject: The input nexus object to "copy".
+    :type nxobject: nexusformat.nexus.NXobject
+    :param exlude_nxpaths: A list of relative paths to child nexus
+        objects that should be excluded from the returned "copy",
+        defaults to `[]`.
+    :type exclude_nxpaths: str, list[str], optional
+    :param nxpath_prefix: For use in recursive calls from inside this
+        function only.
+    :type nxpath_prefix: str
+    :param nxpathabs_prefix: For use in recursive calls from inside this
+        function only.
+    :type nxpathabs_prefix: str
+    :param nxpath_copy_abspath: For use in recursive calls from inside this
+        function only.
+    :type nxpath_copy_abspath: str
+    :return: Copy of the input `nxobject` with some children optionally
+        exluded.
+    :rtype: nexusformat.nexus.NXobject
+    """
+    # Third party modules
+    from nexusformat.nexus import (
+        NXentry,
+        NXfield,
+        NXgroup,
+        NXlink,
+        NXlinkgroup,
+        NXroot,
+    )
+
+
+    if isinstance(nxobject, NXlinkgroup):
+        # The top level nxobject is a linked group
+        # Create a group with the same name as the top level's target
+        nxobject_copy = nxobject[nxobject.nxtarget].__class__(
+            name=nxobject.nxname)
+    elif isinstance(nxobject, (NXlink, NXfield)):
+        # The top level nxobject is a (linked) field: return a copy
+        attrs = nxobject.attrs
+        attrs.pop('target', None)
+        nxobject_copy = NXfield(
+            value=nxobject.nxdata, name=nxobject.nxname,
+            attrs=attrs)
+        return nxobject_copy
+    else:
+        # Create a group with the same type/name as the nxobject
+        nxobject_copy = nxobject.__class__(name=nxobject.nxname)
+
+    # Copy attributes
+    if isinstance(nxobject, NXroot):
+        if 'default' in nxobject.attrs:
+            nxobject_copy.attrs['default'] = nxobject.default
+    else:
+        for k, v in nxobject.attrs.items():
+            nxobject_copy.attrs[k] = v
+
+    # Setup paths
+    if exclude_nxpaths is None:
+        exclude_nxpaths = []
+    elif isinstance(exclude_nxpaths, str):
+        exclude_nxpaths = [exclude_nxpaths]
+    for exclude_nxpath in exclude_nxpaths:
+        if exclude_nxpath[0] == '/':
+            raise ValueError(
+                f'Invalid parameter in exclude_nxpaths ({exclude_nxpaths}), '
+                'excluded paths should be relative')
+    if nxpath_prefix is None:
+        nxpath_prefix = ''
+    if nxpathabs_prefix is None:
+        if isinstance(nxobject, NXentry):
+            nxpathabs_prefix = nxobject.nxpath
+        else:
+            nxpathabs_prefix = nxobject.nxpath.removesuffix(nxobject.nxname)
+    if nxpath_copy_abspath is None:
+        nxpath_copy_abspath = ''
+
+    # Loop over all nxobject's children
+    for k, v in nxobject.items():
+        nxpath = os_path.join(nxpath_prefix, k)
+        nxpathabs = os_path.join(nxpathabs_prefix, nxpath)
+        if nxpath in exclude_nxpaths:
+            if 'default' in nxobject_copy.attrs and nxobject_copy.default == k:
+                nxobject_copy.attrs.pop('default')
+            continue
+        if isinstance(v, NXlinkgroup):
+            if nxpathabs == v.nxpath and not any(
+                    v.nxtarget.startswith(os_path.join(nxpathabs_prefix, p))
+                    for p in exclude_nxpaths):
+                nxobject_copy[k] = NXlink(v.nxtarget)
+            else:
+                nxobject_copy[k] = nxcopy(
+                    v, exclude_nxpaths=exclude_nxpaths,
+                    nxpath_prefix=nxpath, nxpathabs_prefix=nxpathabs_prefix,
+                    nxpath_copy_abspath=os_path.join(nxpath_copy_abspath, k))
+        elif isinstance(v, NXlink):
+            if nxpathabs == v.nxpath and not any(
+                    v.nxtarget.startswith(os_path.join(nxpathabs_prefix, p))
+                    for p in exclude_nxpaths):
+                nxobject_copy[k] = v
+            else:
+                nxobject_copy[k] = v.nxdata
+                for kk, vv in v.attrs.items():
+                    nxobject_copy[k].attrs[kk] = vv
+                nxobject_copy[k].attrs.pop('target', None)
+        elif isinstance(v, NXgroup):
+            nxobject_copy[k] = nxcopy(
+                v, exclude_nxpaths=exclude_nxpaths,
+                nxpath_prefix=nxpath, nxpathabs_prefix=nxpathabs_prefix,
+                nxpath_copy_abspath=os_path.join(nxpath_copy_abspath, k))
+        else:
+            nxobject_copy[k] = v.nxdata
+            for kk, vv in v.attrs.items():
+                nxobject_copy[k].attrs[kk] = vv
+            if nxpathabs != os_path.join(nxpath_copy_abspath, k):
+                nxobject_copy[k].attrs.pop('target', None)
+
+    return nxobject_copy