code: def bytescale(data, high=255, low=0, cmin=None, cmax=None):
      """Byte scales an array (image).
  
      Byte scaling converts the input image to uint8 dtype, and rescales
      the data range to ``(low, high)`` (default 0-255).
      If the input image already has dtype uint8, no scaling is done.
      Source code adapted from scipy.misc.bytescale (deprecated in scipy-1.0.0)
  
      Parameters
      ----------
      data : numpy array
          image data array.
      high : int (default=255)
          Scale max value to `high`.
      low : int (default=0)
          Scale min value to `low`.
      cmin : int (optional)
          Bias scaling of small values. Default is ``data.min()``.
      cmax : int (optional)
          Bias scaling of large values. Default is ``data.max()``.
  
      Returns
      -------
      img_array : uint8 numpy array
          The byte-scaled array.
  
      Examples
      --------
          >>> import numpy as np
          >>> from earthpy.spatial import bytescale
          >>> img = np.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([[255,   0, 236],
                 [205, 225,   4],
                 [140,  90,  70]], dtype=uint8)
      """
      if data.dtype == "uint8":
          return data
  
      if high > 255:
          raise ValueError(
              "`high` should be less than or equal to 255."
          )
      if low < 0:
          raise ValueError(
              "`low` should be greater than or equal to 0."
          )
      if high < low:
          raise ValueError(
              "`high` should be greater than or equal to `low`."
          )
  
      if cmin is None or (cmin < data.min()):
          cmin = float(data.min())
  
      if (cmax is None) or (cmax > data.max()):
          cmax = float(data.max())
  
      # Calculate range of values
      crange = cmax - cmin
      if crange < 0:
          raise ValueError("`cmax` should be larger than `cmin`.")
      elif crange == 0:
          raise ValueError(
              "`cmax` and `cmin` should not be the same value. Please specify "
              "`cmax` > `cmin`"
          )
  
      scale = float(high - low) / crange
  
      # If cmax is less than the data max, then this scale parameter will create
      # data > 1.0. clip the data to cmax first.
      data[data > cmax] = cmax
      bytedata = (data - cmin) * scale + low
      return (bytedata.clip(low, high) + 0.5).astype("uint8")
  
file_path: earthpy/earthpy/spatial.py
imports: import os
  import sys
  import contextlib
  import warnings
  import numpy
  from shapely.geometry import mapping, box
  import geopandas
  import rasterio
  from rasterio.mask import mask
label_desc: Use image node_id 7 for calling a global function with example usage: bytescale(data, high, low, cmin, cmax) and returns: unknown, data