thesby的专栏

专注于机器学习

用 python skimage做图像处理

导言:由于经常需要处理图像,习惯了matlab那么好用的图像处理工具箱,搬到python后有点不知所措了。搜了下python图像处理方面的库,好多PIL的教程,但是无奈的是PIL和numpy等结合不好,而且半天找不到图像处理的函数在哪里,只好作罢;终于搜到了skimage,:-),喜出望外,因为它是和scipy、numpy可以完美结合的,那么就可以很好的使用numpy了。废话不多说,直接上干货吧。

step 1 概览

学习一个python库第一步是干啥?百度、Google搜教程?No,这不是我的风格。第一步就是直接 import。

import skimage
help(skimage)

看看输出:

Help on package skimage:

NAME
    skimage - Image Processing SciKit (Toolbox for SciPy)

FILE
    /usr/local/lib/python2.7/dist-packages/skimage/__init__.py

DESCRIPTION
    ``scikit-image`` (a.k.a. ``skimage``) is a collection of algorithms for image
    processing and computer vision.

    The main package of ``skimage`` only provides a few utilities for converting
    between image data types; for most features, you need to import one of the
    following subpackages:

    Subpackages
    -----------
    color
        Color space conversion.
    data
        Test images and example data.
    draw
        Drawing primitives (lines, text, etc.) that operate on NumPy arrays.
    exposure
        Image intensity adjustment, e.g., histogram equalization, etc.
    feature
        Feature detection and extraction, e.g., texture analysis corners, etc.
    filters
        Sharpening, edge finding, rank filters, thresholding, etc.
    graph
        Graph-theoretic operations, e.g., shortest paths.
    io
        Reading, saving, and displaying images and video.
    measure
        Measurement of image properties, e.g., similarity and contours.
    morphology
        Morphological operations, e.g., opening or skeletonization.
    novice
        Simplified interface for teaching purposes.
    restoration
        Restoration algorithms, e.g., deconvolution algorithms, denoising, etc.
    segmentation
        Partitioning an image into multiple regions.
    transform
        Geometric and other transforms, e.g., rotation or the Radon transform.
    util
        Generic utilities.
    viewer
        A simple graphical user interface for visualizing results and exploring
        parameters.

    Utility Functions
    -----------------
    img_as_float
        Convert an image to floating point format, with values in [0, 1].
    img_as_uint
        Convert an image to unsigned integer format, with values in [0, 65535].
    img_as_int
        Convert an image to signed integer format, with values in [-32768, 32767].
    img_as_ubyte
        Convert an image to unsigned byte format, with values in [0, 255].

PACKAGE CONTENTS
    _build
    _shared (package)
    color (package)
    data (package)
    draw (package)
    exposure (package)
    external (package)
    feature (package)
    filter (package)
    filters (package)
    future (package)
    graph (package)
    io (package)
    measure (package)
    morphology (package)
    novice (package)
    restoration (package)
    scripts (package)
    segmentation (package)
    setup
    transform (package)
    util (package)
    viewer (package)

FUNCTIONS
    test = _test(doctest=False, verbose=False)
        Run all unit tests.

DATA
    __SKIMAGE_SETUP__ = False
    __version__ = '0.12.3'
    data_dir = '/usr/local/lib/python2.7/dist-packages/skimage/data'
    doctest = <functools.partial object>
    doctest_verbose = <functools.partial object>
    pkg_dir = '/usr/local/lib/python2.7/dist-packages/skimage'
    test_verbose = <functools.partial object>

VERSION
    0.12.3

我们可以看到这里有好几个package是单独的,这意味着使用时要单独import。里面有那么多的库,每一个干啥用的?不要问,自己用help看看就知道了。

step 2 IO

我们这里看看如何读写图像文件。这个在skimage.io里面。

import skimage, skimage.io
help(skimage.io)
Help on package skimage.io in skimage:

NAME
    skimage.io - Utilities to read and write images in various formats.

FILE
    /usr/local/lib/python2.7/dist-packages/skimage/io/__init__.py

DESCRIPTION
    The following plug-ins are available:

    ========== ==============================================================
    Plugin     Description
    ---------- --------------------------------------------------------------
    pil        Image reading via the Python Imaging Library
    qt         Fast image display using the Qt library
    freeimage  Load images using the FreeImage library
    gtk        Fast image display using the GTK library
    matplotlib Display or save images using Matplotlib
    fits       FITS image reading via PyFITS
    simpleitk  Image reading and writing via SimpleITK
    imageio    Image reading via the ImageIO Library
    imread     Image reading and writing via imread
    tifffile   Load and save TIFF and TIFF-based images using tifffile.py
    gdal       Image reading via the GDAL Library (www.gdal.org)
    ========== ==============================================================

PACKAGE CONTENTS
    _image_stack
    _io
    _plugins (package)
    collection
    manage_plugins
    setup
    sift
    tests (package)
    util

