Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Teams

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

I have this old piece of code and it says that has been deprecated already. What are possible alternatives to achieve this line of code's purpose?

img = misc.bytescale(img, high=16, low=0)
I stepped over the same issue and found no solution.
I copy here a slightly modified version of the source code (just numpy imports):
import numpy as np
# Returns a byte-scaled image
def bytescale(data, cmin=None, cmax=None, high=255, low=0):
    Byte scales an array (image).
    Byte scaling means converting the input image to uint8 dtype and scaling
    the range to ``(low, high)`` (default 0-255).
    If the input image already has dtype uint8, no scaling is done.
    Parameters
    ----------
    data : ndarray
        PIL image data array.
    cmin : scalar, optional
        Bias scaling of small values. Default is ``data.min()``.
    cmax : scalar, optional
        Bias scaling of large values. Default is ``data.max()``.
    high : scalar, optional
        Scale max value to `high`.  Default is 255.
    low : scalar, optional
        Scale min value to `low`.  Default is 0.
    Returns
    -------
    img_array : uint8 ndarray
        The byte-scaled array.
    Examples
    --------
    >>> img = array([[ 91.06794177,   3.39058326,  84.4221549 ],
                     [ 73.88003259,  80.91433048,   4.88878881],
                     [ 51.53875334,  34.45808177,  27.5873488 ]])
    >>> bytescale(img)
    array([[255,   0, 236],
           [205, 225,   4],
           [140,  90,  70]], dtype=uint8)
    >>> bytescale(img, high=200, low=100)
    array([[200, 100, 192],
           [180, 188, 102],
           [155, 135, 128]], dtype=uint8)
    >>> bytescale(img, cmin=0, cmax=255)
    array([[91,  3, 84],
           [74, 81,  5],
           [52, 34, 28]], dtype=uint8)
    if data.dtype == np.uint8:
        return data
    if high < low:
        raise ValueError("`high` should be larger than `low`.")
    if cmin is None:
        cmin = data.min()
    if cmax is None:
        cmax = data.max()
    cscale = cmax - cmin
    if cscale < 0:
        raise ValueError("`cmax` should be larger than `cmin`.")
    elif cscale == 0:
        cscale = 1
    scale = float(high - low) / cscale
    bytedata = (data * 1.0 - cmin) * scale + 0.4999
    bytedata[bytedata > high] = high
    bytedata[bytedata < 0] = 0
    return np.cast[np.uint8](bytedata) + np.cast[np.uint8](low)
#example
img = np.array([[ 91.06794177,   3.39058326,  84.4221549 ],
                [ 73.88003259,  80.91433048,   4.88878881],
                [ 51.53875334,  34.45808177,  27.5873488 ]])
print(img)
print(bytescale(img))
this returns
[[91.06794177  3.39058326 84.4221549 ]
 [73.88003259 80.91433048  4.88878881]
 [51.53875334 34.45808177 27.5873488 ]]
[[255   0 236]
 [205 225   4]
 [140  90  70]]
def bytescale(arr, low=None, high=None, a=0, b=255):
    """Linear rescale of array. Defaults to bytescale"""
    if low or high:
        arr = np.clip(arr, low, high)
    return (b-a) * ((arr - np.min(arr)) / (np.max(arr) - np.min(arr))) + a
        
Thanks for contributing an answer to Stack Overflow!
Please be sure to answer the question. Provide details and share your research!
But avoid …
Asking for help, clarification, or responding to other answers.
Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.