machinevision-toolbox-python 2.0.1__py3-none-any.whl → 2.2.0__py3-none-any.whl

machinevisiontoolbox/ImageCore.docstring

@@ -1,2877 +0,0 @@
-#################### ImageCore.py/Image.__init__
-"""
-        Create an Image instance
-
-        :param image: image data
-        :type image: array_like(H,W), :class:`Image`
-        :param colororder: order of color channels
-        :type colororder: str, dict
-        :param copy: copy the image data, defaults to False
-        :type copy: bool, optional
-        :param size: new size for the image, defaults to None
-        :type size: tuple, optional
-        :param dtype: data type for image, defaults to same type as ``image``
-        :type dtype: str or NumPy dtype, optional
-        :param name: name of image, defaults to None
-        :type name: str, optional
-        :param id: numeric id of image, typically a sequence number, defaults to None
-        :type id: int, optional
-        :param domain: domain of image, defaults to None
-        :type domain: array_like(W), array_like(H), optional
-        :param binary: create binary image, non-zero values are set to True, defaults to False
-        :type binary: bool, optional
-        :raises TypeError: unknown type passed to constructor
-
-        Create a new :class:`Image` instance which contains pixel values as well as
-        information about image size, datatype, color planes and domain.  The pixel
-        data is stored in a NumPy array, encapsulated by the object.
-
-        An image is considered to be a two-dimensional (width x height) grid of pixel
-        values, that lie within one or more "color" planes.
-
-        The image data can be specified by:
-
-        - a NumPy 2D or 3D array for a greyscale or color image respectively.  For
-          the latter case, the last index represents the color plane::
-
-            Image(nd.zeros((100, 200)))
-            Image(nd.zeros((100, 200, 4)), colororder="WXYZ")
-
-        - a lists of lists of pixel values, each inner list must have the same
-          number of elements (columns)::
-
-                Image([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-
-        - a range of class methods that serve as constructors for common image types such as
-          :meth:`Zeros`, :meth:`Constant`, :meth:`Random` and :meth:`String`, or
-          read an image from a file :meth:`Read`.
-
-        - an existing :class:`Image` instance.
-
-        **Pixel datatype**
-
-        If ``dtype`` is a string or a NumPy dtype, the pixel data type is set to that type.
-
-        If ``dtype`` is ``True`` the pixel data type is inherited from the input if it is a NumPy array.
-
-        If ``dtype`` is not given and:
-
-          * the input is a NumPy array,the image data type is determined by the dtype of the array:
-
-            - if floating point, then the Image inherits the dtype of the array
-            - if integer, then the Image is assigned the smallest integer dtype that can
-              contain the values in the array.  If the minimum value is negative, a signed
-              integer type is used; otherwise an unsigned type is used.
-
-          * the input is a list of lists then the image data type is:
-
-            - float32 if the list contains any floating point values, otherwise
-            - the smallest signed or unsigned int that can represent its
-              value span.
-
-        An image can have boolean pixel values which are stored as ``uint8`` values.
-        When used in a numerical expression, its values will be cast to integer values
-        of 0 or 1 representing False and True respectively.
-
-        **Color planes**
-
-        Images can have multiple planes, typically three (representing the
-        primary colors red, green and blue) but *any number* is possible. In
-        the underlying Numpy array, these planes are identified by an integer
-        plane index (the last dimension of the 3D array).
-
-        Rather than rely on a limiting convention such as planes being in the order
-        RGB or BGR, the :class:`Image` contains a dictionary that maps the name of a color plane to
-        its index value.  The color plane order can be specified as a dict or a string, eg::
-
-            Image(img, colororder="RGB")
-            Image(img, colororder="red:green:blue:alpha")
-            Image(img, colororder=dict("R"=2, "G"=1, "B"=0))
-
-        Image planes can be referenced by their index or by their name, eg.::
-
-            img.plane(0)
-            img.plane("alpha")
-
-        :seealso: :meth:`colororder` :meth:`colororder_str`
-
-        **Image domain**
-
-        An :class:`Image` has a width and height in units of pixels, but for
-        some applications it is useful to specify the pixel coordinates in other
-        units, perhaps metres, or latitude/longitude angles, or for a spherical image
-        as azimuth and colatitude angles.  The domain is specified by two 1D arrays
-        that map the pixel coordinate to the domain variable.
-
-        **Binary images**
-
-        If ``binary`` is True, the image is converted to a binary image, where zero valued
-        pixels are set to False and all other values are set to True.  To create an
-        image where pixels have integer values of 0 and 1 use the ``dtype`` option::
-
-            Image([[0, 3], [4, 0]])  # pixel values are 0, 3, 4, 0
-            Image([[0, 3], [4, 0]], binary=True)  # pixel values are: False, True, True, False
-            Image([[0, 3], [4, 0]], binary=True, dtype="uint8")  # pixel values are 0, 1, 1, 0
-
-        **Reshaping**
-
-        Frequently we need to create an image from 1D data, for example::
-
-            1: Y0 Y1 Y2 ...  # (N,)
-            2: R0 G0 B0 R1 G1 B1 ... # (3N,)
-
-        Or a 2D array with one or more rows::
-
-            3: Y0 Y1 Y2 ... # (1, N)
-
-            4: R0 G0 B0 R1 G1 B1 ... # (1,3N)
-
-            5: R0 R1 R2 ... # (3,N)
-               G0 G1 G2 ...
-               B0 B1 B2 ...
-
-        Or a 2D array with one or more columns::
-
-            6: Y0 # (N,1)
-               Y1
-               Y2
-                .
-                .
-
-            7: R0 # (3N,1)
-               G0
-               B0
-               R1
-               .
-               .
-
-            8: R0 G0 B0 # (N,3)
-               R1 G1 B1
-               R2 G2 B2
-                .
-                .
-
-        The ``size`` option can be used to reshape the data to the specified size.  The number
-        of planes is determined from any of: ``colororder``, the third element of
-        ``size``, or the number of row/columns in the data (formats 5 or 8). For formats
-        2, 4 or 7 the number of planes must be given explicitly in ``colororder``, the
-        third element of ``size``.
-
-        :seealso: :meth:`view1d`
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> import numpy as np
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> print(img)
-            >>> img.print()
-            >>> Image(np.array([[1, 2], [3, 4]]))
-            >>> Image([[1, 2], [3, 1000]])
-            >>> Image([[0.1, 0.2], [0.3, 0.4]])
-            >>> Image([[True, False], [False, True]])
-
-        .. warning:: If an image is constructed from an existing :class:`Image` instance or a Numpy array,
-            the encapsulated Numpy array is, by default, a *reference* to the passed image data.
-            Use the option ``copy=True`` if you want to copy the data.
-
-        """
-
-#################### ImageCore.py/Image.__str__
-"""
-        Single line summary of image parameters
-
-        :return: single line summary of image
-        :rtype: str
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> str(img)
-        """
-
-#################### ImageCore.py/Image.rprint
-"""
-        Print image pixels in compact format and return image
-
-        :param fmt: format string, defaults to None
-        :type fmt: str, optional
-        :param separator: value separator, defaults to single space
-        :type separator: str, optional
-        :param precision: precision for floating point pixel values, defaults to 2
-        :type precision: int, optional
-        :param header: print image summary header, defaults to True
-        :type header: bool, optional
-        :param file: file to print to, defaults to None
-        :type file: file, optional
-        :return: the printed image
-        :rtype: :class:`Image`
-
-        Very compact display of pixel numerical values in grid layout and return the image itself.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Squares(1, size=10).rprint()
-            >>> print(img)
-            >>> img = Image.Squares(1, size=10, dtype='float').rprint(precision=1, header=True)
-            >>> print(img)
-
-        The function returns the image, which is why we see the image ``repr`` value
-        after the printed pixels in this python intrepreter.
-
-        The `rprint` method is particularly useful in a method chain, for example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Random(size=3).rprint()
-            >>> print(img) # return result of print() is the image itself
-
-        .. note::
-
-            - For a boolean image True and False are displayed as 1 and 0
-              respectively.
-            - For a multiplane images the planes are printed sequentially, along
-              with the plane's name.
-
-        :seealso: :meth:`print` :meth:`Image.strhcat` :meth:`Image.showpixels`
-        """
-
-#################### ImageCore.py/Image.print
-"""
-        Print image pixels in compact format
-
-        :param fmt: format string, defaults to None
-        :type fmt: str, optional
-        :param separator: value separator, defaults to single space
-        :type separator: str, optional
-        :param precision: precision for floating point pixel values, defaults to 2
-        :type precision: int, optional
-        :param header: print image summary header, defaults to True
-        :type header: bool, optional
-        :param file: file to print to, defaults to None
-        :type file: file, optional
-        :return: the printed image
-        :rtype: :class:`Image`
-
-        Very compact display of pixel numerical values in grid layout.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Squares(1, size=10)
-            >>> img.print()
-            >>> img = Image.Squares(1, size=10, dtype='float')
-            >>> img.print(precision=1, header=True)
-
-        .. note::
-
-            - For a boolean image True and False are displayed as 1 and 0
-              respectively.
-            - For a multiplane images the planes are printed sequentially, along
-              with the plane's name.
-
-        :seealso: :meth:`rprint` :meth:`Image.strhcat` :meth:`Image.showpixels`
-        """
-
-#################### ImageCore.py/Image.strhcat
-"""Format several small images concatenated horizontally
-
-        :param images: one or more images to be formatted horizontally concatenated
-        :type images: :class:`Image` instances
-        :param widths: number of digits for the formatted array elements, defaults to 1.
-            If scalar applies to all images, if list applies to each image.
-        :type widths: int or list of ints, optional
-        :param arraysep: separator between arrays, defaults to ``" |"``
-        :type arraysep: str, optional
-        :param labels: list of labels for each array, defaults to None
-        :type labels: list of str, optional
-        :return: multiline string containing formatted arrays
-        :rtype: str
-        :raises ValueError: if the arrays have different numbers of rows
-
-        AUTO_EDIT
-
-        For image processing this is useful for displaying small test images.
-
-        The arrays are formatted and concatenated horizontally with a vertical separator.
-        Each array has a header row that indicates the column number.  Each row has a
-        header column that indicates the row number.
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> A = Image.Random(size=(5,5), maxval=9)
-            >>> print(Image.strhcat(A))
-            >>> print(Image.strhcat(A, widths=2))
-            >>> B = Image.Random(size=(5,5), maxval=9)
-            >>> print(Image.strhcat(A, B))
-            >>> print(Image.strhcat(A, B, labels=("A:", "B:")))
-
-        The number of rows in each image must be the same, but the number of columns can
-        vary.
-
-        :seealso: :meth:`Image.print` :meth:`Image.showpixels` :func:`Image`
-        """
-
-#################### ImageCore.py/Image.__repr__
-"""
-        Readable representation of image parameters
-
-        :return: summary of image enclosed in angle brackets
-        :rtype: str
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img
-        """
-
-#################### ImageCore.py/Image.copy
-"""
-        Create image copy
-
-        :param copy: copy the image data
-        :type copy: bool
-        :return: copy of image
-        :rtype: :class:`Image`
-
-        Create a new :class:`Image` instance which contains a copy of the
-        original image data. If ``copy`` is False the new :class:`Image`
-        instance contains a reference to the original image data.
-        """
-
-#################### ImageCore.py/Image.colororder
-"""
-        Set/get color order of image
-
-        The color order is a dict where the key is the color plane name, eg. 'R'
-        and the value is the index of the plane in the 3D pixel value array.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.colororder
-            >>> img.colororder = "BGR"
-            >>> img.colororder
-
-        When setting the color order the value can be any of:
-
-        * simple string, one plane per character, eg. ``"RGB"``
-        * colon separated string, eg. ``"R:G:B"``, ``"L*:a*:b*"``
-        * dictionary, eg. ``dict(R=0, G=1, B=2)``
-
-        For the first two cases the color plane indices are implicit in the
-        order in the string.
-
-        .. note:: Changing the color order does not change the order of the planes
-            in the image array, it simply changes their label.
-
-        :seealso: :meth:`colororder_str` :meth:`colordict` :meth:`plane` :meth:`red` :meth:`green` :meth:`blue`
-        """
-
-#################### ImageCore.py/Image._opencv_type_check
-"""
-        Check that a NumPy array has a type accepted by an OpenCV function.
-
-        :param array: array to check
-        :type array: np.ndarray
-        :param accepted_types: accepted OpenCV type strings
-        :type accepted_types: str
-        :raises TypeError: if the array dtype or channel count is not accepted by OpenCV
-
-        Recognised type strings:
-
-        - Depth strings: ``"CV_8U"``, ``"CV_8S"``, ``"CV_16U"``, ``"CV_16S"``,
-          ``"CV_32S"``, ``"CV_32F"``, ``"CV_64F"``
-        - Channel strings: ``"single-channel"`` (array must be 2D),
-          ``"multiple-channel"`` (array may be 2D or 3D)
-
-        Example::
-
-            Image._opencv_type_check(img, "single-channel", "CV_8U")
-            Image._opencv_type_check(img, "multiple-channel", "CV_8U", "CV_16S", "CV_32F")
-        """
-
-#################### ImageCore.py/Image.colordict
-"""
-        Parse a color order specification
-
-        :param colororder: order of color channels
-        :type colororder: str, dict
-        :raises ValueError: ``colororder`` not a string or dict
-        :return: dictionary mapping color names to plane indices
-        :rtype: dict
-
-        The color order the value can be given in a variety of forms:
-
-        * simple string, one plane per character, eg. ``"RGB"``
-        * colon separated string, eg. ``"R:G:B"``, ``"L*:a*:b*"``
-        * dictionary, eg. ``dict(R=0, G=1, B=2)``
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> Image.colordict('RGB')
-            >>> Image.colordict('red:green:blue')
-            >>> Image.colordict({'L*': 0, 'U*': 1, 'V*': 2})
-
-        :deprecated: use :meth:`colororder2dict`
-        """
-
-#################### ImageCore.py/Image.colororder2dict
-"""
-        Parse a color order specification to a color dictionary
-
-        :param colororder: order of color channels
-        :type colororder: str, dict
-        :param start: starting index for plane numbering, defaults to 0
-        :type start: int, optional
-        :raises ValueError: ``colororder`` not a string or dict
-        :return: dictionary mapping color names to plane indices
-        :rtype: dict
-
-        The color order the value can be given in a variety of forms:
-
-        AUTO_EDIT
-
-        * simple string, one plane per character, eg. ``"RGB"``
-        * colon separated string, eg. ``"R:G:B"``, ``"L*:a*:b*"``
-        * dictionary, eg. ``dict(R=0, G=1, B=2)``
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> Image.colororder2dict('RGB')
-            >>> Image.colororder2dict('red:green:blue')
-            >>> Image.colororder2dict({'L*': 0, 'U*': 1, 'V*': 2})
-        """
-
-#################### ImageCore.py/Image.colordict2list
-"""
-        Convert a color dictionary to a list of color plane names
-
-        :param cdict: dictionary mapping color names to plane indices
-        :type cdict: dict
-        :return: list of color channels in plane order
-        :rtype: list
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> Image.colordict2list({'R': 0, 'G': 1, 'B': 2})
-
-        .. note:: The color planes are sorted by their index value.  There is no
-            check that the lowest plane index is zero.
-
-        :seealso: :meth:`colordict2str` :meth:`colororder2dict`
-        """
-
-#################### ImageCore.py/Image.colordict2str
-"""
-        Convert a color dictionary to a color order string
-
-        :param cdict: dictionary mapping color names to plane indices
-        :type cdict: dict
-        :return: color channel names in plane order as a colon-separated string
-        :rtype: str
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> Image.colordict2str({'R': 0, 'G': 1, 'B': 2})
-
-        .. note:: The color planes are sorted by their index value.  There is no
-            check that the lowest plane index is zero.
-
-        :seealso: :meth:`colordict2list` :meth:`colororder2dict`
-
-        AUTO_EDIT
-        """
-
-#################### ImageCore.py/Image.colororder_str
-"""
-        Image color order as a string
-
-        :return: Image color plane order as a colon separated string.
-        :rtype: str
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.colororder_str
-
-        :seealso: :meth:`colororder`
-        """
-
-#################### ImageCore.py/Image.name
-"""
-        Set/get image name
-
-        An image has a string-valued name that can be read and written.
-        The name is shown by the Image repr and when images are displayed
-        graphically.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.name[-70:]
-            >>> img.name = 'my image'
-            >>> img.name
-
-        .. note:: Images loaded from a file have their name initially set to
-            the full file pathname.
-
-        :seealso: :meth:`Read`
-        """
-
-#################### ImageCore.py/Image.isfloat
-"""
-        Image has floating point pixel values?
-
-        :return: True if image has floating point values
-        :rtype: bool
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.isfloat
-            >>> img = Image.Read('flowers1.png', dtype='float32')
-            >>> img.isfloat
-
-        :seealso: :meth:`isint` :meth:`isbool`
-        """
-
-#################### ImageCore.py/Image.isint
-"""
-        Image has integer values?
-
-        :return: True if image has integer pixel values
-        :rtype: bool
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.isint
-            >>> img = Image.Read('flowers1.png', dtype='float32')
-            >>> img.isint
-
-        :seealso: :meth:`isfloat` :meth:`isbool`
-        """
-
-#################### ImageCore.py/Image.isbool
-"""
-        Image has bolean values?
-
-        :return: True if image has boolean pixel values
-        :rtype: bool
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png') > 200
-            >>> img.isint
-            >>> img.isbool
-
-        :seealso: :meth:`isint` :meth:`isfloat`
-        """
-
-#################### ImageCore.py/Image.dtype
-"""
-        Datatype of image
-
-        :return: NumPy datatype of image
-        :rtype: numpy.dtype
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.dtype
-            >>> img = Image.Read('flowers1.png', dtype='float32')
-            >>> img.dtype
-
-        :seealso: :meth:`to` :meth:`to_int` :meth:`to_float` :meth:`like` :meth:`cast` :func:`numpy.dtype`
-        """
-
-#################### ImageCore.py/Image.numnan
-"""
-        Number of NaN pixels in image
-
-        :return: number of NaN pixels in image
-        :rtype: int
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> from numpy import nan
-            >>> img = Image([[1, 2], [3, nan]], dtype='float32')
-            >>> img.numnan
-
-        :seealso: :meth:`numinf`
-        """
-
-#################### ImageCore.py/Image.numinf
-"""
-        Number of Inf pixels in image
-
-        :return: number of Inf pixels in image
-        :rtype: int
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> from numpy import inf
-            >>> img = Image([[1, 2], [3, inf]], dtype='float32')
-            >>> img.numinf
-
-        :seealso: :meth:`numnan`
-        """
-
-#################### ImageCore.py/Image.width
-"""
-        Image width
-
-        :return: Width of image in pixels
-        :rtype: int
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.width
-
-        :seealso: :meth:`height` :meth:`size` :meth:`umax`
-        """
-
-#################### ImageCore.py/Image.height
-"""
-        Image height
-
-        :return: Height of image in pixels
-        :rtype: int
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.height
-
-        :seealso: :meth:`width` :meth:`size` :meth:`vmax`
-        """
-
-#################### ImageCore.py/Image.umax
-"""
-        Image maximum u-coordinate
-
-        :return: Maximum u-coordinate in image in pixels
-        :rtype: int
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.umax
-            >>> img.width
-
-        :seealso: :meth:`width`
-        """
-
-#################### ImageCore.py/Image.vmax
-"""
-        Image maximum v-coordinate
-
-        :return: Maximum v-coordinate in image in pixels
-        :rtype: int
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.vmax
-            >>> img.height
-
-        :seealso: :meth:`height`
-        """
-
-#################### ImageCore.py/Image.uspan
-"""
-        Linear span of image horizontally
-
-        :param step: step size, defaults to 1
-        :type step: int, optional
-        :return: 1D array of values [0 ... width-1]
-        :rtype: ndarray(W)
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> import numpy as np
-            >>> img = Image.Read('flowers1.png')
-            >>> with np.printoptions(threshold=10):
-            >>>     img.uspan()
-
-        .. note:: If the image has a ``domain`` specified the horizontal
-            component of this is returned instead.
-
-        .. warning:: Computed using :meth:`numpy.arange` and for ``step>1`` the
-            maximum coordinate may not be returned.
-
-        :seealso: :meth:`umax` :meth:`vspan`
-        """
-
-#################### ImageCore.py/Image.vspan
-"""
-        Linear span of image vertically
-
-        :param step: step size, defaults to 1
-        :type step: int, optional
-        :return: 1D array of values [0 ... height-1]
-        :rtype: ndarray(H)
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> import numpy as np
-            >>> img = Image.Read('flowers1.png')
-            >>> with np.printoptions(threshold=10):
-            >>>     img.vspan()
-
-        .. note:: If the image has a ``domain`` specified the vertical
-            component of this is returned instead.
-
-        .. warning:: Computed using :meth:`numpy.arange` and for ``step>1`` the
-            maximum coordinate may not be returned.
-
-        :seealso: :meth:`vmax` :meth:`uspan`
-        """
-
-#################### ImageCore.py/Image.size
-"""
-        Image size
-
-        :return: Size of image (width, height)
-        :rtype: tuple
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.size
-
-        .. note:: The dimensions are in a different order compared to :meth:`shape`.
-
-        :seealso: :meth:`width` :meth:`height` :meth:`shape`
-        """
-
-#################### ImageCore.py/Image.centre
-"""
-        Coordinate of centre pixel
-
-        :return: Coordinate (u,v) of the centre pixel
-        :rtype: tuple
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Zeros(size=(50,50))
-            >>> img.centre
-            >>> img = Image.Zeros(size=(51,51))
-            >>> img.centre
-
-        .. note:: If the image has an even dimension the centre will lie
-            between pixels.
-
-        :seealso: :meth:`center` :meth:`centre_int`
-        """
-
-#################### ImageCore.py/Image.center
-"""
-        Coordinate of center pixel
-
-        :return: Coordinate (u,v) of the centre pixel
-        :rtype: tuple
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Zeros(size=(50,50))
-            >>> img.center
-            >>> img = Image.Zeros(size=(51,51))
-            >>> img.center
-
-        .. note::
-            - If the image has an even dimension the centre will lie
-              between pixels.
-            - Same as ``centre``, just US spelling
-
-        :seealso: :meth:`center_int`
-        """
-
-#################### ImageCore.py/Image.centre_int
-"""
-        Coordinate of centre pixel as integer
-
-        :return: Coordinate (u,v) of the centre pixel
-        :rtype: tuple
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Zeros(size=(50,50))
-            >>> img.centre_int
-            >>> img = Image.Zeros(size=(51,51))
-            >>> img.centre_int
-
-        .. note:: If the image has an even dimension the centre coordinate will
-              be truncated toward zero.
-
-        :seealso: :meth:`centre`
-        """
-
-#################### ImageCore.py/Image.center_int
-"""
-        Coordinate of centre pixel as integer
-
-        :return: Coordinate (u,v) of the centre pixel
-        :rtype: tuple
-
-        Integer coordinate of centre pixel.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Zeros(size=(50,50))
-            >>> img.center_int
-            >>> img = Image.Zeros(size=(51,51))
-            >>> img.center_int
-
-        .. note::
-            - If the image has an even dimension the centre coordinate will
-              be truncated toward zero.
-            - Same as ``centre_int``, just US spelling
-
-        :seealso: :meth:`center`
-        """
-
-#################### ImageCore.py/Image.npixels
-"""
-        Number of pixels in image plane
-
-        :return: Number of pixels in image plane: width x height
-        :rtype: int
-
-        .. note:: Number of planes is not considered.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.npixels
-            >>> img.width * img.height
-
-        :seealso: :meth:`size`
-        """
-
-#################### ImageCore.py/Image.shape
-"""
-        Image shape
-
-        :return: Shape of internal NumPy array
-        :rtype: 2-tuple, or 3-tuple if color
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.shape
-            >>> img = Image.Read('street.png')
-            >>> img.shape
-
-        .. note:: The dimensions are in a different order compared to :meth:`size`.
-
-        :seealso: :meth:`size` :meth:`nplanes` :meth:`ndim` :meth:`iscolor`
-        """
-
-#################### ImageCore.py/Image.ndim
-"""
-        Number of image array dimensions
-
-        :return: number of image dimensions
-        :rtype: int
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.ndim
-            >>> img = Image.Read('street.png')
-            >>> img.ndim
-
-        :seealso: :meth:`nplanes` :meth:`shape`
-        """
-
-#################### ImageCore.py/Image.contains
-"""
-        Test if coordinate lies within image
-
-        :param p: pixel coordinate
-        :type p: array_like(2), ndarray(2,N)
-        :return: whether pixel coordinate lies within image bounds
-        :rtype: bool, ndarray(N)
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> import numpy as np
-            >>> img = Image.Zeros(size=10)
-            >>> img.contains((4,6))
-            >>> img.contains((-1, 7))
-            >>> img.contains(np.array([[4, 6], [-1, 7], [10, 10]]).T)
-        """
-
-#################### ImageCore.py/Image.iscolor
-"""
-        Image has color pixels?
-
-        :return: Image is color
-        :rtype: bool
-
-        :return: number of image dimensions
-        :rtype: int
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.iscolor
-            >>> img = Image.Read('street.png')
-            >>> img.iscolor
-
-        :seealso: :meth:`isrgb` :meth:`nplanes`
-        """
-
-#################### ImageCore.py/Image.isbgr
-"""
-        Image has BGR color order?
-
-        :return: Image has BGR color order
-        :rtype: bool
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.isbgr
-
-        .. note:: Is False if image is not color.
-
-        :seealso: :meth:`colororder`
-        """
-
-#################### ImageCore.py/Image.isrgb
-"""
-        Image has RGB color order?
-
-        :return: Image has RGB color order
-        :rtype: bool
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.isrgb
-
-        .. note:: Is False if image is not color.
-
-        :seealso: :meth:`colororder`
-        """
-
-#################### ImageCore.py/Image.to
-"""
-        Convert image datatype
-
-        :param dtype: Numpy data type
-        :type dtype: str or NumPy dtype
-        :return: image
-        :rtype: :class:`Image`
-
-        Create a new image, same size as input image, with pixels of a different
-        datatype.  Integer values are scaled according to the maximum value
-        of the datatype, floating values are in the range 0.0 to 1.0.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Random(size=3)
-            >>> img.print()
-            >>> img.to('float').print()
-            >>> img = Image.Random(size=3, dtype='float')
-            >>> img.print()
-            >>> img.to('uint8').print()
-
-        :seealso: :meth:`astype` :meth:`to_int` :meth:`to_float`
-        """
-
-#################### ImageCore.py/Image.astype
-"""
-        Cast image datatype
-
-        :param dtype: Numpy data type
-        :type dtype: str or NumPy dtype
-        :return: image
-        :rtype: :class:`Image`
-
-        Create a new image, same size as input image, with pixels of a different
-        datatype.  Values are retained, only the datatype is changed.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Random(size=3)
-            >>> img.print()
-            >>> img.astype('float').print()
-            >>> img = Image.Random(size=3, dtype='float')
-            >>> img.print()
-            >>> img.astype('uint8').print()
-
-        :seealso: :meth:`to`
-        """
-
-#################### ImageCore.py/Image.image
-"""
-        Image as NumPy array
-
-        :return: image as a NumPy array
-        :rtype: ndarray(H,W) or ndarray(H,W,3)
-
-        Return a reference to the encapsulated NumPy array that holds the pixel
-        values.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img
-            >>> type(img)
-            >>> type(img.image)
-
-        .. note:: For a color image the color plane order is given by the
-            colororder dictionary.
-
-        .. deprecated:: 1.0.3
-            Use :meth:`array` instead.
-
-        :seealso: :meth:`A` :meth:`colororder`
-        """
-
-#################### ImageCore.py/Image.array
-"""
-        Image as NumPy array
-
-        :return: image as a NumPy array
-        :rtype: ndarray(H,W) or ndarray(H,W,3)
-
-        Return a reference to the encapsulated NumPy array that holds the pixel
-        values.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> type(img)
-            >>> type(img.array)
-
-        .. note:: For a color image the color plane order is given by the
-            colororder dictionary.
-
-        .. warning:: This property is for accessing the NumPy image data for
-           passing to a NumPy, OpenCV or other function.  It is not intended for direct
-           manipulation of the image data -- doing so may make the state of the
-           Image instance inconsistent.
-
-        :seealso: :meth:`array_as` :meth:`rgb` :meth:`bgr` :meth:`colororder`
-        """
-
-#################### ImageCore.py/Image.A
-"""
-        Set/get the NumPy array containing pixel values
-
-        **Getting**
-
-        :return: image as a NumPy array
-        :rtype: ndarray(H,W) or ndarray(H,W,3)
-
-        Return a reference to the encapsulated NumPy array that holds the pixel
-        values.
-
-        **Setting**
-
-        Replace the encapsulated NumPy array with another.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> import numpy as np
-            >>> img = Image.Read('flowers1.png')
-            >>> img
-            >>> type(img)
-            >>> type(img.A)
-            >>> img.A = np.zeros((50,50))
-            >>> img
-
-        .. deprecated:: 1.0.3
-            Use :meth:`array` instead for accessing the NumPy image data and the
-            :meth:`Image` constructor for creating a new ``Image`` with a different array.
-
-        :seealso: :meth:`array` :meth:`image`
-        """
-
-#################### ImageCore.py/Image.rgb
-"""
-        Image as NumPy array in RGB color order
-
-        :raises ValueError: image is greyscale
-        :return: image as a NumPy array in RGB color order
-        :rtype: ndarray(H,W,3)
-
-        The image is guaranteed to be in RGB order irrespective of current color order.
-
-        :seealso: :meth:`image` :meth:`bgr` :meth:`colororder`
-        """
-
-#################### ImageCore.py/Image.bgr
-"""
-        Image as NumPy array in BGR color order
-
-        :raises ValueError: image is greyscale
-        :return: image as a NumPy array in BGR color order
-        :rtype: ndarray(H,W,3)
-
-        The image is guaranteed to be in BGR (OpenCV standard) order irrespective of current color order.
-
-        :seealso: :meth:`image` :meth:`rgb` :meth:`colororder`
-        """
-
-#################### ImageCore.py/Image.to_int
-"""
-        Image as integer NumPy array
-
-        :param intclass: name of NumPy supported integer class, default is 'uint8'
-        :type intclass: str or NumPy dtype, optional
-        :return: NumPy array with integer values
-        :rtype: ndarray(H,W) or ndarray(H,W,P)
-
-        Return a NumPy array with pixels converted to the integer class
-        ``intclass``.  For the case where the input image is:
-
-        * a floating point class, the pixel values are scaled from an
-          input range of [0,1] to a range spanning zero to the maximum positive
-          value of the output integer class.
-        * an integer class, then the pixels are scaled and cast to ``intclass``.
-          The scale factor is the ratio of the maximum value of the input and
-          output integer classes.
-        * boolean class, False is mapped to zero and True is mapped to the
-          maximum positive value.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[5_000, 10_000], [30_000, 60_000]])
-            >>> img
-            >>> img.to_int('uint8')
-            >>> img.to_int('uint32')
-            >>> img = Image([[0.0, 0.3], [0.5, 1.0]])
-            >>> img
-            >>> img.to_int('uint8')
-            >>> img = Image([[False, True], [True, False]])
-            >>> img
-            >>> img.to_int('uint8')
-            >>> img.to_int('uint16')
-
-        .. note:: Works for greyscale or color (arbitrary number of planes) image
-
-        .. deprecated:: 1.0.3
-            Use :meth:`array_as` instead.
-
-        :seealso: :meth:`array_as` :meth:`to_float` :meth:`cast` :meth:`like`
-        """
-
-#################### ImageCore.py/Image.to_float
-"""
-        Image as float NumPy array
-
-        :param floatclass: 'single', 'double', 'float32' [default], 'float64'
-        :type floatclass: str or NumPy dtype
-        :return: NumPy array with floating point values
-        :rtype: ndarray(H,W) or ndarray(H,W,P)
-
-        Return a NumPy array with pixels converted to the floating point class ``floatclass``
-        and the values span the range 0 to 1. For the case where the input image
-        is:
-
-        * an integer class, the pixel values are scaled from an input range
-          spanning zero to the maximum positive value of the integer
-          class to [0.0, 1.0]
-        * a floating class, the pixels are cast to change type but not their
-          value.
-        * boolean class, False is mapped to 0.0 and True is mapped to 1.0.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[50, 100], [150, 200]])
-            >>> img
-            >>> img.to_float()
-            >>> img = Image([[0.0, 0.3], [0.5, 1.0]])
-            >>> img
-            >>> img.to_float('float64')
-            >>> img = Image([[False, True], [True, False]])
-            >>> img.to_float()
-
-        .. note:: Works for greyscale or color (arbitrary number of planes) image
-
-        .. deprecated:: 1.0.3
-            Use :meth:`array_as` instead.
-
-        :seealso: :meth:`array_as` :meth:`to_int` :meth:`cast` :meth:`like`
-        """
-
-#################### ImageCore.py/Image.array_as
-"""
-        Convert Image to NumPy array of specified type
-
-        :param dtype: data type of the output array
-        :type dtype: str or np.dtype
-        :return: NumPy array with specified type
-        :rtype: ndarray(H,W) or ndarray(H,W,P)
-
-        Return a NumPy array with pixels converted to the specified data type.
-
-        =========  ========================================  ====================================
-        Input      Output int                                Output float
-        =========  ========================================  ====================================
-        float      scaled [-1,1] → [min_int, max_int]        cast, values unchanged
-        int        scaled by max_int_output/max_int_input    scaled [min_int, max_int] → [-1, 1]
-        uint       scaled by max_int_output/max_int_input    scaled [0, max_int] → [0, 1]
-        bool       False → 0, True → max_int                 False → 0.0, True → 1.0
-        =========  ========================================  ====================================
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[5_000, 10_000], [30_000, 60_000]]) # uint16 image
-            >>> img
-            >>> img.array_as('uint8')
-            >>> img.array_as('uint32')
-            >>> img.array_as('float')
-            >>> img = Image([[0.0, 0.3], [0.5, 1.0]])
-            >>> img
-            >>> img.array_as('uint8')
-            >>> img = Image([[False, True], [True, False]])
-            >>> img
-            >>> img.array_int('uint8')
-            >>> img.array_int('float')
-
-        .. note:: Works for greyscale or color (arbitrary number of planes) image
-
-        .. warning:: This method assumes that all integer values are unsigned.
-
-        :seealso: :meth:`array` :func:`array_float` :meth:`cast` :meth:`like`
-        """
-
-#################### ImageCore.py/Image.cast
-"""
-        Cast value to same type as image
-
-        :param value: value to cast
-        :type value: scalar, ndarray
-        :return: value cast to same type as image
-        :rtype: numpy type, ndarray
-
-        The value, scalar or integer, is **cast** to the same type as the image.
-        The result has the same numeric value, but the type is changed.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> x = img.cast(12.5)
-            >>> x
-            >>> type(x)
-
-        .. note:: Scalars are cast to NumPy types not native Python types.
-
-        :seealso: :meth:`like`
-        """
-
-#################### ImageCore.py/Image.like
-"""
-        Convert value to the same type as image
-
-        :param value: scalar or NumPy array
-        :type value: scalar, ndarray
-        :param maxint: maximum integer value for an integer image, defaults to
-            maximum positive value of the class
-        :type maxint: int, optional
-        :raises ValueError: [description]
-        :return: converted value
-        :rtype: NumPy type
-
-        The value, scalar or integer, is **converted** to the same type as the
-        image. The result is optionally rescaled and cast:
-
-        * Float to float: values are cast
-        * Float to int: values in the interval [0, 1] are scaled to the interval
-          [0, ``maxint``] and then cast
-        * Int to float: values in the interval [0, ``maxint``] are scaled to the
-          interval [0, 1] and then cast.
-        * Int to int: values are scaled and cast.
-
-        .. warning:: For integer to integer conversion, integer values  greater
-            than the maximum value of the destination class are wrapped not
-            clipped.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('flowers1.png')
-            >>> img.like(0.5)
-
-        :seealso: :meth:`cast` :meth:`to_int` :meth:`to_float`
-
-        """
-
-#################### ImageCore.py/Image.minval
-"""
-        Minimum value of image datatype
-
-        :return: Minimum value
-        :rtype: int or float
-
-        For the datatype of the image, return its minimum possible value
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Zeros(size=20, dtype='float32')
-            >>> img.minval
-            >>> img = Image.Zeros(size=20, dtype='uint8')
-            >>> img.minval
-
-        :seealso: :meth:`maxval`
-        """
-
-#################### ImageCore.py/Image.maxval
-"""
-        Maximum value of image datatype
-
-        :return: Maximum value
-        :rtype: int or float
-
-        For the datatype of the image, return its maximum possible value
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Zeros(size=20, dtype='float32')
-            >>> img.maxval
-            >>> img = Image.Zeros(size=20, dtype='uint8')
-            >>> img.maxval
-
-        :seealso: :meth:`minval`
-        """
-
-#################### ImageCore.py/Image.true
-"""
-        True value for logical image
-
-        :return: Value used as true
-        :rtype: int or float
-
-        The true value is 1.0 for a floating point image and maximum integer
-        value for an integer value.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Zeros(size=20, dtype='float32')
-            >>> img.true
-            >>> img = Image.Zeros(size=20, dtype='uint8')
-            >>> img.true
-
-        :seealso: :meth:`false` :meth:`maxval`
-        """
-
-#################### ImageCore.py/Image.false
-"""
-        False value for logical image
-
-        :return: Value used as true
-        :rtype: int or float
-
-        The false value is 0.0 for a floating point image and 0
-        value for an integer value.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Zeros(size=20, dtype='float32')
-            >>> img.false
-            >>> img = Image.Zeros(size=20, dtype='uint8')
-            >>> img.false
-
-        :seealso: :meth:`true`
-        """
-
-#################### ImageCore.py/Image.nplanes
-"""
-        Number of color planes
-
-        :return: Number of color planes, or None if image is empty
-        :rtype: int
-
-        For a 2D or greyscale image this is one, otherwise it is the third
-        dimension of the image.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read('street.png')
-            >>> img.nplanes
-            >>> img = Image.Read('flowers1.png')
-            >>> img.nplanes
-
-        .. note:: A greyscale image is stored internally as a 2D NumPy array
-            which has zero planes, but ``nplanes`` will return 1 in that case.
-
-        :seealso: :meth:`iscolor` :meth:`shape` :meth:`ndim`
-        """
-
-#################### ImageCore.py/Image.planes
-"""
-        Iterator for image planes
-
-        :return out: image containing a single plane
-        :rtype: :class:`Image`
-
-        Iterator that returns sequential image planes.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read("flowers4.png") # in BGR order
-            >>> for plane in img.planes():
-            >>>     print(plane)
-        """
-
-#################### ImageCore.py/Image.plane
-"""
-        Extract plane(s) from color image
-
-        :param planes: planes to extract
-        :type planes: int, list, str
-        :raises ValueError: if image is not color
-        :return out: image containing only the selected planes
-        :rtype: :class:`Image`
-
-        Create a new image from the selected planes of the image.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read("flowers4.png") # in BGR order
-            >>> img.colororder_str
-            >>> img.nplanes
-            >>> red = img.plane(0) # red plane
-            >>> red
-            >>> red.iscolor
-            >>> red.nplanes
-            >>> green_blue = img.plane('G:B') # green and blue planes
-            >>> green_blue
-            >>> green_blue.iscolor
-            >>> green_blue.nplanes
-            >>> red_blue = img.plane([0, 2]) # blue and red planes
-            >>> red_blue
-
-        .. note::
-
-            - This can also be performed using the overloaded ``__getitem__``
-              operator.
-            - To select more than one plane, use either a sequence of integers or a string
-              of colon separated plane names.
-            - For a single-plane image the index must be zero.
-
-        :seealso: :meth:`red` :meth:`green` :meth:`blue` :meth:``__getitem__``
-        """
-
-#################### ImageCore.py/Image.__getitem__
-"""
-        Return pixel value or slice from image
-
-        :param keys: slices to extract
-        :type keys: int, str, tuple of int or slice
-        :return: slice of image
-        :rtype: :class:`Image`
-
-        This is a Swiss-army knife method for accessing subregions of an ``Image``
-        by uv-region and/or plane. A ``key`` can be:
-
-        - a 2-tuple of integers, eg. ``img[u,v]``, return this pixel as a scalar.  If the image has
-          multiple planes, the result is an ndarray over planes.
-        - a 3-tuple of integers, eg, ``img[u,v,p]``, for a multiplane image return this pixel from
-          specified plane as a scalar.
-        - a 2-tuple containing at least one slice object, eg. ``img[100:110, 200:300]``, return this
-          region as an ``Image``. If the image has multiple planes, the result is a multiplane
-          ``Image``.
-        - a 3-tuple containing at least one slice objects, return this region of uv and planes as an
-          ``Image`` with one or more planes.
-        - an int, return this plane as an ``Image``.
-        - a string, return this named plane or planes as an ``Image``.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read("flowers4.png") # in RGB order
-            >>> red = img[0] # red plane
-            >>> red # greyscale image
-            >>> green = img["G"]
-            >>> green # greyscale image
-            >>> roi = img[100:200, 300:400]
-            >>> roi # color image
-            >>> roi = img[100:200, 300:400, 1:]
-            >>> roi # 2-plane color image
-            >>> roi = img[100, :]  # column 100
-            >>> roi # color image
-            >>> pix = img[100, 200, 1] # green pixel at (100,200) as scalar
-            >>> pix
-            >>> pix = img[100, 200] # RGB vector at (100,200) as ndarray
-            >>> pix
-
-        .. note:: If the result is a single row or column the result is a 1xn or nx1
-            ``Image`` instance.  If the result is a single plane the result is a
-            greyscale image.
-
-        .. note:: Indexing pixel values this way is slow, use :meth:`pixel(u,v)` for faster
-            access, or ``img.A[v,u]`` for direct access to the underlying NumPy array.
-
-        .. warning:: The order of the indices is column, row and plane. This
-            is the opposite of the order used for NumPy index on the underlying
-            array.  It is consistent with the column-first convention used across the
-            Toolbox and is consistent with the :math:`(u,v)` coordinate system for images.
-
-        .. versionadded:: 1.0.0
-            The order of the indices changed to column, row, plane.  Previously
-            it was row, column, plane.
-
-        :seealso: :meth:`red` :meth:`green` :meth:`blue` :meth:`plane` :meth:`roi` :meth:`pixel`
-        """
-
-#################### ImageCore.py/Image.pixel
-"""
-        Return pixel value
-
-        :param u: column coordinate
-        :type u: int
-        :param v: row coordinate
-        :type v: int
-        :return: pixel value
-        :rtype: int, float or ndarray
-
-        Return the specified pixel.  If the image has multiple planes, the result is a vector over planes.
-
-        .. note:: This method is faster than the more general :meth:`__getitem__`
-            for the individual pixel case.
-
-        .. warning:: The order of the indices is column, row and plane. This
-            is the opposite of the order used for NumPy index on the underlying
-            array.  It is consistent with the column-first convention used across the
-            Toolbox and is consistent with the :math:`(u,v)` coordinate system for images.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read("flowers4.png", mono=True)
-            >>> pix = img.pixel(100, 200)
-            >>> pix # grey scale pixel value
-            >>> img = Image.Read("flowers4.png")
-            >>> pix = img.pixel(100, 200)
-            >>> pix # color pixel value (R, G, B)
-
-        :seealso: :meth:`__getitem__` :meth:`roi`
-        """
-
-#################### ImageCore.py/Image.pixels_mask
-"""
-        Return pixel values at locations specified by a mask
-
-        :param mask: the selection mask as either non-zero pixels in a 2D image or the area covered by a polygon or list of polygons
-        :type mask: :class:`Image`, a single :class:`Polygon2` or a list of :class:`Polygon2`
-        :param coords: include pixel coordinates in output, defaults to False
-        :type coords: bool, optional
-        :param return_mask: also return the mask as an Image, defaults to False
-        :type return_mask: bool, optional
-        :return: array of pixel values and optionally coordinates of pixels selected by the mask, optionally also the mask as an Image
-        :rtype: :class:`Array2d`, :class:`Array2d` and :class:`Image`
-
-        For an image with P planes and a mask that selects N pixels, return an PxN array
-        of pixel values.  If ``coords`` is True, the result is an (P+2)xN array where
-        the first two rows are the u and v coordinates of the selected pixels.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> from spatialmath import Polygon2
-            >>> img = Image.Read("flowers4.png")
-            >>> polygon = Polygon2([(300, 400), (360, 400), (330, 450)], close=True)
-            >>> pixels = img.pixels_mask(polygon, coords=True)
-            >>> pixels.shape
-            >>> pixels[:,:5] # first 5 pixels, with coordinates
-
-        :seealso: :meth:`pixel` :meth:`__getitem__` :meth:`roi`
-        """
-
-#################### ImageCore.py/Image.red
-"""
-        Extract the red plane of a color image
-
-        :raises ValueError: if image is not color
-        :return out: greyscale image representing the red image plane
-        :rtype: :class:`Image`
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read("flowers4.png")
-            >>> red = img.red() # red plane
-            >>> red.disp()
-            >>> red
-            >>> red.iscolor
-
-        .. plot::
-
-            from machinevisiontoolbox import Image
-            Image.Read("flowers4.png").red().disp()
-
-
-        :seealso: :meth:`plane` :meth:`green` :meth:`blue`
-        """
-
-#################### ImageCore.py/Image.green
-"""
-        Extract the green plane of a color image
-
-        :raises ValueError: if image is not color
-        :return out: greyscale image representing the green image plane
-        :rtype: :class:`Image`
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read("flowers4.png")
-            >>> green = img.green() # green plane
-            >>> green.disp()
-            >>> green
-            >>> green.iscolor
-
-        .. plot::
-
-            from machinevisiontoolbox import Image
-            Image.Read("flowers4.png").green().disp()
-
-        :seealso: :meth:`plane` :meth:`red` :meth:`blue`
-        """
-
-#################### ImageCore.py/Image.blue
-"""
-        Extract the blue plane of a color image
-
-        :raises ValueError: if image is not color
-        :return out: greyscale image representing the blue image plane
-        :rtype: :class:`Image`
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read("flowers4.png")
-            >>> blue = img.blue() # blue plane
-            >>> blue.disp()
-            >>> blue
-            >>> blue.iscolor
-
-        .. plot::
-
-            from machinevisiontoolbox import Image
-            Image.Read("flowers4.png").blue().disp()
-
-        :seealso: :meth:`plane` :meth:`red` :meth:`green`
-        """
-
-#################### ImageCore.py/Image.__mul__
-"""
-        Overloaded ``*`` operator
-
-        :return: element-wise product of images
-        :rtype: :class:`Image`
-
-        Compute the product of an Image with another image or a scalar.
-        Supports:
-
-        * image ``*`` image, element-wise
-        * scalar ``*`` image
-        * image ``*`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img * img
-            >>> z.array
-            >>> z = 2 * img
-            >>> z.array
-
-        ..warning:: Values will be wrapped not clipped to the range of the
-            pixel datatype.
-        """
-
-#################### ImageCore.py/Image.__imul__
-"""
-        Overloaded in-place ``*=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Multiply an Image in place by another image or a scalar.
-
-        :seealso: :meth:`__mul__`
-        """
-
-#################### ImageCore.py/Image.__pow__
-"""
-        Overloaded ``**`` operator
-
-        :return: element-wise exponent of image
-        :rtype: :class:`Image`
-
-        Compute the element-wise power of an Image.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img**3
-            >>> z.array
-
-        ..warning:: Values will be wrapped not clipped to the range of the
-            pixel datatype.
-        """
-
-#################### ImageCore.py/Image.__add__
-"""
-        Overloaded ``+`` operator
-
-        :return: element-wise addition of images
-        :rtype: :class:`Image`
-
-        Compute the sum of an Image with another image or a scalar.
-        Supports:
-
-        * image ``+`` image, element-wise
-        * scalar ``+`` image
-        * image ``+`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img + img
-            >>> z.array
-            >>> z = 10 + img
-            >>> z.array
-
-        ..warning:: Values will be wrapped not clipped to the range of the
-            pixel datatype.
-        """
-
-#################### ImageCore.py/Image.__iadd__
-"""
-        Overloaded in-place ``+=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Add another image or a scalar to an Image in place.
-
-        :seealso: :meth:`__add__`
-        """
-
-#################### ImageCore.py/Image.__sub__
-"""
-        Overloaded ``-`` operator
-
-        :return: element-wise subtraction of images
-        :rtype: :class:`Image`
-
-        Compute the difference of an Image with another image or a scalar.
-        Supports:
-
-        * image ``-`` image, element-wise
-        * scalar ``-`` image
-        * image ``-`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img - img
-            >>> z.array
-            >>> z = img - 1
-            >>> z.array
-
-        ..warning:: Values will be wrapped not clipped to the range of the
-            pixel datatype.
-        """
-
-#################### ImageCore.py/Image.__isub__
-"""
-        Overloaded in-place ``-=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Subtract another image or a scalar from an Image in place.
-
-        :seealso: :meth:`__sub__`
-        """
-
-#################### ImageCore.py/Image.__truediv__
-"""
-        Overloaded ``/`` operator
-
-        :return: element-wise division of images
-        :rtype: :class:`Image`
-
-        Compute the quotient of an Image with another image or a scalar.
-        Supports:
-
-        * image ``/`` image, element-wise
-        * scalar ``/`` image
-        * image ``/`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img / img
-            >>> z.array
-            >>> z = img / 2
-            >>> z.array
-
-        .. note:: The resulting values are floating point.
-        """
-
-#################### ImageCore.py/Image.__itruediv__
-"""
-        Overloaded in-place ``/=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Divide an Image in place by another image or a scalar.
-
-        :seealso: :meth:`__truediv__`
-        """
-
-#################### ImageCore.py/Image.__floordiv__
-"""
-        Overloaded ``//`` operator
-
-        :return: element-wise floored division of images
-        :rtype: :class:`Image`
-
-        Compute the integer quotient of an Image with another image or a scalar.
-        Supports:
-
-        * image ``//`` image
-        * scalar ``//`` image
-        * image ``//`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img / 2
-            >>> z.array
-            >>> z = img // 2
-            >>> z.array
-        """
-
-#################### ImageCore.py/Image.__ifloordiv__
-"""
-        Overloaded in-place ``//=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Divide an Image in place by another image or a scalar, rounding down.
-
-        :seealso: :meth:`__floordiv__`
-        """
-
-#################### ImageCore.py/Image.__neg__
-"""
-        Overloaded unary ``-`` operator
-
-        :return: element-wise negation of image
-        :rtype: :class:`Image`
-
-
-        Compute the element-wise negation of an Image.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, -2], [-3, 4]], dtype='int8')
-            >>> img.print()
-            >>> neg_img = -img
-            >>> neg_img.print()
-        """
-
-#################### ImageCore.py/Image.__and__
-"""
-        Overloaded ``&`` operator
-
-        :return: element-wise binary-and of images
-        :rtype: :class:`Image`
-
-        Compute the binary-and of an Image with another image or a scalar.
-        Supports:
-
-        * image ``&`` image
-        * scalar ``&`` image
-        * image ``&`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img & Image([[2, 2], [2, 2]])
-            >>> z.array
-            >>> z = img & 1
-            >>> z.array
-        """
-
-#################### ImageCore.py/Image.__iand__
-"""
-        Overloaded in-place ``&=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Bitwise-AND an Image in place with another image or a scalar.
-
-        :seealso: :meth:`__and__`
-        """
-
-#################### ImageCore.py/Image.__or__
-"""
-        Overloaded ``|`` operator
-
-        :return: element-wise binary-or of images
-        :rtype: :class:`Image`
-
-        Compute the binary-or of an Image with another image or a scalar.
-        Supports:
-
-        * image ``|`` image
-        * scalar ``|`` image
-        * image ``|`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img | Image([[2, 2], [2, 2]])
-            >>> z.array
-            >>> z = img | 1
-            >>> z.array
-        """
-
-#################### ImageCore.py/Image.__ior__
-"""
-        Overloaded in-place ``|=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Bitwise-OR an Image in place with another image or a scalar.
-
-        :seealso: :meth:`__or__`
-        """
-
-#################### ImageCore.py/Image.__xor__
-"""
-        Overloaded ``^`` operator
-
-        :return: element-wise binary-xor of images
-        :rtype: :class:`Image`
-
-        Compute the binary-xor of an Image with another image or a scalar.
-        Supports:
-
-        * image ``^`` image
-        * scalar ``^`` image
-        * image ``^`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img ^ Image([[2, 2], [2, 2]])
-            >>> z.array
-            >>> z = img ^ 1
-            >>> z.array
-        """
-
-#################### ImageCore.py/Image.__ixor__
-"""
-        Overloaded in-place ``^=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Bitwise-XOR an Image in place with another image or a scalar.
-
-        :seealso: :meth:`__xor__`
-        """
-
-#################### ImageCore.py/Image.__lshift__
-"""
-        Overloaded ``<<`` operator
-
-        :return: element-wise binary-left-shift of images
-        :rtype: :class:`Image`
-
-        Left shift pixel values in an Image.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img  << 1
-            >>> z.array
-        """
-
-#################### ImageCore.py/Image.__ilshift__
-"""
-        Overloaded in-place ``<<=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Left-shift pixel values of an Image in place.
-
-        :seealso: :meth:`__lshift__`
-        """
-
-#################### ImageCore.py/Image.__rshift__
-"""
-        Overloaded ``>>`` operator
-
-        :return: element-wise binary-right-shift of images
-        :rtype: :class:`Image`
-
-        Right shift pixel values in an Image.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img >> 2
-            >>> z.array
-        """
-
-#################### ImageCore.py/Image.__irshift__
-"""
-        Overloaded in-place ``>>=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Right-shift pixel values of an Image in place.
-
-        :seealso: :meth:`__rshift__`
-        """
-
-#################### ImageCore.py/Image.__mod__
-"""
-        Overloaded ``%`` operator
-
-        :return: image with stacked planes
-        :rtype: :class:`Image`
-
-        ``img1 % img2`` results in an image with the planes of ``img1`` followed by the
-        planes of ``img2``.  The two images must have the same number of rows and
-        columns and data type. The color order of the resulting image is the color order of ``img1``
-        followed by the color order of ``img2``.
-
-        The operation also supports stacking a scalar as a plane onto an image, in which case the
-        resulting image has one more plane than the original image and the new plane is filled with
-        the scalar value.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> z = img % Image([[5, 6], [7, 8]])
-            >>> print(z.nplanes)
-            >>> z = img % 0
-            >>> print(z.nplanes)
-
-        :seealso: :meth:`Pstack`
-        """
-
-#################### ImageCore.py/Image.__imod__
-"""
-        Overloaded in-place ``%=`` operator
-
-        :return: self, modified in place
-        :rtype: :class:`Image`
-
-        Stack the planes of another image (or a scalar plane) onto this Image
-        in place.
-
-        :seealso: :meth:`__mod__`
-        """
-
-#################### ImageCore.py/Image.__eq__
-"""
-        Overloaded ``==`` operator
-
-        :return: element-wise comparison of pixels
-        :rtype: bool :class:`Image`
-
-        Compute the equality between an Image and another image or a scalar.
-        Supports:
-
-            * image ``==`` image
-            * scalar ``==`` image
-            * image ``==`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> (img == 2).print()
-            >>> (img == Image([[0, 2], [3, 4]])).print()
-
-        :seealso: :meth:`true` :meth:`false`
-        """
-
-#################### ImageCore.py/Image.sameas
-"""
-        Compare two images for exact equality and return a scalar bool.
-
-        :param other: image to compare against
-        :type other: :class:`Image`
-        :param colororder: compare ``colororder_str`` values if ``True``, defaults to ``True``
-        :type colororder: bool, optional
-        :return: exact image equality test
-        :rtype: bool
-
-        Unlike ``==``, which returns an element-wise boolean Image,
-        this method returns ``True`` only if:
-
-            * ``other`` is an :class:`Image`
-            * image shape is identical
-            * image dtype is identical
-            * color order is identical (if ``colororder`` is ``True``)
-            * all pixel values are identical
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> a = Image([[1, 2], [3, 4]])
-            >>> b = Image([[1, 2], [3, 4]])
-            >>> a.sameas(b)
-            True
-        """
-
-#################### ImageCore.py/Image.__ne__
-"""
-        Overloaded ``!=`` operator
-
-        :return: element-wise comparison of pixels
-        :rtype: bool :class:`Image`
-
-        Compute the inequality between an Image and another image or a scalar.
-        Supports:
-
-            * image ``!=`` image
-            * scalar ``!=`` image
-            * image ``!=`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> (img != 2).print()
-            >>> (img != Image([[0, 2], [3, 4]])).print()
-
-        :seealso: :meth:`true` :meth:`false`
-        """
-
-#################### ImageCore.py/Image.__gt__
-"""
-        Overloaded ``>`` operator
-
-        :return: element-wise comparison of pixels
-        :rtype: bool :class:`Image`
-
-        Compute the inequality between an Image and another image or a scalar.
-        Supports:
-
-            * image ``>`` image
-            * scalar ``>`` image
-            * image ``>`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> (img > 2).print()
-            >>> (img > Image([[0, 2], [3, 4]])).print()
-
-        :seealso: :meth:`true` :meth:`false`
-        """
-
-#################### ImageCore.py/Image.__ge__
-"""
-        Overloaded ``>=`` operator
-
-        :return: element-wise comparison of pixels
-        :rtype: bool :class:`Image`
-
-        Compute the inequality between an Image and another image or a scalar.
-        Supports:
-
-            * image ``>=`` image
-            * scalar ``>=`` image
-            * image ``>=`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> (img >= 2).print()
-            >>> (img >= Image([[0, 2], [3, 4]])).print()
-
-        :seealso: :meth:`true` :meth:`false`
-        """
-
-#################### ImageCore.py/Image.__lt__
-"""
-        Overloaded ``<`` operator
-
-        :return: element-wise comparison of images
-        :rtype: bool :class:`Image`
-
-        Compute the inequality between an Image and another image or a scalar.
-        Supports:
-
-            * image ``<`` image
-            * scalar ``<`` image
-            * image ``<`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> (img < 2).print()
-            >>> (img < Image([[0, 2], [3, 4]])).print()
-
-        :seealso: :meth:`true` :meth:`false`
-        """
-
-#################### ImageCore.py/Image.__le__
-"""
-        Overloaded ``<=`` operator
-
-        :return: element-wise comparison of images
-        :rtype: bool :class:`Image`
-
-        Compute the inequality between an Image and another image or a scalar.
-        Supports:
-
-            * image ``<=`` image
-            * scalar ``<=`` image
-            * image ``<=`` scalar
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> (img <= 2).print()
-            >>> (img <= Image([[0, 2], [3, 4]])).print()
-
-        :seealso: :meth:`true` :meth:`false`
-        """
-
-#################### ImageCore.py/Image.__invert__
-"""
-        Overloaded ``~`` operator
-
-        :return: element-wise inversion of logical values
-        :rtype: boo, :class:`Image`
-
-        Returns logical not operation where image values are interpretted as:
-
-            * floating image: True is 1.0, False is 0.0
-            * integer image: True is maximum value, False is 0 True is 1 and False is 0.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[True, False], [False, True]])
-            >>> z = ~img
-            >>> z.print()
-        """
-
-#################### ImageCore.py/Image.abs
-"""
-        Absolute value of image
-
-        :return: element-wise absolute value of image
-        :rtype: :class:`Image`
-
-        Return element-wise absolute value of pixel values.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[-1, 2], [3, -4]], dtype='int8')
-            >>> img.abs().print()
-        """
-
-#################### ImageCore.py/Image.sqrt
-"""
-        Square root of image
-
-        :return: element-wise square root of image
-        :rtype: :class:`Image`
-
-        Return element-wise square root of pixel values.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2], [3, 4]])
-            >>> img.sqrt().print()
-        """
-
-#################### ImageCore.py/Image.draw_line
-"""
-        Draw line into image
-
-        :param start: start coordinate (u,v)
-        :type start: array_like(2)
-        :param end: end coordinate (u,v)
-        :type end: array_like(2)
-        :param kwargs: parameters passed to :func:`~machinevisiontoolbox.base.graphics.draw_line`
-
-        Example, "burn" a line into the Mona Lisa image:
-
-            .. code-block:: python
-
-                from machinevisiontoolbox import Image
-                img = Image.Read("monalisa.png")
-                img.draw_line((20,30), (500,600), thickness=5, color="orange")
-                img.disp()
-
-
-        .. plot::
-
-            from machinevisiontoolbox import Image
-            img = Image.Read("monalisa.png")
-            img.draw_line((20,30), (500,600), thickness=5, color="orange")
-            img.disp()
-
-        .. note:: If ``image`` has multiple planes then ``color`` should have the same number
-            of elements as the image has planes. If it is a scalar that value is used
-            for each color plane. For a color image ``color`` can be
-            a string color name.
-
-        :seealso: :func:`~machinevisiontoolbox.base.graphics.draw_line`
-        """
-
-#################### ImageCore.py/Image.draw_circle
-"""
-        Draw circle into image
-
-        :param centre: centre coordinate (u,v)
-        :type centre: array_like(2)
-        :param radius: circle radius in pixels
-        :type radius: int
-        :param kwargs: parameters passed to :func:`~machinevisiontoolbox.base.graphics.draw_circle`
-
-        Example, "burn" some circles (confetti) into the Mona Lisa:
-
-            .. code-block:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> import matplotlib as mpl
-            >>> img = Image.Read("monalisa.png")
-            >>> colors = mpl.color_sequences["petroff10"]
-            >>> for color in colors:
-            ...     u = np.random.randint(20, img.umax-20)
-                    v = np.random.randint(20, img.vmax-20)
-                    r = np.random.randint(10, 50)
-                    img.draw_circle((u, v), r, thickness=-1, color=[255*c for c in color])
-            >>> img.disp(img)
-
-
-        .. plot::
-
-            from machinevisiontoolbox import Image
-            import matplotlib as mpl
-            img = Image.Read("monalisa.png")
-            for color in mpl.color_sequences["petroff10"]:
-                u = np.random.randint(20, img.umax-20)
-                v = np.random.randint(20, img.vmax-20)
-                r = np.random.randint(10, 50)
-                img.draw_circle((u, v), r, thickness=-1, color=[255*c for c in color])
-            img.disp(img)
-
-        .. note:: If ``image`` has multiple planes then ``color`` should have the same number
-            of elements as the image has planes. If it is a scalar that value is used
-            for each color plane. For a color image ``color`` can be
-            a string color name.
-
-        :seealso: :func:`~machinevisiontoolbox.base.graphics.draw_circle`
-        """
-
-#################### ImageCore.py/Image.draw_box
-"""
-        Draw box into image
-
-        :param kwargs: parameters passed to :func:`~machinevisiontoolbox.base.graphics.draw_box`
-
-        There are myriad ways to specify the corners of the box.
-
-        Example, draw boxes over the eyes of the Mona Lisa:
-
-            .. code-block:: python
-
-                from machinevisiontoolbox import Image
-                img = Image.Read("monalisa.png")
-                img.draw_box(lb=(245,170), rt=(290, 210), color="yellow", thickness=5)
-                img.draw_box(lb=(315, 175), rt=(370,205), color="blue", thickness=-1)
-                img.disp()
-
-
-        .. plot::
-
-            from machinevisiontoolbox import Image
-            img = Image.Read("monalisa.png")
-            img.draw_box(lt=(245,210), rb=(290, 170), color="yellow", thickness=5)
-            img.draw_box(lt=(315, 205), rb=(370,175), color="blue", thickness=-1)
-            img.disp()
-
-        .. note:: If ``image`` has multiple planes then ``color`` should have the same number
-            of elements as the image has planes. If it is a scalar that value is used
-            for each color plane. For a color image ``color`` can be
-            a string color name.
-
-        :seealso: :func:`~machinevisiontoolbox.base.graphics.draw_box`
-        """
-
-#################### ImageCore.py/Image.draw_labelbox
-"""
-        Draw label box into image
-
-        :param text: text for the box label
-        :type text: str
-        :param kwargs: parameters passed to :func:`~machinevisiontoolbox.base.graphics.draw_labelbox` to
-            specify the box position, color, etc.
-
-        The box position is specified by the parameters accepted by :func:`~machinevisiontoolbox.base.graphics.draw_box`
-
-        Example:
-
-            .. code-block:: python
-
-                from machinevisiontoolbox import Image
-                img = Image.Read("monalisa.png")
-                img.draw_labelbox("Face", lb=(243,111), rt=(394,329), color="yellow", fontheight=20)
-                img.disp()
-
-
-        .. plot::
-
-            from machinevisiontoolbox import Image
-            img = Image.Read("monalisa.png")
-            img.draw_labelbox("Face", lb=(243,111), rt=(394,329), color="yellow", fontheight=20)
-            img.disp()
-
-        .. note:: If ``image`` has multiple planes then ``color`` should have the same number
-            of elements as the image has planes. If it is a scalar that value is used
-            for each color plane. For a color image ``color`` can be
-            a string color name.
-
-        :seealso: :func:`~machinevisiontoolbox.base.graphics.draw_labelbox`
-        """
-
-#################### ImageCore.py/Image.draw_text
-"""
-        Draw text into image
-        :param pos: text position (u,v)
-        :type pos: array_like(2)
-        :param text: text to draw
-        :type text: str
-        :param kwargs: parameters passed to :func:`~machinevisiontoolbox.base.graphics.draw_text`
-
-        Example:
-
-            .. code-block:: python
-
-                from machinevisiontoolbox import Image
-                img = Image.Read("monalisa.png")
-                img.draw_text((340,290), "Smile!", fontheight=40, color="yellow")
-                img.disp()
-
-
-        .. plot::
-
-            from machinevisiontoolbox import Image
-            img = Image.Read("monalisa.png")
-            img.draw_text((340,290), "Smile!", fontheight=40, color="yellow")
-            img.disp()
-
-        .. note:: If ``image`` has multiple planes then ``color`` should have the same number
-            of elements as the image has planes. If it is a scalar that value is used
-            for each color plane. For a color image ``color`` can be
-            a string color name.
-
-        :seealso: :func:`~machinevisiontoolbox.base.graphics.draw_text`
-        """
-
-#################### ImageCore.py/Image.draw_point
-"""
-        Draw a marker in image
-
-        :param pos: position of marker
-        :type pos: array_like(2), ndarray(2,n), list of 2-tuples
-        :param marker: marker character, defaults to "+"
-        :type marker: str, optional
-        :param text: text label, defaults to None
-        :type text: str, optional
-        :param kwargs: parameters passed to :func:`~machinevisiontoolbox.base.graphics.draw_point`
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image.Read("monalisa.png")
-            >>> img.draw_point((270,194), "+", "eye", fontsize=1, color="yellow")
-            >>> img.draw_point((293,246), "*", "nose", fontsize=1, color="blue")
-            >>> img.disp()
-
-        .. plot::
-
-            from machinevisiontoolbox import Image
-            img = Image.Read("monalisa.png")
-            img.draw_point((270,194), "+", "eye", fontsize=1, color="yellow")
-            img.draw_point((293,246), "*", "nose", fontsize=1, color="blue")
-            img.disp()
-
-        .. note:: If ``image`` has multiple planes then ``color`` should have the same number
-            of elements as the image has planes. If it is a scalar that value is used
-            for each color plane. For a color image ``color`` can be
-            a string color name.
-
-        :seealso: :func:`~machinevisiontoolbox.base.graphics.draw_text`
-        """
-
-#################### ImageCore.py/Image.Pstack
-"""
-        Concatenation of image planes
-
-        :param images: images to concatenate plane-wise
-        :type images: iterable of :class:`Image`
-        :param colororder: color order for the result, defaults to None
-        :type colororder: str, optional
-        :raises ValueError: all images must have the same dtype
-        :raises ValueError: all images must have the same size
-        :return: plane-stacked image
-        :rtype: :class:`Image`
-
-        Create a new image by stacking the planes of the input images.
-        All images must have the same width, height and dtype. The resulting
-        image has a number of planes equal to the sum of planes in all input images.
-
-        If ``colororder`` is not specified and all images have color orders defined,
-        the result's color order is constructed by concatenating the color orders
-        of the input images.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> r = Image.Random(size=(100, 120), colororder='R')
-            >>> g = Image.Random(size=(100, 120), colororder='G')
-            >>> b = Image.Random(size=(100, 120), colororder='B')
-            >>> rgb = Image.Pstack((r, g, b))
-            >>> rgb.nplanes
-            >>> rgb.colororder_str
-
-        :seealso: :meth:`Vstack` :meth:`Hstack`
-
-        AUTO_EDIT
-        """
-
-#################### ImageCore.py/Image.fliplr
-"""
-        Flip image left-right
-
-        :return: horizontally flipped image
-        :rtype: :class:`Image`
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2, 3], [4, 5, 6]])
-            >>> img.fliplr().A
-
-        :seealso: :meth:`flipud`
-        """
-
-#################### ImageCore.py/Image.flipud
-"""
-        Flip image up-down
-
-        :return: vertically flipped image
-        :rtype: :class:`Image`
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> img = Image([[1, 2, 3], [4, 5, 6]])
-            >>> img.flipud().A
-
-        :seealso: :meth:`fliplr`
-        """
-
-#################### ImageCore.py/Image.fixbad
-"""
-        Fix bad values in image
-
-        :param nan: value to replace NaN values, defaults to 0.0
-        :type nan: scalar or array-like(n), optional
-        :param posinf: value to replace positive infinity values, defaults to maximum value of image dtype
-        :type posinf: scalar or array-like(n), optional
-        :param neginf: value to replace negative infinity values, defaults to negative maximum value of image dtype
-        :type neginf: scalar or array-like(n), optional
-        :return: image with bad values fixed
-        :rtype: :class:`~machinevisiontoolbox.ImageCore.Image` instance
-
-        Return an image where any pixel that contains a NaN or Inf values has been
-        replaced by the specified replacement values.
-
-        The replacement value can be a scalar, in which case all bad values are replaced
-        by the same value, or an array-like of length n, where n is the number of
-        channels in the image, in which case each channel is replaced by the
-        corresponding value.
-
-        By default NaN values are replaced by 0, positive infinity values are replaced
-        by the maximum value of the image dtype, and negative infinity values are
-        replaced by the negative maximum value of the image dtype.
-
-        Example:
-
-        .. runblock:: pycon
-
-            >>> from machinevisiontoolbox import Image
-            >>> from numpy import nan, inf
-            >>> img = Image([[1, 2, 3], [4, nan, 6], [7, 8, inf]])
-            >>> img.fixbad(posinf=99).print()
-
-        """
-