DATA
    WRAP_LEN = 73
    available_plugins = {'fits': ['imread', 'imread_collection'], 'freeima...
    image_stack = []

好像没有列出全部的函数,没关系,继续看。

dir(skimage.io)
['ImageCollection',
 'MultiImage',
 'WRAP_LEN',
 '__builtins__',
 '__doc__',
 '__file__',
 '__name__',
 '__package__',
 '__path__',
 '_format_plugin_info_table',
 '_image_stack',
 '_io',
 '_plugins',
 '_separator',
 '_update_doc',
 'available_plugins',
 'call_plugin',
 'collection',
 'concatenate_images',
 'find_available_plugins',
 'image_stack',
 'imread',
 'imread_collection',
 'imread_collection_wrapper',
 'imsave',
 'imshow',
 'imshow_collection',
 'load_sift',
 'load_surf',
 'manage_plugins',
 'plugin_info',
 'plugin_order',
 'pop',
 'push',
 'reset_plugins',
 'show',
 'sift',
 'use_plugin',
 'util']
  1. imread: 和matlab一样,就是读取图像
  2. imsave: 和matlab一样,就是存储图像
  3. imshow: 调用的matplotlib的显示,所以必须再使用show才能真正显示。
    其他的就不多说了,自己help就很清楚了。

step 3 形态学变换

由step1可以看出形态学变换的东西肯定就在 skimage.morphology里面了。

import skimage, skimage.morphology
help(skimage.morphology)
Help on package skimage.morphology in skimage:

NAME
    skimage.morphology

FILE
    /usr/local/lib/python2.7/dist-packages/skimage/morphology/__init__.py

PACKAGE CONTENTS
    _convex_hull
    _greyreconstruct
    _skeletonize
    _skeletonize_3d
    _skeletonize_3d_cy
    _skeletonize_cy
    _watershed
    binary
    convex_hull
    grey
    greyreconstruct
    misc
    selem
    setup
    tests (package)
    watershed

FUNCTIONS
    ball(radius, dtype=<type 'numpy.uint8'>)
        Generates a ball-shaped structuring element.

        This is the 3D equivalent of a disk.
        A pixel is within the neighborhood if the euclidean distance between
        it and the origin is no greater than radius.

        Parameters
        ----------
        radius : int
            The radius of the ball-shaped structuring element.

        Other Parameters
        ----------------
        dtype : data-type
            The data type of the structuring element.

        Returns
        -------
        selem : ndarray
            The structuring element where elements of the neighborhood
            are 1 and 0 otherwise.

    binary_closing(image, selem=None, *args, **kwargs)
        Return fast binary morphological closing of an image.

        This function returns the same result as greyscale closing but performs
        faster for binary images.

        The morphological closing on an image is defined as a dilation followed by
        an erosion. Closing can remove small dark spots (i.e. "pepper") and connect
        small bright cracks. This tends to "close" up (dark) gaps between (bright)
        features.

        Parameters
        ----------
        image : ndarray
            Binary input image.
        selem : ndarray, optional
            The neighborhood expressed as a 2-D array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarray of bool, optional
            The array to store the result of the morphology. If None,
            is passed, a new array will be allocated.

        Returns
        -------
        closing : ndarray of bool
            The result of the morphological closing.

    binary_dilation(image, selem=None, *args, **kwargs)
        Return fast binary morphological dilation of an image.

        This function returns the same result as greyscale dilation but performs
        faster for binary images.

        Morphological dilation sets a pixel at ``(i,j)`` to the maximum over all
        pixels in the neighborhood centered at ``(i,j)``. Dilation enlarges bright
        regions and shrinks dark regions.

        Parameters
        ----------

        image : ndarray
            Binary input image.
        selem : ndarray, optional
            The neighborhood expressed as a 2-D array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarray of bool, optional
            The array to store the result of the morphology. If None, is
            passed, a new array will be allocated.

        Returns
        -------
        dilated : ndarray of bool or uint
            The result of the morphological dilation with values in
            ``[False, True]``.

    binary_erosion(image, selem=None, *args, **kwargs)
        Return fast binary morphological erosion of an image.

        This function returns the same result as greyscale erosion but performs
        faster for binary images.

        Morphological erosion sets a pixel at ``(i,j)`` to the minimum over all
        pixels in the neighborhood centered at ``(i,j)``. Erosion shrinks bright
        regions and enlarges dark regions.

        Parameters
        ----------
        image : ndarray
            Binary input image.
        selem : ndarray, optional
            The neighborhood expressed as a 2-D array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarray of bool, optional
            The array to store the result of the morphology. If None is
            passed, a new array will be allocated.

        Returns
        -------
        eroded : ndarray of bool or uint
            The result of the morphological erosion taking values in
            ``[False, True]``.

    binary_opening(image, selem=None, *args, **kwargs)
        Return fast binary morphological opening of an image.

        This function returns the same result as greyscale opening but performs
        faster for binary images.

        The morphological opening on an image is defined as an erosion followed by
        a dilation. Opening can remove small bright spots (i.e. "salt") and connect
        small dark cracks. This tends to "open" up (dark) gaps between (bright)
        features.

        Parameters
        ----------
        image : ndarray
            Binary input image.
        selem : ndarray, optional
            The neighborhood expressed as a 2-D array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarray of bool, optional
            The array to store the result of the morphology. If None
            is passed, a new array will be allocated.

        Returns
        -------
        opening : ndarray of bool
            The result of the morphological opening.

    black_tophat(image, selem=None, *args, **kwargs)
        Return black top hat of an image.

        The black top hat of an image is defined as its morphological closing minus
        the original image. This operation returns the dark spots of the image that
        are smaller than the structuring element. Note that dark spots in the
        original image are bright spots after the black top hat.

        Parameters
        ----------
        image : ndarray
            Image array.
        selem : ndarray, optional
            The neighborhood expressed as a 2-D array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarray, optional
            The array to store the result of the morphology. If None
            is passed, a new array will be allocated.

        Returns
        -------
        opening : array, same shape and type as `image`
           The result of the black top filter.

        Examples
        --------
        >>> # Change dark peak to bright peak and subtract background
        >>> import numpy as np
        >>> from skimage.morphology import square
        >>> dark_on_grey = np.array([[7, 6, 6, 6, 7],
        ...                          [6, 5, 4, 5, 6],
        ...                          [6, 4, 0, 4, 6],
        ...                          [6, 5, 4, 5, 6],
        ...                          [7, 6, 6, 6, 7]], dtype=np.uint8)
        >>> black_tophat(dark_on_grey, square(3))
        array([[0, 0, 0, 0, 0],
               [0, 0, 1, 0, 0],
               [0, 1, 5, 1, 0],
               [0, 0, 1, 0, 0],
               [0, 0, 0, 0, 0]], dtype=uint8)

    closing(image, selem=None, *args, **kwargs)
        Return greyscale morphological closing of an image.

        The morphological closing on an image is defined as a dilation followed by
        an erosion. Closing can remove small dark spots (i.e. "pepper") and connect
        small bright cracks. This tends to "close" up (dark) gaps between (bright)
        features.

        Parameters
        ----------
        image : ndarray
            Image array.
        selem : ndarray, optional
            The neighborhood expressed as an array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarray, optional
            The array to store the result of the morphology. If None,
            is passed, a new array will be allocated.

        Returns
        -------
        closing : array, same shape and type as `image`
            The result of the morphological closing.

        Examples
        --------
        >>> # Close a gap between two bright lines
        >>> import numpy as np
        >>> from skimage.morphology import square
        >>> broken_line = np.array([[0, 0, 0, 0, 0],
        ...                         [0, 0, 0, 0, 0],
        ...                         [1, 1, 0, 1, 1],
        ...                         [0, 0, 0, 0, 0],
        ...                         [0, 0, 0, 0, 0]], dtype=np.uint8)
        >>> closing(broken_line, square(3))
        array([[0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0],
               [1, 1, 1, 1, 1],
               [0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0]], dtype=uint8)

    convex_hull_image(image)
        Compute the convex hull image of a binary image.

        The convex hull is the set of pixels included in the smallest convex
        polygon that surround all white pixels in the input image.

        Parameters
        ----------
        image : (M, N) array
            Binary input image. This array is cast to bool before processing.

        Returns
        -------
        hull : (M, N) array of bool
            Binary image with pixels in convex hull set to True.

        References
        ----------
        .. [1] http://blogs.mathworks.com/steve/2011/10/04/binary-image-convex-hull-algorithm-notes/

    convex_hull_object(image, neighbors=8)
        Compute the convex hull image of individual objects in a binary image.

        The convex hull is the set of pixels included in the smallest convex
        polygon that surround all white pixels in the input image.

        Parameters
        ----------
        image : (M, N) array
            Binary input image.
        neighbors : {4, 8}, int
            Whether to use 4- or 8-connectivity.

        Returns
        -------
        hull : ndarray of bool
            Binary image with pixels in convex hull set to True.

        Notes
        -----
        This function uses skimage.morphology.label to define unique objects,
        finds the convex hull of each using convex_hull_image, and combines
        these regions with logical OR. Be aware the convex hulls of unconnected
        objects may overlap in the result. If this is suspected, consider using
        convex_hull_image separately on each object.

    cube(width, dtype=<type 'numpy.uint8'>)
        Generates a cube-shaped structuring element.

        This is the 3D equivalent of a square.
        Every pixel along the perimeter has a chessboard distance
        no greater than radius (radius=floor(width/2)) pixels.

        Parameters
        ----------
        width : int
            The width, height and depth of the cube.

        Other Parameters
        ----------------
        dtype : data-type
            The data type of the structuring element.

        Returns
        -------
        selem : ndarray
            A structuring element consisting only of ones, i.e. every
            pixel belongs to the neighborhood.

    diamond(radius, dtype=<type 'numpy.uint8'>)
        Generates a flat, diamond-shaped structuring element.

        A pixel is part of the neighborhood (i.e. labeled 1) if
        the city block/Manhattan distance between it and the center of
        the neighborhood is no greater than radius.

        Parameters
        ----------
        radius : int
            The radius of the diamond-shaped structuring element.

        Other Parameters
        ----------------
        dtype : data-type
            The data type of the structuring element.

        Returns
        -------

        selem : ndarray
            The structuring element where elements of the neighborhood
            are 1 and 0 otherwise.

    dilation(image, selem=None, *args, **kwargs)
        Return greyscale morphological dilation of an image.

        Morphological dilation sets a pixel at (i,j) to the maximum over all pixels
        in the neighborhood centered at (i,j). Dilation enlarges bright regions
        and shrinks dark regions.

        Parameters
        ----------

        image : ndarray
            Image array.
        selem : ndarray, optional
            The neighborhood expressed as a 2-D array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarray, optional
            The array to store the result of the morphology. If None, is
            passed, a new array will be allocated.
        shift_x, shift_y : bool, optional
            shift structuring element about center point. This only affects
            eccentric structuring elements (i.e. selem with even numbered sides).

        Returns
        -------
        dilated : uint8 array, same shape and type as `image`
            The result of the morphological dilation.

        Notes
        -----
        For `uint8` (and `uint16` up to a certain bit-depth) data, the lower
        algorithm complexity makes the `skimage.filter.rank.maximum` function more
        efficient for larger images and structuring elements.

        Examples
        --------
        >>> # Dilation enlarges bright regions
        >>> import numpy as np
        >>> from skimage.morphology import square
        >>> bright_pixel = np.array([[0, 0, 0, 0, 0],
        ...                          [0, 0, 0, 0, 0],
        ...                          [0, 0, 1, 0, 0],
        ...                          [0, 0, 0, 0, 0],
        ...                          [0, 0, 0, 0, 0]], dtype=np.uint8)
        >>> dilation(bright_pixel, square(3))
        array([[0, 0, 0, 0, 0],
               [0, 1, 1, 1, 0],
               [0, 1, 1, 1, 0],
               [0, 1, 1, 1, 0],
               [0, 0, 0, 0, 0]], dtype=uint8)

    disk(radius, dtype=<type 'numpy.uint8'>)
        Generates a flat, disk-shaped structuring element.

        A pixel is within the neighborhood if the euclidean distance between
        it and the origin is no greater than radius.

        Parameters
        ----------
        radius : int
            The radius of the disk-shaped structuring element.

        Other Parameters
        ----------------
        dtype : data-type
            The data type of the structuring element.

        Returns
        -------
        selem : ndarray
            The structuring element where elements of the neighborhood
            are 1 and 0 otherwise.

    erosion(image, selem=None, *args, **kwargs)
        Return greyscale morphological erosion of an image.

        Morphological erosion sets a pixel at (i,j) to the minimum over all pixels
        in the neighborhood centered at (i,j). Erosion shrinks bright regions and
        enlarges dark regions.

        Parameters
        ----------
        image : ndarray
            Image array.
        selem : ndarray, optional
            The neighborhood expressed as an array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarrays, optional
            The array to store the result of the morphology. If None is
            passed, a new array will be allocated.
        shift_x, shift_y : bool, optional
            shift structuring element about center point. This only affects
            eccentric structuring elements (i.e. selem with even numbered sides).

        Returns
        -------
        eroded : array, same shape as `image`
            The result of the morphological erosion.

        Notes
        -----
        For ``uint8`` (and ``uint16`` up to a certain bit-depth) data, the
        lower algorithm complexity makes the `skimage.filter.rank.minimum`
        function more efficient for larger images and structuring elements.

        Examples
        --------
        >>> # Erosion shrinks bright regions
        >>> import numpy as np
        >>> from skimage.morphology import square
        >>> bright_square = np.array([[0, 0, 0, 0, 0],
        ...                           [0, 1, 1, 1, 0],
        ...                           [0, 1, 1, 1, 0],
        ...                           [0, 1, 1, 1, 0],
        ...                           [0, 0, 0, 0, 0]], dtype=np.uint8)
        >>> erosion(bright_square, square(3))
        array([[0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0],
               [0, 0, 1, 0, 0],
               [0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0]], dtype=uint8)

    label(input, neighbors=None, background=None, return_num=False, connectivity=None)
        Label connected regions of an integer array.

        Two pixels are connected when they are neighbors and have the same value.
        In 2D, they can be neighbors either in a 1- or 2-connected sense.
        The value refers to the maximum number of orthogonal hops to consider a
        pixel/voxel a neighbor::

          1-connectivity      2-connectivity     diagonal connection close-up

               [ ]           [ ]  [ ]  [ ]         [ ]
                |               \  |  /             |  <- hop 2
          [ ]--[x]--[ ]      [ ]--[x]--[ ]    [x]--[ ]
                |               /  |  \         hop 1
               [ ]           [ ]  [ ]  [ ]

        Parameters
        ----------
        input : ndarray of dtype int
            Image to label.
        neighbors : {4, 8}, int, optional
            Whether to use 4- or 8-"connectivity".
            In 3D, 4-"connectivity" means connected pixels have to share face,
            whereas with 8-"connectivity", they have to share only edge or vertex.
            **Deprecated, use ``connectivity`` instead.**
        background : int, optional
            Consider all pixels with this value as background pixels, and label
            them as 0. By default, 0-valued pixels are considered as background
            pixels.
        return_num : bool, optional
            Whether to return the number of assigned labels.
        connectivity : int, optional
            Maximum number of orthogonal hops to consider a pixel/voxel
            as a neighbor.
            Accepted values are ranging from  1 to input.ndim. If ``None``, a full
            connectivity of ``input.ndim`` is used.

        Returns
        -------
        labels : ndarray of dtype int
            Labeled array, where all connected regions are assigned the
            same integer value.
        num : int, optional
            Number of labels, which equals the maximum label index and is only
            returned if return_num is `True`.

        Examples
        --------
        >>> import numpy as np
        >>> x = np.eye(3).astype(int)
        >>> print(x)
        [[1 0 0]
         [0 1 0]
         [0 0 1]]
        >>> from skimage.measure import label
        >>> print(label(x, connectivity=1))
        [[1 0 0]
         [0 2 0]
         [0 0 3]]

        >>> print(label(x, connectivity=2))
        [[1 0 0]
         [0 1 0]
         [0 0 1]]

        >>> print(label(x, background=-1))
        [[1 2 2]
         [2 1 2]
         [2 2 1]]

        >>> x = np.array([[1, 0, 0],
        ...               [1, 1, 5],
        ...               [0, 0, 0]])

        >>> print(label(x))
        [[1 0 0]
         [1 1 2]
         [0 0 0]]

    medial_axis(image, mask=None, return_distance=False)
        Compute the medial axis transform of a binary image

        Parameters
        ----------
        image : binary ndarray, shape (M, N)
            The image of the shape to be skeletonized.
        mask : binary ndarray, shape (M, N), optional
            If a mask is given, only those elements in `image` with a true
            value in `mask` are used for computing the medial axis.
        return_distance : bool, optional
            If true, the distance transform is returned as well as the skeleton.

        Returns
        -------
        out : ndarray of bools
            Medial axis transform of the image
        dist : ndarray of ints, optional
            Distance transform of the image (only returned if `return_distance`
            is True)

        See also
        --------
        skeletonize

        Notes
        -----
        This algorithm computes the medial axis transform of an image
        as the ridges of its distance transform.

        The different steps of the algorithm are as follows
         * A lookup table is used, that assigns 0 or 1 to each configuration of
           the 3x3 binary square, whether the central pixel should be removed
           or kept. We want a point to be removed if it has more than one neighbor
           and if removing it does not change the number of connected components.

         * The distance transform to the background is computed, as well as
           the cornerness of the pixel.

         * The foreground (value of 1) points are ordered by
           the distance transform, then the cornerness.

         * A cython function is called to reduce the image to its skeleton. It
           processes pixels in the order determined at the previous step, and
           removes or maintains a pixel according to the lookup table. Because
           of the ordering, it is possible to process all pixels in only one
           pass.

        Examples
        --------
        >>> square = np.zeros((7, 7), dtype=np.uint8)
        >>> square[1:-1, 2:-2] = 1
        >>> square
        array([[0, 0, 0, 0, 0, 0, 0],
               [0, 0, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 0, 0],
               [0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
        >>> medial_axis(square).astype(np.uint8)
        array([[0, 0, 0, 0, 0, 0, 0],
               [0, 0, 1, 0, 1, 0, 0],
               [0, 0, 0, 1, 0, 0, 0],
               [0, 0, 0, 1, 0, 0, 0],
               [0, 0, 0, 1, 0, 0, 0],
               [0, 0, 1, 0, 1, 0, 0],
               [0, 0, 0, 0, 0, 0, 0]], dtype=uint8)

    octagon(m, n, dtype=<type 'numpy.uint8'>)
        Generates an octagon shaped structuring element.

        For a given size of (m) horizontal and vertical sides
        and a given (n) height or width of slanted sides octagon is generated.
        The slanted sides are 45 or 135 degrees to the horizontal axis
        and hence the widths and heights are equal.

        Parameters
        ----------
        m : int
            The size of the horizontal and vertical sides.
        n : int
            The height or width of the slanted sides.

        Other Parameters
        ----------------
        dtype : data-type
            The data type of the structuring element.

        Returns
        -------
        selem : ndarray
            The structuring element where elements of the neighborhood
            are 1 and 0 otherwise.

    octahedron(radius, dtype=<type 'numpy.uint8'>)
        Generates a octahedron-shaped structuring element.

        This is the 3D equivalent of a diamond.
        A pixel is part of the neighborhood (i.e. labeled 1) if
        the city block/Manhattan distance between it and the center of
        the neighborhood is no greater than radius.

        Parameters
        ----------
        radius : int
            The radius of the octahedron-shaped structuring element.

        Other Parameters
        ----------------
        dtype : data-type
            The data type of the structuring element.

        Returns
        -------

        selem : ndarray
            The structuring element where elements of the neighborhood
            are 1 and 0 otherwise.

    opening(image, selem=None, *args, **kwargs)
        Return greyscale morphological opening of an image.

        The morphological opening on an image is defined as an erosion followed by
        a dilation. Opening can remove small bright spots (i.e. "salt") and connect
        small dark cracks. This tends to "open" up (dark) gaps between (bright)
        features.

        Parameters
        ----------
        image : ndarray
            Image array.
        selem : ndarray, optional
            The neighborhood expressed as an array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarray, optional
            The array to store the result of the morphology. If None
            is passed, a new array will be allocated.

        Returns
        -------
        opening : array, same shape and type as `image`
            The result of the morphological opening.

        Examples
        --------
        >>> # Open up gap between two bright regions (but also shrink regions)
        >>> import numpy as np
        >>> from skimage.morphology import square
        >>> bad_connection = np.array([[1, 0, 0, 0, 1],
        ...                            [1, 1, 0, 1, 1],
        ...                            [1, 1, 1, 1, 1],
        ...                            [1, 1, 0, 1, 1],
        ...                            [1, 0, 0, 0, 1]], dtype=np.uint8)
        >>> opening(bad_connection, square(3))
        array([[0, 0, 0, 0, 0],
               [1, 1, 0, 1, 1],
               [1, 1, 0, 1, 1],
               [1, 1, 0, 1, 1],
               [0, 0, 0, 0, 0]], dtype=uint8)

    reconstruction(seed, mask, method='dilation', selem=None, offset=None)
        Perform a morphological reconstruction of an image.

        Morphological reconstruction by dilation is similar to basic morphological
        dilation: high-intensity values will replace nearby low-intensity values.
        The basic dilation operator, however, uses a structuring element to
        determine how far a value in the input image can spread. In contrast,
        reconstruction uses two images: a "seed" image, which specifies the values
        that spread, and a "mask" image, which gives the maximum allowed value at
        each pixel. The mask image, like the structuring element, limits the spread
        of high-intensity values. Reconstruction by erosion is simply the inverse:
        low-intensity values spread from the seed image and are limited by the mask
        image, which represents the minimum allowed value.

        Alternatively, you can think of reconstruction as a way to isolate the
        connected regions of an image. For dilation, reconstruction connects
        regions marked by local maxima in the seed image: neighboring pixels
        less-than-or-equal-to those seeds are connected to the seeded region.
        Local maxima with values larger than the seed image will get truncated to
        the seed value.

        Parameters
        ----------
        seed : ndarray
            The seed image (a.k.a. marker image), which specifies the values that
            are dilated or eroded.
        mask : ndarray
            The maximum (dilation) / minimum (erosion) allowed value at each pixel.
        method : {'dilation'|'erosion'}
            Perform reconstruction by dilation or erosion. In dilation (or
            erosion), the seed image is dilated (or eroded) until limited by the
            mask image. For dilation, each seed value must be less than or equal
            to the corresponding mask value; for erosion, the reverse is true.
        selem : ndarray
            The neighborhood expressed as a 2-D array of 1's and 0's.

        Returns
        -------
        reconstructed : ndarray
           The result of morphological reconstruction.

        Examples
        --------
        >>> import numpy as np
        >>> from skimage.morphology import reconstruction

        First, we create a sinusoidal mask image with peaks at middle and ends.

        >>> x = np.linspace(0, 4 * np.pi)
        >>> y_mask = np.cos(x)

        Then, we create a seed image initialized to the minimum mask value (for
        reconstruction by dilation, min-intensity values don't spread) and add
        "seeds" to the left and right peak, but at a fraction of peak value (1).

        >>> y_seed = y_mask.min() * np.ones_like(x)
        >>> y_seed[0] = 0.5
        >>> y_seed[-1] = 0
        >>> y_rec = reconstruction(y_seed, y_mask)

        The reconstructed image (or curve, in this case) is exactly the same as the
        mask image, except that the peaks are truncated to 0.5 and 0. The middle
        peak disappears completely: Since there were no seed values in this peak
        region, its reconstructed value is truncated to the surrounding value (-1).

        As a more practical example, we try to extract the bright features of an
        image by subtracting a background image created by reconstruction.

        >>> y, x = np.mgrid[:20:0.5, :20:0.5]
        >>> bumps = np.sin(x) + np.sin(y)

        To create the background image, set the mask image to the original image,
        and the seed image to the original image with an intensity offset, `h`.

        >>> h = 0.3
        >>> seed = bumps - h
        >>> background = reconstruction(seed, bumps)

        The resulting reconstructed image looks exactly like the original image,
        but with the peaks of the bumps cut off. Subtracting this reconstructed
        image from the original image leaves just the peaks of the bumps

        >>> hdome = bumps - background

        This operation is known as the h-dome of the image and leaves features
        of height `h` in the subtracted image.

        Notes
        -----
        The algorithm is taken from [1]_. Applications for greyscale reconstruction
        are discussed in [2]_ and [3]_.

        References
        ----------
        .. [1] Robinson, "Efficient morphological reconstruction: a downhill
               filter", Pattern Recognition Letters 25 (2004) 1759-1767.
        .. [2] Vincent, L., "Morphological Grayscale Reconstruction in Image
               Analysis: Applications and Efficient Algorithms", IEEE Transactions
               on Image Processing (1993)
        .. [3] Soille, P., "Morphological Image Analysis: Principles and
               Applications", Chapter 6, 2nd edition (2003), ISBN 3540429883.

    rectangle(width, height, dtype=<type 'numpy.uint8'>)
        Generates a flat, rectangular-shaped structuring element.

        Every pixel in the rectangle generated for a given width and given height
        belongs to the neighborhood.

        Parameters
        ----------
        width : int
            The width of the rectangle.
        height : int
            The height of the rectangle.

        Other Parameters
        ----------------
        dtype : data-type
            The data type of the structuring element.

        Returns
        -------
        selem : ndarray
            A structuring element consisting only of ones, i.e. every
            pixel belongs to the neighborhood.

    remove_small_holes(ar, min_size=64, connectivity=1, in_place=False)
        Remove continguous holes smaller than the specified size.

        Parameters
        ----------
        ar : ndarray (arbitrary shape, int or bool type)
            The array containing the connected components of interest.
        min_size : int, optional (default: 64)
            The hole component size.
        connectivity : int, {1, 2, ..., ar.ndim}, optional (default: 1)
            The connectivity defining the neighborhood of a pixel.
        in_place : bool, optional (default: False)
            If `True`, remove the connected components in the input array itself.
            Otherwise, make a copy.

        Raises
        ------
        TypeError
            If the input array is of an invalid type, such as float or string.
        ValueError
            If the input array contains negative values.

        Returns
        -------
        out : ndarray, same shape and type as input `ar`
            The input array with small holes within connected components removed.

        Examples
        --------
        >>> from skimage import morphology
        >>> a = np.array([[1, 1, 1, 1, 1, 0],
        ...               [1, 1, 1, 0, 1, 0],
        ...               [1, 0, 0, 1, 1, 0],
        ...               [1, 1, 1, 1, 1, 0]], bool)
        >>> b = morphology.remove_small_holes(a, 2)
        >>> b
        array([[ True,  True,  True,  True,  True, False],
               [ True,  True,  True,  True,  True, False],
               [ True, False, False,  True,  True, False],
               [ True,  True,  True,  True,  True, False]], dtype=bool)
        >>> c = morphology.remove_small_holes(a, 2, connectivity=2)
        >>> c
        array([[ True,  True,  True,  True,  True, False],
               [ True,  True,  True, False,  True, False],
               [ True, False, False,  True,  True, False],
               [ True,  True,  True,  True,  True, False]], dtype=bool)
        >>> d = morphology.remove_small_holes(a, 2, in_place=True)
        >>> d is a
        True

        Notes
        -----

        If the array type is int, it is assumed that it contains already-labeled
        objects. The labels are not kept in the output image (this function always
        outputs a bool image). It is suggested that labeling is completed after
        using this function.

    remove_small_objects(ar, min_size=64, connectivity=1, in_place=False)
        Remove connected components smaller than the specified size.

        Parameters
        ----------
        ar : ndarray (arbitrary shape, int or bool type)
            The array containing the connected components of interest. If the array
            type is int, it is assumed that it contains already-labeled objects.
            The ints must be non-negative.
        min_size : int, optional (default: 64)
            The smallest allowable connected component size.
        connectivity : int, {1, 2, ..., ar.ndim}, optional (default: 1)
            The connectivity defining the neighborhood of a pixel.
        in_place : bool, optional (default: False)
            If `True`, remove the connected components in the input array itself.
            Otherwise, make a copy.

        Raises
        ------
        TypeError
            If the input array is of an invalid type, such as float or string.
        ValueError
            If the input array contains negative values.

        Returns
        -------
        out : ndarray, same shape and type as input `ar`
            The input array with small connected components removed.

        Examples
        --------
        >>> from skimage import morphology
        >>> a = np.array([[0, 0, 0, 1, 0],
        ...               [1, 1, 1, 0, 0],
        ...               [1, 1, 1, 0, 1]], bool)
        >>> b = morphology.remove_small_objects(a, 6)
        >>> b
        array([[False, False, False, False, False],
               [ True,  True,  True, False, False],
               [ True,  True,  True, False, False]], dtype=bool)
        >>> c = morphology.remove_small_objects(a, 7, connectivity=2)
        >>> c
        array([[False, False, False,  True, False],
               [ True,  True,  True, False, False],
               [ True,  True,  True, False, False]], dtype=bool)
        >>> d = morphology.remove_small_objects(a, 6, in_place=True)
        >>> d is a
        True

    skeletonize(image)
        Return the skeleton of a binary image.

        Thinning is used to reduce each connected component in a binary image
        to a single-pixel wide skeleton.

        Parameters
        ----------
        image : numpy.ndarray
            A binary image containing the objects to be skeletonized. '1'
            represents foreground, and '0' represents background. It
            also accepts arrays of boolean values where True is foreground.

        Returns
        -------
        skeleton : ndarray
            A matrix containing the thinned image.

        See also
        --------
        medial_axis

        Notes
        -----
        The algorithm [1]_ works by making successive passes of the image,
        removing pixels on object borders. This continues until no
        more pixels can be removed.  The image is correlated with a
        mask that assigns each pixel a number in the range [0...255]
        corresponding to each possible pattern of its 8 neighbouring
        pixels. A look up table is then used to assign the pixels a
        value of 0, 1, 2 or 3, which are selectively removed during
        the iterations.

        Note that this algorithm will give different results than a
        medial axis transform, which is also often referred to as
        "skeletonization".

        References
        ----------
        .. [1] A fast parallel algorithm for thinning digital patterns,
               T. Y. Zhang and C. Y. Suen, Communications of the ACM,
               March 1984, Volume 27, Number 3.


        Examples
        --------
        >>> X, Y = np.ogrid[0:9, 0:9]
        >>> ellipse = (1./3 * (X - 4)**2 + (Y - 4)**2 < 3**2).astype(np.uint8)
        >>> ellipse
        array([[0, 0, 0, 1, 1, 1, 0, 0, 0],
               [0, 0, 1, 1, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 1, 1, 0, 0],
               [0, 0, 1, 1, 1, 1, 1, 0, 0],
               [0, 0, 0, 1, 1, 1, 0, 0, 0]], dtype=uint8)
        >>> skel = skeletonize(ellipse)
        >>> skel.astype(np.uint8)
        array([[0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 1, 0, 0, 0, 0],
               [0, 0, 0, 0, 1, 0, 0, 0, 0],
               [0, 0, 0, 0, 1, 0, 0, 0, 0],
               [0, 0, 0, 0, 1, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0],
               [0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)

    skeletonize_3d(img)
        Compute the skeleton of a binary image.

        Thinning is used to reduce each connected component in a binary image
        to a single-pixel wide skeleton.

        Parameters
        ----------
        img : ndarray, 2D or 3D
            A binary image containing the objects to be skeletonized. Zeros
            represent background, nonzero values are foreground.

        Returns
        -------
        skeleton : ndarray
            The thinned image.

        See also
        --------
        skeletonize, medial_axis

        Notes
        -----
        The method of [Lee94]_ uses an octree data structure to examine a 3x3x3
        neighborhood of a pixel. The algorithm proceeds by iteratively sweeping
        over the image, and removing pixels at each iteration until the image
        stops changing. Each iteration consists of two steps: first, a list of
        candidates for removal is assembled; then pixels from this list are
        rechecked sequentially, to better preserve connectivity of the image.

        The algorithm this function implements is different from the algorithms
        used by either `skeletonize` or `medial_axis`, thus for 2D images the
        results produced by this function are generally different.

        References
        ----------
        .. [Lee94] T.-C. Lee, R.L. Kashyap and C.-N. Chu, Building skeleton models
               via 3-D medial surface/axis thinning algorithms.
               Computer Vision, Graphics, and Image Processing, 56(6):462-478, 1994.

    square(width, dtype=<type 'numpy.uint8'>)
        Generates a flat, square-shaped structuring element.

        Every pixel along the perimeter has a chessboard distance
        no greater than radius (radius=floor(width/2)) pixels.

        Parameters
        ----------
        width : int
            The width and height of the square.

        Other Parameters
        ----------------
        dtype : data-type
            The data type of the structuring element.

        Returns
        -------
        selem : ndarray
            A structuring element consisting only of ones, i.e. every
            pixel belongs to the neighborhood.

    watershed(image, markers, connectivity=None, offset=None, mask=None)
        Return a matrix labeled using the watershed segmentation algorithm

        Parameters
        ----------

        image: ndarray (2-D, 3-D, ...) of integers
            Data array where the lowest value points are labeled first.
        markers: ndarray of the same shape as `image`
            An array marking the basins with the values to be assigned in the
            label matrix. Zero means not a marker. This array should be of an
            integer type.
        connectivity: ndarray, optional
            An array with the same number of dimensions as `image` whose
            non-zero elements indicate neighbors for connection.
            Following the scipy convention, default is a one-connected array of
            the dimension of the image.
        offset: array_like of shape image.ndim, optional
            offset of the connectivity (one offset per dimension)
        mask: ndarray of bools or 0s and 1s, optional
            Array of same shape as `image`. Only points at which mask == True
            will be labeled.

        Returns
        -------
        out: ndarray
            A labeled matrix of the same type and shape as markers

        See also
        --------

        skimage.segmentation.random_walker: random walker segmentation
            A segmentation algorithm based on anisotropic diffusion, usually
            slower than the watershed but with good results on noisy data and
            boundaries with holes.

        Notes
        -----
        This function implements a watershed algorithm [1]_that apportions pixels
        into marked basins. The algorithm uses a priority queue to hold the pixels
        with the metric for the priority queue being pixel value, then the time of
        entry into the queue - this settles ties in favor of the closest marker.

        Some ideas taken from
        Soille, "Automated Basin Delineation from Digital Elevation Models Using
        Mathematical Morphology", Signal Processing 20 (1990) 171-182

        The most important insight in the paper is that entry time onto the queue
        solves two problems: a pixel should be assigned to the neighbor with the
        largest gradient or, if there is no gradient, pixels on a plateau should
        be split between markers on opposite sides.

        This implementation converts all arguments to specific, lowest common
        denominator types, then passes these to a C algorithm.

        Markers can be determined manually, or automatically using for example
        the local minima of the gradient of the image, or the local maxima of the
        distance function to the background for separating overlapping objects
        (see example).

        References
        ----------
        .. [1] http://en.wikipedia.org/wiki/Watershed_%28image_processing%29

        .. [2] http://cmm.ensmp.fr/~beucher/wtshed.html

        Examples
        --------
        The watershed algorithm is very useful to separate overlapping objects

        >>> # Generate an initial image with two overlapping circles
        >>> x, y = np.indices((80, 80))
        >>> x1, y1, x2, y2 = 28, 28, 44, 52
        >>> r1, r2 = 16, 20
        >>> mask_circle1 = (x - x1)**2 + (y - y1)**2 < r1**2
        >>> mask_circle2 = (x - x2)**2 + (y - y2)**2 < r2**2
        >>> image = np.logical_or(mask_circle1, mask_circle2)
        >>> # Now we want to separate the two objects in image
        >>> # Generate the markers as local maxima of the distance
        >>> # to the background
        >>> from scipy import ndimage as ndi
        >>> distance = ndi.distance_transform_edt(image)
        >>> from skimage.feature import peak_local_max
        >>> local_maxi = peak_local_max(distance, labels=image,
        ...                             footprint=np.ones((3, 3)),
        ...                             indices=False)
        >>> markers = ndi.label(local_maxi)[0]
        >>> labels = watershed(-distance, markers, mask=image)

        The algorithm works also for 3-D images, and can be used for example to
        separate overlapping spheres.

    white_tophat(image, selem=None, *args, **kwargs)
        Return white top hat of an image.

        The white top hat of an image is defined as the image minus its
        morphological opening. This operation returns the bright spots of the image
        that are smaller than the structuring element.

        Parameters
        ----------
        image : ndarray
            Image array.
        selem : ndarray, optional
            The neighborhood expressed as an array of 1's and 0's.
            If None, use cross-shaped structuring element (connectivity=1).
        out : ndarray, optional
            The array to store the result of the morphology. If None
            is passed, a new array will be allocated.

        Returns
        -------
        out : array, same shape and type as `image`
            The result of the morphological white top hat.

        Examples
        --------
        >>> # Subtract grey background from bright peak
        >>> import numpy as np
        >>> from skimage.morphology import square
        >>> bright_on_grey = np.array([[2, 3, 3, 3, 2],
        ...                            [3, 4, 5, 4, 3],
        ...                            [3, 5, 9, 5, 3],
        ...                            [3, 4, 5, 4, 3],
        ...                            [2, 3, 3, 3, 2]], dtype=np.uint8)
        >>> white_tophat(bright_on_grey, square(3))
        array([[0, 0, 0, 0, 0],
               [0, 0, 1, 0, 0],
               [0, 1, 5, 1, 0],
               [0, 0, 1, 0, 0],
               [0, 0, 0, 0, 0]], dtype=uint8)

DATA
    __all__ = ['binary_erosion', 'binary_dilation', 'binary_opening', 'bin...

这个也真够长的,也很详细。
想看看所有函数有哪些?

dir(skimage.morphology)
['__all__',
 '__builtins__',
 '__doc__',
 '__file__',
 '__name__',
 '__package__',
 '__path__',
 '_convex_hull',
 '_skeletonize',
 '_skeletonize_3d',
 '_skeletonize_3d_cy',
 '_skeletonize_cy',
 '_watershed',
 'ball',
 'binary',
 'binary_closing',
 'binary_dilation',
 'binary_erosion',
 'binary_opening',
 'black_tophat',
 'closing',
 'convex_hull',
 'convex_hull_image',
 'convex_hull_object',
 'cube',
 'diamond',
 'dilation',
 'disk',
 'erosion',
 'grey',
 'greyreconstruct',
 'label',
 'medial_axis',
 'misc',
 'octagon',
 'octahedron',
 'opening',
 'reconstruction',
 'rectangle',
 'remove_small_holes',
 'remove_small_objects',
 'selem',
 'skeletonize',
 'skeletonize_3d',
 'square',
 'star',
 'watershed',
 'white_tophat']
阅读更多
版权声明:本文为博主原创文章,转载时务必将原文链接置于转载文章首部可见处,尊重博主劳动。博主研究生一枚,现在正在找工作,对深度学习非常感兴趣,希望有做这方面的公司收留,谢谢! https://blog.csdn.net/thesby/article/details/51340894
文章标签: python 图像处理
个人分类: 图像处理
上一篇caffe python layer
下一篇Linux大文件的切割与合并
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