draw

Module: draw

skimage.draw.bezier_curve（r0，c0，r1，c1，...）	生成贝塞尔曲线坐标。
skimage.draw.disk（r，c，半径，形状）	生成圆内像素的坐标。
skimage.draw.circle_perimeter（r，c，radius）	生成圆周边坐标。
skimage.draw.circle_perimeter_aa（r，c，radius）	生成反锯齿圆周边坐标。
skimage.draw.ellipse（r，c，r_radius，c_radius）	生成椭圆内像素的坐标。
skimage.draw.ellipse_perimeter（r，c，...，...）	生成椭圆周长坐标。
skimage.draw.ellipsoid（a，b，c，间距，...）	生成具有半长轴的椭球体，其与具有指定间距的网格上的网格维度对齐。
skimage.draw.ellipsoid_stats（a，b，c）	计算半长轴与指定间距的网格尺寸对齐的椭球体的分析表面积和体积。
skimage.draw.line（r0，c0，r1，c1）	生成线像素坐标。
skimage.draw.line_aa（r0，c0，r1，c1）	生成抗锯齿线像素坐标。
skimage.draw.polygon（r，c，shape）	生成多边形内像素的坐标。
skimage.draw.polygon_perimeter（r，c，...）	生成多边形周边坐标。
skimage.draw.set_color（img，coords，color，...）	在给定坐标处设置图像中的像素颜色。
skimage.draw.draw
skimage.draw.draw3d

bezier_curve

skimage.draw.bezier_curve(r0, c0, r1, c1, r2, c2, weight, shape=None)[source]

生成贝塞尔曲线坐标。

参数：	r0，c0：int第一个控制点的坐标。r1，c1：int中间控制点的坐标。r2，c2：int最后一个控制点的坐标。重量：双中控点重量，它描述了线张力。形状：元组，可选图像形状，用于确定输出像素坐标的最大范围。这对于超过图像大小的曲线非常有用。如果没有，则使用曲线的整个范围。
返回：	rr，cc：（N，）ndarray of int属于Bezier曲线的像素索引。可用于直接索引到数组中，例如imgrr，cc = 1。

注意

该算法是参考文献[R99]中提出的有理二次算法。

参考

R99	（1,2）绘制曲线的光栅化算法，A.Zingl，2012 http://members.chello.at/easyfilter/Bresenham.pdf

示例

>>> 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.disk(r, c, radius, shape=None)[source]

生成圆内像素的坐标。

参数：	r，c：双圆的中心坐标。半径：双圆的半径。形状：元组，可选图像形状，用于确定输出像素坐标的最大范围。这对于超出图像大小的圆圈很有用。如果没有，则使用该圆的全部范围。
返回：	rr，cc：int的ndarray圆形的像素坐标。可用于直接索引到数组中，例如imgrr，cc = 1。

示例

>>> from skimage.draw import circle
>>> img = np.zeros((10, 10), dtype=np.uint8)
>>> rr, cc = circle(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)

circle_perimeter

skimage.draw.circle_perimeter(r, c, radius, method='bresenham', shape=None)[source]

生成圆周边坐标。

参数：	r，c：int圆的中心坐标。radius：int圆的半径。方法：{'bresenham'，'andres'}，可选bresenham：Bresenham方法（默认）andres：Andres方法形状：元组，可选图像形状，用于确定输出像素坐标的最大范围。这对于超出图像大小的圆圈很有用。如果没有，则使用该圆的全部范围。
返回：	rr，cc：int Bresenham和Andres方法的（N，）ndarray：属于圆周的像素的索引。可用于直接索引到数组中，例如imgrr，cc = 1。

注意

Andres方法呈现出同心圆形成圆盘的优点，而Bresenham可以制造圆孔。当Andres圈子旋转时，扭曲也较少。Bresenham方法也被称为中点圆算法。防锯齿圆形发生器可用circle_perimeter_aa。

参考

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.

示例

>>> 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]

生成反锯齿圆周边坐标。

参数：	r，c：int圆的中心坐标。radius：int圆的半径。形状：元组，可选图像形状，用于确定输出像素坐标的最大范围。这对于超出图像大小的圆圈很有用。如果没有，则使用该圆的全部范围。
返回：	rr，cc，val：（N，）ndarray（int，int，float）像素的索引（rr，cc）和强度值（val）。imgrr，cc = val。

注意

吴的方法画出反锯齿圆。该实现不使用查找表优化。

参考

R102	X. Wu, “An efficient antialiasing technique”, In ACM SIGGRAPH Computer Graphics, 25 (1991) 143-152.

示例

>>> 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)

ellipse

skimage.draw.ellipse(r, c, r_radius, c_radius, shape=None, rotation=0.0)[source]

生成椭圆内像素的坐标。

参数：	r，c：椭圆的双中心坐标。r_radius，c_radius：双小短轴和主半轴。（r / r_radius） 2 +（c / c_radius） 2 = 1.形状：元组，可选图像形状，用于确定输出像素坐标的最大范围。这对于超过图像大小的椭圆很有用。默认情况下使用椭圆的全部范围。旋转：浮动，可选（默认为0.）将椭圆旋转（旋转）设置在范围（-PI，PI）中的逆时针方向，因此PI / 2度表示交换椭圆轴
返回：	rr，cc：ndarray of int椭圆的像素坐标。可用于直接索引到数组中，例如imgrr，cc = 1。

