MNT: Remove volumeutils functions deprecated at 3.0

Author: effigies

nibabel/tests/test_volumeutils.py

@@ -30,9 +30,6 @@
                            array_to_file,
                            allopen,  # for backwards compatibility
                            fname_ext_ul_case,
-                           calculate_scale,  # Deprecated
-                           can_cast,  # Deprecated
-                           scale_min_max,  # Deprecated
                            write_zeros,
                            seek_tell,
                            apply_read_scaling,
@@ -68,15 +65,6 @@
 NUMERIC_TYPES = CFLOAT_TYPES + IUINT_TYPES
 
 
-def test_deprecated_functions():
-    with pytest.raises(ExpiredDeprecationError):
-        scale_min_max(0, 1, np.uint8, True)
-    with pytest.raises(ExpiredDeprecationError):
-        calculate_scale(np.array([-2, -1], dtype=np.int8), np.uint8, True)
-    with pytest.raises(ExpiredDeprecationError):
-        can_cast(np.float32, np.float32)
-
-
 def test__is_compressed_fobj():
     # _is_compressed helper function
     with InTemporaryDirectory():

nibabel/volumeutils.py

@@ -18,7 +18,7 @@
 
 import numpy as np
 
-from .casting import (shared_range, type_info, OK_FLOATS)
+from .casting import shared_range, OK_FLOATS
 from .openers import Opener, BZ2File, IndexedGzipFile
 from .deprecated import deprecate_with_version
 from .externals.oset import OrderedSet
@@ -372,74 +372,6 @@ def make_dt_codes(codes_seqs):
     return Recoder(dt_codes, fields + ['dtype', 'sw_dtype'], DtypeMapper)
 
 
-@deprecate_with_version('can_cast deprecated. '
-                        'Please use arraywriter classes instead',
-                        '1.2',
-                        '3.0')
-def can_cast(in_type, out_type, has_intercept=False, has_slope=False):
-    """ Return True if we can safely cast ``in_type`` to ``out_type``
-
-    Parameters
-    ----------
-    in_type : numpy type
-       type of data we will case from
-    out_dtype : numpy type
-       type that we want to cast to
-    has_intercept : bool, optional
-       Whether we can subtract a constant from the data (before scaling)
-       before casting to ``out_dtype``.  Default is False
-    has_slope : bool, optional
-       Whether we can use a scaling factor to adjust slope of
-       relationship of data to data in cast array.  Default is False
-
-    Returns
-    -------
-    tf : bool
-       True if we can safely cast, False otherwise
-
-    Examples
-    --------
-    >>> can_cast(np.float64, np.float32)  # doctest: +SKIP
-    True
-    >>> can_cast(np.complex128, np.float32)  # doctest: +SKIP
-    False
-    >>> can_cast(np.int64, np.float32)  # doctest: +SKIP
-    True
-    >>> can_cast(np.float32, np.int16)  # doctest: +SKIP
-    False
-    >>> can_cast(np.float32, np.int16, False, True)  # doctest: +SKIP
-    True
-    >>> can_cast(np.int16, np.uint8)  # doctest: +SKIP
-    False
-
-    Whether we can actually cast int to uint when we don't have an intercept
-    depends on the data.  That's why this function isn't very useful. But we
-    assume that an integer is using its full range, and check whether scaling
-    works in that situation.
-
-    Here we need an intercept to scale the full range of an int to a uint
-
-    >>> can_cast(np.int16, np.uint8, False, True)  # doctest: +SKIP
-    False
-    >>> can_cast(np.int16, np.uint8, True, True)  # doctest: +SKIP
-    True
-    """
-    in_dtype = np.dtype(in_type)
-    # Whether we can cast depends on the data, and we've only got the type.
-    # Let's assume integers use all of their range but floats etc not
-    if in_dtype.kind in 'iu':
-        info = np.iinfo(in_dtype)
-        data = np.array([info.min, info.max], dtype=in_dtype)
-    else:  # Float or complex or something. Any old thing will do
-        data = np.ones((1,), in_type)
-    from .arraywriters import make_array_writer, WriterError
-    try:
-        make_array_writer(data, out_type, has_slope, has_intercept)
-    except WriterError:
-        return False
-    return True
-
-
 def _is_compressed_fobj(fobj):
     """ Return True if fobj represents a compressed data file-like object
     """
@@ -1005,154 +937,6 @@ def working_type(in_type, slope=1.0, inter=0.0):
     return val.dtype.type
 
 
