Link to numpy.uint8

oscargus · oscargus · commit 87b62ea985f3 · 2023-03-07T12:41:36.000+01:00
diff --git a/lib/matplotlib/backend_bases.py b/lib/matplotlib/backend_bases.py
@@ -473,7 +473,7 @@ def draw_image(self, gc, x, y, im, transform=None):
             The distance in physical units (i.e., dots or pixels) from the
             bottom side of the canvas.
 
-        im : (N, M, 4) array-like of np.uint8
+        im : (N, M, 4) array of `numpy.uint8`
             An array of RGBA pixels.
 
         transform : `matplotlib.transforms.Affine2DBase`
diff --git a/lib/matplotlib/cm.py b/lib/matplotlib/cm.py
@@ -437,7 +437,7 @@ def to_rgba(self, x, alpha=None, bytes=False, norm=True):
         If *x* is an `~numpy.ndarray` with 3 dimensions,
         and the last dimension is either 3 or 4, then it will be
         treated as an RGB or RGBA array, and no mapping will be done.
-        The array can be uint8, or it can be floating point with
+        The array can be `~numpy.uint8`, or it can be floats with
         values in the 0-1 range; otherwise a ValueError will be raised.
         If it is a masked array, the mask will be ignored.
         If the last dimension is 3, the *alpha* kwarg (defaulting to 1)
@@ -448,7 +448,7 @@ def to_rgba(self, x, alpha=None, bytes=False, norm=True):
 
         In either case, if *bytes* is *False* (default), the RGBA
         array will be floats in the 0-1 range; if it is *True*,
-        the returned RGBA array will be uint8 in the 0 to 255 range.
+        the returned RGBA array will be `~numpy.uint8` in the 0 to 255 range.
 
         If norm is False, no normalization of the input data is
         performed, and it is assumed to be in the range (0-1).
diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py
@@ -681,7 +681,7 @@ def __init__(self, name, N=256):
         self.colorbar_extend = False
 
     def __call__(self, X, alpha=None, bytes=False):
-        """
+        r"""
         Parameters
         ----------
         X : float or int, `~numpy.ndarray` or scalar
@@ -695,8 +695,8 @@ def __call__(self, X, alpha=None, bytes=False):
             floats with shape matching X, or None.
         bytes : bool
             If False (default), the returned RGBA values will be floats in the
-            interval ``[0, 1]`` otherwise they will be uint8s in the interval
-            ``[0, 255]``.
+            interval ``[0, 1]`` otherwise they will be `numpy.uint8`\s in the
+            interval ``[0, 255]``.
 
         Returns
         -------
diff --git a/lib/matplotlib/image.py b/lib/matplotlib/image.py
@@ -74,7 +74,7 @@ def composite_images(images, renderer, magnification=1.0):
 
     Returns
     -------
-    image : uint8 array (M, N, 4)
+    image : (M, N, 4) `numpy.uint8` array
         The composited RGBA image.
     offset_x, offset_y : float
         The (left, bottom) offset where the composited image should be placed
@@ -333,9 +333,10 @@ def _make_image(self, A, in_bbox, out_bbox, clip_bbox, magnification=1.0,
         the given *clip_bbox* (also in pixel space), and magnified by the
         *magnification* factor.
 
-        *A* may be a greyscale image (M, N) with a dtype of float32, float64,
-        float128, uint16 or uint8, or an (M, N, 4) RGBA image with a dtype of
-        float32, float64, float128, or uint8.
+        *A* may be a greyscale image (M, N) with a dtype of `~numpy.float32`,
+        `~numpy.float64`, `~numpy.float128`, `~numpy.uint16` or `~numpy.uint8`,
+        or an (M, N, 4) RGBA image with a dtype of `~numpy.float32`,
+        `~numpy.float64`, `~numpy.float128`, or `~numpy.uint8`.
 
         If *unsampled* is True, the image will not be scaled, but an
         appropriate affine transformation will be returned instead.
@@ -347,7 +348,7 @@ def _make_image(self, A, in_bbox, out_bbox, clip_bbox, magnification=1.0,
 
         Returns
         -------
-        image : (M, N, 4) uint8 array
+        image : (M, N, 4) `numpy.uint8` array
             The RGBA image, resampled unless *unsampled* is True.
         x, y : float
             The upper left corner where the image should be drawn, in pixel
@@ -596,7 +597,7 @@ def make_image(self, renderer, magnification=1.0, unsampled=False):
 
         Returns
         -------
-        image : (M, N, 4) uint8 array
+        image : (M, N, 4) `numpy.uint8` array
             The RGBA image, resampled unless *unsampled* is True.
         x, y : float
             The upper left corner where the image should be drawn, in pixel
diff --git a/lib/matplotlib/path.py b/lib/matplotlib/path.py
@@ -29,7 +29,7 @@ class Path:
     The underlying storage is made up of two parallel numpy arrays:
 
     - *vertices*: an (N, 2) float array of vertices
-    - *codes*: an N-length uint8 array of path codes, or None
+    - *codes*: an N-length `numpy.uint8` array of path codes, or None
 
     These two arrays always have the same length in the first
     dimension.  For example, to represent a cubic curve, you must
diff --git a/src/_image_wrapper.cpp b/src/_image_wrapper.cpp
@@ -17,12 +17,12 @@ const char* image_resample__doc__ =
 
 "Parameters\n"
 "----------\n"
-"input_array : 2-d or 3-d array-like of float, double or uint8\n"
+"input_array : 2-d or 3-d NumPy array of float, double or `numpy.uint8`\n"
 "    If 2-d, the image is grayscale.  If 3-d, the image must be of size\n"
 "    4 in the last dimension and represents RGBA data.\n\n"
 
-"output_array : 2-d or 3-d numpy array of float, double or uint8\n"
-"    The dtype and number of dimensions must match *input_array*.\n\n"
+"output_array : 2-d or 3-d NumPy array of float, double or `numpy.uint8`\n"
+"    The dtype and number of dimensions must match `input_array`.\n\n"
 
 "transform : matplotlib.transforms.Transform instance\n"
 "    The transformation from the input array to the output array.\n\n"