注意

椭圆方程：

((x * cos(alpha) + y * sin(alpha)) / x_radius) ** 2 +
((x * sin(alpha) - y * cos(alpha)) / y_radius) ** 2 = 1

请注意，ellipse未指定的位置shape也可以具有负值，因为这在飞机上是正确的。另一方面，以后使用这些椭圆位置来表示图像的另一侧可能会导致出现在图像的另一侧，因为image[-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)

示例

>>> 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)

ellipse_perimeter

skimage.draw.ellipse_perimeter(r, c, r_radius, c_radius, orientation=0, shape=None)[source]

生成椭圆周长坐标。

参数：	r，c：int椭圆的中心坐标。r_radius，c_radius：int次要和主要半轴。（r / r_radius） 2 +（c / c_radius） 2 = 1.方向：double，可选主轴方向为顺时针方向，弧度。形状：元组，可选图像形状，用于确定输出像素坐标的最大范围。这对于超过图像大小的椭圆很有用。如果没有，则使用椭圆的全部范围。
返回：	rr，cc：（N，）ndarray of int属于椭圆周边的像素索引。可用于直接索引到数组中，例如imgrr，cc = 1。

参考

R103	A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012 http://members.chello.at/easyfilter/Bresenham.pdf

例子

>>> 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)

>>> 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]

生成具有半长轴的椭球体，与具有指定网格的网格维度对齐spacing。

参数：	a：float半长轴与x轴对齐的长度。b：float半长轴与y轴对齐的长度。c：float半长轴与z轴对齐的长度。间距：浮点数元组，长度为3（x，y，z）空间维度的间距。levelset：bool如果为True，则返回为此椭圆体设置的级别（有符号级别设置为零，表示内部为正数）为np.float64。False返回所述级别集合的二进制版本。
返回：	椭圆：（N，M，P）数组椭圆体以给定间距居中放置在正确大小的数组中。布尔dtype除非levelset = True，在这种情况下返回的浮点数组的级别设置为0.0以上代表椭圆体。

ellipsoid_stats

skimage.draw.ellipsoid_stats(a, b, c)[source]

计算半长轴与指定网格尺寸对齐的椭球体的分析表面积和体积spacing。

参数：	a：float半长轴与x轴对齐的长度。b：float半长轴与y轴对齐的长度。c：float半长轴与z轴对齐的长度。
返回：	vol：float椭球体的计算体积。surf：float椭球体的计算表面积。

line

skimage.draw.line(r0, c0, r1, c1)[source]

生成线像素坐标。

参数：	r0，c0：int起始位置（行，列）。r1，c1：int结束位置（行，列）。
返回：	rr，cc：（N，）ndarray属于该行的像素的索引。可用于直接索引到数组中，例如imgrr，cc = 1。

注意

消除锯齿线发生器可用line_aa。

例子

>>> 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]

生成抗锯齿线像素坐标。

参数：	r0，c0：int起始位置（行，列）。r1，c1：int结束位置（行，列）。
返回：	rr，cc，val：（N，）ndarray（int，int，float）像素的索引（rr，cc）和强度值（val）。imgrr，cc = val。

参考

R104	A Rasterizing Algorithm for Drawing Curves, A. Zingl, 2012 http://members.chello.at/easyfilter/Bresenham.pdf

例子

>>> 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)

polygon

skimage.draw.polygon(r, c, shape=None)[source]

生成多边形内像素的坐标。

参数：	r：（N，）ndarray多边形顶点的行坐标。c：（N，）ndarray多边形顶点的列坐标。形状：元组，可选图像形状，用于确定输出像素坐标的最大范围。这对于超过图像大小的多边形非常有用。如果没有，则使用多边形的全部范围。
返回：	rr，cc：ndarray of int多边形的像素坐标。可用于直接索引到数组中，例如imgrr，cc = 1。

示例

>>> from skimage.draw import polygon
>>> img = np.zeros((10, 10), dtype=np.uint8)
>>> r = np.array([1, 2, 8, 1])
>>> c = np.array([1, 7, 4, 1])
>>> 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)

polygon_perimeter

skimage.draw.polygon_perimeter(r, c, shape=None, clip=False)[source]

生成多边形周边坐标。

参数：	r：（N，）ndarray多边形顶点的行坐标。c：（N，）ndarray多边形顶点的列坐标。形状：元组，可选图像形状，用于确定输出像素坐标的最大范围。这对于超过图像大小的多边形非常有用。如果没有，则使用多边形的全部范围。clip：bool，可选是否将多边形裁剪为提供的形状。如果这设置为True，则绘制的图形将始终是一个封闭的多边形，并且所有边都可见。
返回：	rr，cc：ndarray of int多边形的像素坐标。可用于直接索引到数组中，例如imgrr，cc = 1。

例子

>>> 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)

set_color

skimage.draw.set_color(img, coords, color, alpha=1)[source]

在给定坐标处设置图像中的像素颜色。

超过图像形状的坐标将被忽略。

参数：	img：（M，N，D）ndarray图像坐标：（（P，）ndarray，（P，）ndarray）的元组要被着色的像素的行和列坐标。颜色：（D，）ndarray颜色被分配给图像中的坐标。alpha：标量或（N，）ndarray Alpha值，用于将颜色与图像混合。0是透明的，1是不透明的。
返回：	img：（M，N，D）ndarray更新的图像。

例子

>>> 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)