Module: draw
¶
|
Generate Bezier curve coordinates. |
|
Generate coordinates of pixels within circle. |
|
Generate circle perimeter coordinates. |
|
Generate anti-aliased circle perimeter coordinates. |
|
Generate coordinates of pixels within circle. |
|
Generate coordinates of pixels within ellipse. |
|
Generate ellipse perimeter coordinates. |
|
Generates ellipsoid with semimajor axes aligned with grid dimensions on grid with specified spacing. |
|
Calculates analytical surface area and volume for ellipsoid with semimajor axes aligned with grid dimensions of specified spacing. |
|
Generate line pixel coordinates. |
|
Generate anti-aliased line pixel coordinates. |
|
Draw a single-pixel thick line in n dimensions. |
|
Generate coordinates of pixels within polygon. |
|
Compute a mask from polygon. |
|
Generate polygon perimeter coordinates. |
|
Generate an image with random shapes, labeled with bounding boxes. |
|
Generate coordinates of pixels within a rectangle. |
|
Generate coordinates of pixels that are exactly around a rectangle. |
|
Set pixel color in the image at the given coordinates. |
bezier_curve¶
-
skimage.draw.
bezier_curve
(r0, c0, r1, c1, r2, c2, weight, shape=None)[source]¶ Generate Bezier curve coordinates.
- Parameters
r0, c0 : int
Coordinates of the first control point.
r1, c1 : int
Coordinates of the middle control point.
r2, c2 : int
Coordinates of the last control point.
weight : double
Middle control point weight, it describes the line tension.
shape : tuple, optional
Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for curves that exceed the image size. If None, the full extent of the curve is used.
- Returns
rr, cc : (N,) ndarray of int
Indices of pixels that belong to the Bezier curve. May be used to directly index into an array, e.g.
img[rr, cc] = 1
.
Notes
The algorithm is the rational quadratic algorithm presented in reference [R99].
References
- R99(1,2)
A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012 http://members.chello.at/easyfilter/Bresenham.pdf
Examples
>>> import numpy as np >>> from skimage.draw import bezier_curve >>> img = np.zeros((10, 10), dtype=np.uint8) >>> rr, cc = bezier_curve(1, 5, 5, -2, 8, 8, 2) >>> img[rr, cc] = 1 >>> img array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 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, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
circle¶
-
skimage.draw.
circle
(r, c, radius, shape=None)[source]¶ Generate coordinates of pixels within circle.
- Parameters
r, c : double
Center coordinate of disk.
radius : double
Radius of disk.
shape : tuple, optional
Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for disks that exceed the image size. If None, the full extent of the disk is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.
- Returns
rr, cc : ndarray of int
Pixel coordinates of disk. May be used to directly index into an array, e.g.
img[rr, cc] = 1
.- Warns
Deprecated:
New in version 0.17: This function is deprecated and will be removed in scikit-image 0.19. Please use the function named
disk
instead.
circle_perimeter¶
-
skimage.draw.
circle_perimeter
(r, c, radius, method='bresenham', shape=None)[source]¶ Generate circle perimeter coordinates.
- Parameters
r, c : int
Centre coordinate of circle.
radius : int
Radius of circle.
method : {‘bresenham’, ‘andres’}, optional
bresenham : Bresenham method (default) andres : Andres method
shape : tuple, optional
Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for circles that exceed the image size. If None, the full extent of the circle is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.
- Returns
rr, cc : (N,) ndarray of int
Bresenham and Andres’ method: Indices of pixels that belong to the circle perimeter. May be used to directly index into an array, e.g.
img[rr, cc] = 1
.
Notes
Andres method presents the advantage that concentric circles create a disc whereas Bresenham can make holes. There is also less distortions when Andres circles are rotated. Bresenham method is also known as midpoint circle algorithm. Anti-aliased circle generator is available with
circle_perimeter_aa
.References
- R100
J.E. Bresenham, “Algorithm for computer control of a digital plotter”, IBM Systems journal, 4 (1965) 25-30.
- R101
E. Andres, “Discrete circles, rings and spheres”, Computers & Graphics, 18 (1994) 695-706.
Examples
>>> from skimage.draw import circle_perimeter >>> img = np.zeros((10, 10), dtype=np.uint8) >>> rr, cc = circle_perimeter(4, 4, 3) >>> img[rr, cc] = 1 >>> img array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
circle_perimeter_aa¶
-
skimage.draw.
circle_perimeter_aa
(r, c, radius, shape=None)[source]¶ Generate anti-aliased circle perimeter coordinates.
- Parameters
r, c : int
Centre coordinate of circle.
radius : int
Radius of circle.
shape : tuple, optional
Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for circles that exceed the image size. If None, the full extent of the circle is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.
- Returns
rr, cc, val : (N,) ndarray (int, int, float)
Indices of pixels (rr, cc) and intensity values (val).
img[rr, cc] = val
.
Notes
Wu’s method draws anti-aliased circle. This implementation doesn’t use lookup table optimization.
Use the function
draw.set_color
to applycircle_perimeter_aa
results to color images.References
- R102
X. Wu, “An efficient antialiasing technique”, In ACM SIGGRAPH Computer Graphics, 25 (1991) 143-152.
Examples
>>> from skimage.draw import circle_perimeter_aa >>> img = np.zeros((10, 10), dtype=np.uint8) >>> rr, cc, val = circle_perimeter_aa(4, 4, 3) >>> img[rr, cc] = val * 255 >>> img array([[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 0, 0, 60, 211, 255, 211, 60, 0, 0, 0], [ 0, 60, 194, 43, 0, 43, 194, 60, 0, 0], [ 0, 211, 43, 0, 0, 0, 43, 211, 0, 0], [ 0, 255, 0, 0, 0, 0, 0, 255, 0, 0], [ 0, 211, 43, 0, 0, 0, 43, 211, 0, 0], [ 0, 60, 194, 43, 0, 43, 194, 60, 0, 0], [ 0, 0, 60, 211, 255, 211, 60, 0, 0, 0], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
>>> from skimage import data, draw >>> image = data.chelsea() >>> rr, cc, val = draw.circle_perimeter_aa(r=100, c=100, radius=75) >>> draw.set_color(image, (rr, cc), [1, 0, 0], alpha=val)
disk¶
-
skimage.draw.
disk
(center, radius, *, shape=None)[source]¶ Generate coordinates of pixels within circle.
- Parameters
center : tuple
Center coordinate of disk.
radius : double
Radius of disk.
shape : tuple, optional
Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for disks that exceed the image size. If None, the full extent of the disk is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.
- Returns
rr, cc : ndarray of int
Pixel coordinates of disk. May be used to directly index into an array, e.g.
img[rr, cc] = 1
.
Examples
>>> from skimage.draw import disk >>> img = np.zeros((10, 10), dtype=np.uint8) >>> rr, cc = disk((4, 4), 5) >>> img[rr, cc] = 1 >>> img array([[0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
ellipse¶
-
skimage.draw.
ellipse
(r, c, r_radius, c_radius, shape=None, rotation=0.0)[source]¶ Generate coordinates of pixels within ellipse.
- Parameters
r, c : double
Centre coordinate of ellipse.
r_radius, c_radius : double
Minor and major semi-axes.
(r/r_radius)**2 + (c/c_radius)**2 = 1
.shape : tuple, optional
Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for ellipses which exceed the image size. By default the full extent of the ellipse are used. Must be at least length 2. Only the first two values are used to determine the extent.
rotation : float, optional (default 0.)
Set the ellipse rotation (rotation) in range (-PI, PI) in contra clock wise direction, so PI/2 degree means swap ellipse axis
- Returns
rr, cc : ndarray of int
Pixel coordinates of ellipse. May be used to directly index into an array, e.g.
img[rr, cc] = 1
.
Notes
The ellipse equation:
((x * cos(alpha) + y * sin(alpha)) / x_radius) ** 2 + ((x * sin(alpha) - y * cos(alpha)) / y_radius) ** 2 = 1
Note that the positions of
ellipse
without specified shape can have also, negative values, as this is correct on the plane. On the other hand using these ellipse positions for an image afterwards may lead to appearing on the other side of image, becauseimage[-1, -1] = image[end-1, end-1]
>>> rr, cc = ellipse(1, 2, 3, 6) >>> img = np.zeros((6, 12), dtype=np.uint8) >>> img[rr, cc] = 1 >>> img array([[1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1]], dtype=uint8)
Examples
>>> from skimage.draw import ellipse >>> img = np.zeros((10, 12), dtype=np.uint8) >>> rr, cc = ellipse(5, 6, 3, 5, rotation=np.deg2rad(30)) >>> img[rr, cc] = 1 >>> img 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, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0], [0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
Examples using skimage.draw.ellipse
¶
ellipse_perimeter¶
-
skimage.draw.
ellipse_perimeter
(r, c, r_radius, c_radius, orientation=0, shape=None)[source]¶ Generate ellipse perimeter coordinates.
- Parameters
r, c : int
Centre coordinate of ellipse.
r_radius, c_radius : int
Minor and major semi-axes.
(r/r_radius)**2 + (c/c_radius)**2 = 1
.orientation : double, optional
Major axis orientation in clockwise direction as radians.
shape : tuple, optional
Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for ellipses that exceed the image size. If None, the full extent of the ellipse is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.
- Returns
rr, cc : (N,) ndarray of int
Indices of pixels that belong to the ellipse perimeter. May be used to directly index into an array, e.g.
img[rr, cc] = 1
.
References
- R103
A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012 http://members.chello.at/easyfilter/Bresenham.pdf
Examples
>>> from skimage.draw import ellipse_perimeter >>> img = np.zeros((10, 10), dtype=np.uint8) >>> rr, cc = ellipse_perimeter(5, 5, 3, 4) >>> img[rr, cc] = 1 >>> img array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 1], [0, 1, 0, 0, 0, 0, 0, 0, 0, 1], [0, 1, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
Note that the positions of
ellipse
without specified shape can have also, negative values, as this is correct on the plane. On the other hand using these ellipse positions for an image afterwards may lead to appearing on the other side of image, becauseimage[-1, -1] = image[end-1, end-1]
>>> rr, cc = ellipse_perimeter(2, 3, 4, 5) >>> img = np.zeros((9, 12), dtype=np.uint8) >>> img[rr, cc] = 1 >>> img array([[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]], dtype=uint8)
ellipsoid¶
-
skimage.draw.
ellipsoid
(a, b, c, spacing=(1.0, 1.0, 1.0), levelset=False)[source]¶ Generates ellipsoid with semimajor axes aligned with grid dimensions on grid with specified spacing.
- Parameters
a : float
Length of semimajor axis aligned with x-axis.
b : float
Length of semimajor axis aligned with y-axis.
c : float
Length of semimajor axis aligned with z-axis.
spacing : tuple of floats, length 3
Spacing in (x, y, z) spatial dimensions.
levelset : bool
If True, returns the level set for this ellipsoid (signed level set about zero, with positive denoting interior) as np.float64. False returns a binarized version of said level set.
- Returns
ellip : (N, M, P) array
Ellipsoid centered in a correctly sized array for given spacing. Boolean dtype unless levelset=True, in which case a float array is returned with the level set above 0.0 representing the ellipsoid.
Examples using skimage.draw.ellipsoid
¶
ellipsoid_stats¶
-
skimage.draw.
ellipsoid_stats
(a, b, c)[source]¶ Calculates analytical surface area and volume for ellipsoid with semimajor axes aligned with grid dimensions of specified spacing.
- Parameters
a : float
Length of semimajor axis aligned with x-axis.
b : float
Length of semimajor axis aligned with y-axis.
c : float
Length of semimajor axis aligned with z-axis.
- Returns
vol : float
Calculated volume of ellipsoid.
surf : float
Calculated surface area of ellipsoid.
line¶
-
skimage.draw.
line
(r0, c0, r1, c1)[source]¶ Generate line pixel coordinates.
- Parameters
r0, c0 : int
Starting position (row, column).
r1, c1 : int
End position (row, column).
- Returns
rr, cc : (N,) ndarray of int
Indices of pixels that belong to the line. May be used to directly index into an array, e.g.
img[rr, cc] = 1
.
Notes
Anti-aliased line generator is available with
line_aa
.Examples
>>> from skimage.draw import line >>> img = np.zeros((10, 10), dtype=np.uint8) >>> rr, cc = line(1, 1, 8, 8) >>> img[rr, cc] = 1 >>> img array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
line_aa¶
-
skimage.draw.
line_aa
(r0, c0, r1, c1)[source]¶ Generate anti-aliased line pixel coordinates.
- Parameters
r0, c0 : int
Starting position (row, column).
r1, c1 : int
End position (row, column).
- Returns
rr, cc, val : (N,) ndarray (int, int, float)
Indices of pixels (rr, cc) and intensity values (val).
img[rr, cc] = val
.
References
- R104
A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012 http://members.chello.at/easyfilter/Bresenham.pdf
Examples
>>> from skimage.draw import line_aa >>> img = np.zeros((10, 10), dtype=np.uint8) >>> rr, cc, val = line_aa(1, 1, 8, 8) >>> img[rr, cc] = val * 255 >>> img array([[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 0, 255, 74, 0, 0, 0, 0, 0, 0, 0], [ 0, 74, 255, 74, 0, 0, 0, 0, 0, 0], [ 0, 0, 74, 255, 74, 0, 0, 0, 0, 0], [ 0, 0, 0, 74, 255, 74, 0, 0, 0, 0], [ 0, 0, 0, 0, 74, 255, 74, 0, 0, 0], [ 0, 0, 0, 0, 0, 74, 255, 74, 0, 0], [ 0, 0, 0, 0, 0, 0, 74, 255, 74, 0], [ 0, 0, 0, 0, 0, 0, 0, 74, 255, 0], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
line_nd¶
-
skimage.draw.
line_nd
(start, stop, *, endpoint=False, integer=True)[source]¶ Draw a single-pixel thick line in n dimensions.
The line produced will be ndim-connected. That is, two subsequent pixels in the line will be either direct or diagonal neighbours in n dimensions.
- Parameters
start : array-like, shape (N,)
The start coordinates of the line.
stop : array-like, shape (N,)
The end coordinates of the line.
endpoint : bool, optional
Whether to include the endpoint in the returned line. Defaults to False, which allows for easy drawing of multi-point paths.
integer : bool, optional
Whether to round the coordinates to integer. If True (default), the returned coordinates can be used to directly index into an array. False could be used for e.g. vector drawing.
- Returns
coords : tuple of arrays
The coordinates of points on the line.
Examples
>>> lin = line_nd((1, 1), (5, 2.5), endpoint=False) >>> lin (array([1, 2, 3, 4]), array([1, 1, 2, 2])) >>> im = np.zeros((6, 5), dtype=int) >>> im[lin] = 1 >>> im array([[0, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 0]]) >>> line_nd([2, 1, 1], [5, 5, 2.5], endpoint=True) (array([2, 3, 4, 4, 5]), array([1, 2, 3, 4, 5]), array([1, 1, 2, 2, 2]))
polygon¶
-
skimage.draw.
polygon
(r, c, shape=None)[source]¶ Generate coordinates of pixels within polygon.
- Parameters
r : (N,) ndarray
Row coordinates of vertices of polygon.
c : (N,) ndarray
Column coordinates of vertices of polygon.
shape : tuple, optional
Image shape which is used to determine the maximum extent of output pixel coordinates. This is useful for polygons that exceed the image size. If None, the full extent of the polygon is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.
- Returns
rr, cc : ndarray of int
Pixel coordinates of polygon. May be used to directly index into an array, e.g.
img[rr, cc] = 1
.
Examples
>>> from skimage.draw import polygon >>> img = np.zeros((10, 10), dtype=np.uint8) >>> r = np.array([1, 2, 8]) >>> c = np.array([1, 7, 4]) >>> rr, cc = polygon(r, c) >>> img[rr, cc] = 1 >>> img array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 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, 0, 0, 0]], dtype=uint8)
polygon2mask¶
-
skimage.draw.
polygon2mask
(image_shape, polygon)[source]¶ Compute a mask from polygon.
- Parameters
image_shape : tuple of size 2.
The shape of the mask.
polygon : array_like.
The polygon coordinates of shape (N, 2) where N is the number of points.
- Returns
mask : 2-D ndarray of type ‘bool’.
The mask that corresponds to the input polygon.
Notes
This function does not do any border checking, so that all the vertices need to be within the given shape.
Examples
>>> image_shape = (128, 128) >>> polygon = np.array([[60, 100], [100, 40], [40, 40]]) >>> mask = polygon2mask(image_shape, polygon) >>> mask.shape (128, 128)
polygon_perimeter¶
-
skimage.draw.
polygon_perimeter
(r, c, shape=None, clip=False)[source]¶ Generate polygon perimeter coordinates.
- Parameters
r : (N,) ndarray
Row coordinates of vertices of polygon.
c : (N,) ndarray
Column coordinates of vertices of polygon.
shape : tuple, optional
Image shape which is used to determine maximum extents of output pixel coordinates. This is useful for polygons that exceed the image size. If None, the full extents of the polygon is used. Must be at least length 2. Only the first two values are used to determine the extent of the input image.
clip : bool, optional
Whether to clip the polygon to the provided shape. If this is set to True, the drawn figure will always be a closed polygon with all edges visible.
- Returns
rr, cc : ndarray of int
Pixel coordinates of polygon. May be used to directly index into an array, e.g.
img[rr, cc] = 1
.
Examples
>>> from skimage.draw import polygon_perimeter >>> img = np.zeros((10, 10), dtype=np.uint8) >>> rr, cc = polygon_perimeter([5, -1, 5, 10], ... [-1, 5, 11, 5], ... shape=img.shape, clip=True) >>> img[rr, cc] = 1 >>> img array([[0, 0, 0, 0, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 1, 1, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 1, 1, 1, 0, 0, 0]], dtype=uint8)
random_shapes¶
-
skimage.draw.
random_shapes
(image_shape, max_shapes, min_shapes=1, min_size=2, max_size=None, multichannel=True, num_channels=3, shape=None, intensity_range=None, allow_overlap=False, num_trials=100, random_seed=None)[source]¶ Generate an image with random shapes, labeled with bounding boxes.
The image is populated with random shapes with random sizes, random locations, and random colors, with or without overlap.
Shapes have random (row, col) starting coordinates and random sizes bounded by min_size and max_size. It can occur that a randomly generated shape will not fit the image at all. In that case, the algorithm will try again with new starting coordinates a certain number of times. However, it also means that some shapes may be skipped altogether. In that case, this function will generate fewer shapes than requested.
- Parameters
image_shape : tuple
The number of rows and columns of the image to generate.
max_shapes : int
The maximum number of shapes to (attempt to) fit into the shape.
min_shapes : int, optional
The minimum number of shapes to (attempt to) fit into the shape.
min_size : int, optional
The minimum dimension of each shape to fit into the image.
max_size : int, optional
The maximum dimension of each shape to fit into the image.
multichannel : bool, optional
If True, the generated image has
num_channels
color channels, otherwise generates grayscale image.num_channels : int, optional
Number of channels in the generated image. If 1, generate monochrome images, else color images with multiple channels. Ignored if
multichannel
is set to False.shape : {rectangle, circle, triangle, ellipse, None} str, optional
The name of the shape to generate or None to pick random ones.
intensity_range : {tuple of tuples of uint8, tuple of uint8}, optional
The range of values to sample pixel values from. For grayscale images the format is (min, max). For multichannel - ((min, max),) if the ranges are equal across the channels, and ((min_0, max_0), … (min_N, max_N)) if they differ. As the function supports generation of uint8 arrays only, the maximum range is (0, 255). If None, set to (0, 254) for each channel reserving color of intensity = 255 for background.
allow_overlap : bool, optional
If True, allow shapes to overlap.
num_trials : int, optional
How often to attempt to fit a shape into the image before skipping it.
random_seed : int, optional
Seed to initialize the random number generator. If None, a random seed from the operating system is used.
- Returns
image : uint8 array
An image with the fitted shapes.
labels : list
A list of labels, one per shape in the image. Each label is a (category, ((r0, r1), (c0, c1))) tuple specifying the category and bounding box coordinates of the shape.
Examples
>>> import skimage.draw >>> image, labels = skimage.draw.random_shapes((32, 32), max_shapes=3) >>> image array([ [[255, 255, 255], [255, 255, 255], [255, 255, 255], ..., [255, 255, 255], [255, 255, 255], [255, 255, 255]]], dtype=uint8) >>> labels [('circle', ((22, 18), (25, 21))), ('triangle', ((5, 6), (13, 13)))]
Examples using skimage.draw.random_shapes
¶
rectangle¶
-
skimage.draw.
rectangle
(start, end=None, extent=None, shape=None)[source]¶ Generate coordinates of pixels within a rectangle.
- Parameters
start : tuple
Origin point of the rectangle, e.g.,
([plane,] row, column)
.end : tuple
End point of the rectangle
([plane,] row, column)
. For a 2D matrix, the slice defined by the rectangle is[start:(end+1)]
. Either end or extent must be specified.extent : tuple
The extent (size) of the drawn rectangle. E.g.,
([num_planes,] num_rows, num_cols)
. Either end or extent must be specified. A negative extent is valid, and will result in a rectangle going along the oposite direction. If extent is negative, the start point is not included.shape : tuple, optional
Image shape used to determine the maximum bounds of the output coordinates. This is useful for clipping rectangles that exceed the image size. By default, no clipping is done.
- Returns
coords : array of int, shape (Ndim, Npoints)
The coordinates of all pixels in the rectangle.
Notes
This function can be applied to N-dimensional images, by passing start and end or extent as tuples of length N.
Examples
>>> import numpy as np >>> from skimage.draw import rectangle >>> img = np.zeros((5, 5), dtype=np.uint8) >>> start = (1, 1) >>> extent = (3, 3) >>> rr, cc = rectangle(start, extent=extent, shape=img.shape) >>> img[rr, cc] = 1 >>> img 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)
>>> img = np.zeros((5, 5), dtype=np.uint8) >>> start = (0, 1) >>> end = (3, 3) >>> rr, cc = rectangle(start, end=end, shape=img.shape) >>> img[rr, cc] = 1 >>> img array([[0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]], dtype=uint8)
>>> import numpy as np >>> from skimage.draw import rectangle >>> img = np.zeros((6, 6), dtype=np.uint8) >>> start = (3, 3) >>> >>> rr, cc = rectangle(start, extent=(2, 2)) >>> img[rr, cc] = 1 >>> rr, cc = rectangle(start, extent=(-2, 2)) >>> img[rr, cc] = 2 >>> rr, cc = rectangle(start, extent=(-2, -2)) >>> img[rr, cc] = 3 >>> rr, cc = rectangle(start, extent=(2, -2)) >>> img[rr, cc] = 4 >>> print(img) [[0 0 0 0 0 0] [0 3 3 2 2 0] [0 3 3 2 2 0] [0 4 4 1 1 0] [0 4 4 1 1 0] [0 0 0 0 0 0]]
rectangle_perimeter¶
-
skimage.draw.
rectangle_perimeter
(start, end=None, extent=None, shape=None, clip=False)[source]¶ Generate coordinates of pixels that are exactly around a rectangle.
- Parameters
start : tuple
Origin point of the inner rectangle, e.g.,
(row, column)
.end : tuple
End point of the inner rectangle
(row, column)
. For a 2D matrix, the slice defined by inner the rectangle is[start:(end+1)]
. Either end or extent must be specified.extent : tuple
The extent (size) of the inner rectangle. E.g.,
(num_rows, num_cols)
. Either end or extent must be specified. Negative extents are permitted. Seerectangle
to better understand how they behave.shape : tuple, optional
Image shape used to determine the maximum bounds of the output coordinates. This is useful for clipping perimeters that exceed the image size. By default, no clipping is done. Must be at least length 2. Only the first two values are used to determine the extent of the input image.
clip : bool, optional
Whether to clip the perimeter to the provided shape. If this is set to True, the drawn figure will always be a closed polygon with all edges visible.
- Returns
coords : array of int, shape (2, Npoints)
The coordinates of all pixels in the rectangle.
Examples
>>> import numpy as np >>> from skimage.draw import rectangle_perimeter >>> img = np.zeros((5, 6), dtype=np.uint8) >>> start = (2, 3) >>> end = (3, 4) >>> rr, cc = rectangle_perimeter(start, end=end, shape=img.shape) >>> img[rr, cc] = 1 >>> img array([[0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1], [0, 0, 1, 0, 0, 1], [0, 0, 1, 0, 0, 1], [0, 0, 1, 1, 1, 1]], dtype=uint8)
>>> img = np.zeros((5, 5), dtype=np.uint8) >>> r, c = rectangle_perimeter(start, (10, 10), shape=img.shape, clip=True) >>> img[r, c] = 1 >>> img array([[0, 0, 0, 0, 0], [0, 0, 1, 1, 1], [0, 0, 1, 0, 1], [0, 0, 1, 0, 1], [0, 0, 1, 1, 1]], dtype=uint8)
set_color¶
-
skimage.draw.
set_color
(image, coords, color, alpha=1)[source]¶ Set pixel color in the image at the given coordinates.
Note that this function modifies the color of the image in-place. Coordinates that exceed the shape of the image will be ignored.
- Parameters
image : (M, N, D) ndarray
Image
coords : tuple of ((P,) ndarray, (P,) ndarray)
Row and column coordinates of pixels to be colored.
color : (D,) ndarray
Color to be assigned to coordinates in the image.
alpha : scalar or (N,) ndarray
Alpha values used to blend color with image. 0 is transparent, 1 is opaque.
Examples
>>> from skimage.draw import line, set_color >>> img = np.zeros((10, 10), dtype=np.uint8) >>> rr, cc = line(1, 1, 20, 20) >>> set_color(img, (rr, cc), 1) >>> img array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]], dtype=uint8)