-@deprecate_with_version('calculate_scale deprecated. '
-                        'Please use arraywriter classes instead',
-                        '1.2',
-                        '3.0')
-def calculate_scale(data, out_dtype, allow_intercept):
-    """ Calculate scaling and optional intercept for data
-
-    Parameters
-    ----------
-    data : array
-    out_dtype : dtype
-       output data type in some form understood by ``np.dtype``
-    allow_intercept : bool
-       If True allow non-zero intercept
-
-    Returns
-    -------
-    scaling : None or float
-       scalefactor to divide into data.  None if no valid data
-    intercept : None or float
-       intercept to subtract from data.  None if no valid data
-    mn : None or float
-       minimum of finite value in data or None if this will not
-       be used to threshold data
-    mx : None or float
-       minimum of finite value in data, or None if this will not
-       be used to threshold data
-    """
-    # Code here is a compatibility shell around arraywriters refactor
-    in_dtype = data.dtype
-    out_dtype = np.dtype(out_dtype)
-    if np.can_cast(in_dtype, out_dtype):
-        return 1.0, 0.0, None, None
-    from .arraywriters import make_array_writer, WriterError, get_slope_inter
-    try:
-        writer = make_array_writer(data, out_dtype, True, allow_intercept)
-    except WriterError as e:
-        raise ValueError(str(e))
-    if out_dtype.kind in 'fc':
-        return (1.0, 0.0, None, None)
-    mn, mx = writer.finite_range()
-    if (mn, mx) == (np.inf, -np.inf):  # No valid data
-        return (None, None, None, None)
-    if in_dtype.kind not in 'fc':
-        mn, mx = (None, None)
-    return get_slope_inter(writer) + (mn, mx)
-
-
-@deprecate_with_version('scale_min_max deprecated. Please use arraywriter '
-                        'classes instead.',
-                        '1.2',
-                        '3.0')
-def scale_min_max(mn, mx, out_type, allow_intercept):
-    """ Return scaling and intercept min, max of data, given output type
-
-    Returns ``scalefactor`` and ``intercept`` to best fit data with
-    given ``mn`` and ``mx`` min and max values into range of data type
-    with ``type_min`` and ``type_max`` min and max values for type.
-
-    The calculated scaling is therefore::
-
-        scaled_data = (data-intercept) / scalefactor
-
-    Parameters
-    ----------
-    mn : scalar
-       data minimum value
-    mx : scalar
-       data maximum value
-    out_type : numpy type
-       numpy type of output
-    allow_intercept : bool
-       If true, allow calculation of non-zero intercept.  Otherwise,
-       returned intercept is always 0.0
-
-    Returns
-    -------
-    scalefactor : numpy scalar, dtype=np.maximum_sctype(np.float64)
-       scalefactor by which to divide data after subtracting intercept
-    intercept : numpy scalar, dtype=np.maximum_sctype(np.float64)
-       value to subtract from data before dividing by scalefactor
-
-    Examples
-    --------
-    >>> scale_min_max(0, 255, np.uint8, False)  # doctest: +SKIP
-    (1.0, 0.0)
-    >>> scale_min_max(-128, 127, np.int8, False)  # doctest: +SKIP
-    (1.0, 0.0)
-    >>> scale_min_max(0, 127, np.int8, False)  # doctest: +SKIP
-    (1.0, 0.0)
-    >>> scaling, intercept = scale_min_max(0, 127, np.int8,  True)  # doctest: +SKIP
-    >>> np.allclose((0 - intercept) / scaling, -128)  # doctest: +SKIP
-    True
-    >>> np.allclose((127 - intercept) / scaling, 127)  # doctest: +SKIP
-    True
-    >>> scaling, intercept = scale_min_max(-10, -1, np.int8, True)  # doctest: +SKIP
-    >>> np.allclose((-10 - intercept) / scaling, -128)  # doctest: +SKIP
-    True
-    >>> np.allclose((-1 - intercept) / scaling, 127)  # doctest: +SKIP
-    True
-    >>> scaling, intercept = scale_min_max(1, 10, np.int8, True)  # doctest: +SKIP
-    >>> np.allclose((1 - intercept) / scaling, -128)  # doctest: +SKIP
-    True
-    >>> np.allclose((10 - intercept) / scaling, 127)  # doctest: +SKIP
-    True
-
-    Notes
-    -----
-    We don't use this function anywhere in nibabel now, it's here for API
-    compatibility only.
-
-    The large integers lead to python long types as max / min for type.
-    To contain the rounding error, we need to use the maximum numpy
-    float types when casting to float.
-    """
-    if mn > mx:
-        raise ValueError('min value > max value')
-    info = type_info(out_type)
-    mn, mx, type_min, type_max = np.array(
-        [mn, mx, info['min'], info['max']], np.maximum_sctype(np.float))
-    # with intercept
-    if allow_intercept:
-        data_range = mx - mn
-        if data_range == 0:
-            return 1.0, mn
-        type_range = type_max - type_min
-        scaling = data_range / type_range
-        intercept = mn - type_min * scaling
-        return scaling, intercept
-    # without intercept
-    if mx == 0 and mn == 0:
-        return 1.0, 0.0
-    if type_min == 0:  # uint
-        if mn < 0 and mx > 0:
-            raise ValueError('Cannot scale negative and positive '
-                             'numbers to uint without intercept')
-        if mx < 0:
-            scaling = mn / type_max
-        else:
-            scaling = mx / type_max
-    else:  # int
-        if abs(mx) >= abs(mn):
-            scaling = mx / type_max
-        else:
-            scaling = mn / type_min
-    return scaling, 0.0
-
-
 def int_scinter_ftype(ifmt, slope=1.0, inter=0.0, default=np.float32):
     """ float type containing int type `ifmt` * `slope` + `inter`