measure

模块：测量

approximate_polygon

skimage.measure.approximate_polygon(coords, tolerance)[资源]

近似具有指定公差的多边形链。

它基于Douglas-Peucker算法。

请注意，近似的多边形总是在原始多边形的凸包内。

参考

block_reduce

skimage.measure.block_reduce(image, block_size, func=<function sum>, cval=0)[资源]

通过对局部块应用函数来下采样图像。

例子

>>> from skimage.measure import block_reduce
>>> image = np.arange(3*3*4).reshape(3, 3, 4)
>>> image 
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],
       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]],
       [[24, 25, 26, 27],
        [28, 29, 30, 31],
        [32, 33, 34, 35]]])
>>> block_reduce(image, block_size=(3, 3, 1), func=np.mean)
array([[[ 16.,  17.,  18.,  19.]]])
>>> image_max1 = block_reduce(image, block_size=(1, 3, 4), func=np.max)
>>> image_max1 
array([[[11]],
       [[23]],
       [[35]]])
>>> image_max2 = block_reduce(image, block_size=(3, 1, 4), func=np.max)
>>> image_max2 
array([[[27],
        [31],
        [35]]])

compare_mse

skimage.measure.compare_mse(im1, im2)[资源]

计算两幅图像之间的均方差。

compare_nrmse

skimage.measure.compare_nrmse(im_true, im_test, norm_type='Euclidean')[资源]

计算两幅图像之间的归一化均方根误差（NRMSE）。

• '欧几里得'：按欧几里得规范归一化im_true。

• 'min-max'：按照强度范围进行归一化im_true。

• 'mean'：用.im_true的均值标准化

Returns:  **nrmse** : float

NRMSE度量。

参考

compare_psnr

skimage.measure.compare_psnr(im_true, im_test, data_range=None, dynamic_range=None)[资源]

计算图像的峰值信噪比（PSNR）。

参考

compare_ssim

skimage.measure.compare_ssim(X, Y, win_size=None, gradient=False, data_range=None, multichannel=False, gaussian_weights=False, full=False, dynamic_range=None, **kwargs)[资源]

计算两幅图像之间的平均结构相似性指数。

| 其他参数：|

| | use_sample_covariance：bool如果为真，用N-1归一化协方差而不是N，其中N是滑动窗口内的像素数。K1：浮点算法参数，K1（小常量，参见R332）K2：浮点算法参数，K2（小常量，参见R332）sigma：当gaussian_weights为真时为高斯浮点数。|

注意

为了配合Wang等的实施。[R332]，将gaussian_weights设置为True，将sigma设置为1.5，并将use_sample_covariance设置为False。

参考

correct_mesh_orientation

skimage.measure.correct_mesh_orientation(volume, verts, faces, spacing=(1.0, 1.0, 1.0), gradient_direction='descent')[资源]

网格面的正确方向。

扩展内容

skimage.measure.marching_cubes_classic, skimage.measure.mesh_surface_area

注意

某些应用程序和网格处理算法要求所有面都以一致的方式进行定向。通常，这意味着法线向量指出网格形状的“出”。该算法skimage.measure.marching_cubes_classic通过翻转面向错误的面的方向来校正输出。

由于步进立方体可以用于在梯度下降（其中所需物体具有比外部更大的值）或上升（其中期望物体具有比外部更低的值）处找到等值面，gradient_directionkwarg允许用户通知该算法，其中是正确的。如果生成的网格看上去完全不正确，请尝试更改此选项。

这个函数期望的参数是来自的确切输出skimage.measure.marching_cubes_classic。只有faces被修正并返回，因为顶点不会改变; 只有它们被引用的顺序。

该算法假定faces提供的都是三角形。

find_contours

skimage.measure.find_contours(array, level, fully_connected='low', positive_orientation='low')[资源]

对于给定的水平值，在二维数组中找到等值的轮廓。

使用“步进方块”方法计算输入2D阵列的等值轮廓以获得特定的水平值。数组值被线性插值以提供更好的输出轮廓精度。

注意

行军平方算法是行军立方体算法[R334]的特例。这里有一个简单的解释：

http://www.essi.fr/~lingrand/MarchingCubes/algo.html

行进平方算法中有一个模棱两可的情况：当给定的2×2元素正方形具有两个高值元素和两个低值元素时，每个元素对角相邻。 （其中高值和低值是相对于所寻求的等值线的值）。在这种情况下，高值元素可以通过分隔低值元素的薄地峡连接在一起，反之亦然。 当元素通过对角线连接在一起时，它们被认为是“完全连接”（也称为“面+顶点连接”或“8连接”）。 只有高价值或低价值的元素可以完全连接，另一套将被视为“面子连接”或“四连接”。 默认情况下，低值元素被视为完全连接; 这可以通过'fully_connected'参数改变。

输出轮廓不保证关闭：与阵列边缘相交的轮廓将保持打开状态。所有其他轮廓将被关闭。（可以通过检查起点与终点相同来测试轮廓的闭合度。）

轮廓面向。默认情况下，低于轮廓值的数组值位于轮廓的左侧，大于轮廓值的值位于右侧。这意味着轮廓将围绕低值像素逆时针旋转（即以“正方向”）。这种行为可以通过'positive_orientation'参数改变。

输出列表中轮廓的顺序由轮廓中最小x,y（按字典顺序）坐标确定。这是输入数组如何遍历的副作用，但可以依赖。

警告

假定数组的坐标/值是指数组元素的中心。举一个简单的例子输入：[0, 1]。在这个数组中0.5的插值位置是0元素（x=0）和1元素（ x=1）之间的中间值，因此将落在x=0.5。

这意味着要找到合理的轮廓，最好在预期的“光”和“黑”值之间找到轮廓线。特别是，给定一个二进制数组，不要选择在数组的低值或高值处查找等值线。这通常会产生退化的轮廓，特别是在单个数组元素宽的结构周围。而是选择一个中间值，如上所述。

参考

例子

>>> a = np.zeros((3, 3))
>>> a[0, 0] = 1
>>> a
array([[ 1.,  0.,  0.],
       [ 0.,  0.,  0.],
       [ 0.,  0.,  0.]])
>>> find_contours(a, 0.5)
[array([[ 0. ,  0.5],
       [ 0.5,  0. ]])]

grid_points_in_poly

skimage.measure.grid_points_in_poly(shape, verts)[资源]

测试指定网格上的点是否在多边形内。

对于网格上的每个（r，c）坐标，即（0,0），（0,1）等，测试该点是否位于多边形内。

扩展内容

points_in_poly

标签

skimage.measure.label(input, neighbors=None, background=None, return_num=False, connectivity=None)[资源]

标记整数数组的连接区域。

两个像素是相邻的，并且具有相同的值。在2D中，它们可以是1或2连接意义上的邻居。该值是指考虑像素/体素邻居的正交跳跃的最大数量：

1-connectivity      2-connectivity     diagonal connection close-up

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

扩展内容

regionprops

参考

例子

>>> import numpy as np
>>> x = np.eye(3).astype(int)
>>> print(x)
[[1 0 0]
 [0 1 0]
 [0 0 1]]
>>> 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]]

marching_cubes

skimage.measure.marching_cubes(volume, level=None, spacing=(1.0, 1.0, 1.0), gradient_direction='descent', step_size=1, allow_degenerate=True, use_classic=False)[资源]

Lewiner推进立方体算法来查找3D体积数据中的曲面。

相比marching_cubes_classic()之下，这种算法更快，解决了模糊问题，并保证拓扑结果正确。因此，除非经典算法有特定需求，否则此算法通常是更好的选择。

扩展内容

skimage.measure.marching_cubes_classic, skimage.measure.mesh_surface_area

注意

算法1是Chernyaev的Marching Cubes 33算法的改进版本。这是一种高效的算法，它依赖大量查找表来处理许多不同的情况，使算法相对简单。这个实现是用Cython编写的，从Lewiner的C ++实现中移植过来的。

为了量化该算法生成的等值面的面积，将vert和faces传递给skimage.measure.mesh_surface_area。

关于算法输出的可视化，要myvolume使用以下mayavi程序包勾画关于等级0.0 命名的卷：

>>> from mayavi import mlab 
>>> verts, faces, normals, values = marching_cubes(myvolume, 0.0) 
>>> mlab.triangular_mesh([vert[0] for vert in verts],
...                      [vert[1] for vert in verts],
...                      [vert[2] for vert in verts],
...                      faces) 
>>> mlab.show() 

同样使用visvis软件包：

>>> import visvis as vv 
>>> verts, faces, normals, values = marching_cubes_classic(myvolume, 0.0) 
>>> vv.mesh(np.fliplr(verts), faces, normals, values) 
>>> vv.use().Run() 

参考

marching_cubes_classic

skimage.measure.marching_cubes_classic(volume, level=None, spacing=(1.0, 1.0, 1.0), gradient_direction='descent')[资源]

经典的游动立方体算法，用于查找3D体积数据中的曲面。

请注意，该marching_cubes()算法推荐使用此算法，因为它速度更快，效果更好。

扩展内容

skimage.measure.marching_cubes, skimage.measure.mesh_surface_area

注意

行进立方体算法按照[R338]中的描述执行。这里有一个简单的解释：

http://www.essi.fr/~lingrand/MarchingCubes/algo.html

行军立方体算法中有几种已知的模糊情况。使用如[R338]，图4中的点标记，如图所示：

    v8 ------ v7
   / |       / |        y
  /  |      /  |        ^  z
v4 ------ v3   |        | /
 |  v5 ----|- v6        |/          (note: NOT right handed!)
 |  /      |  /          ----> x
 | /       | /
v1 ------ v2

最值得注意的是，如果v4，v8，v2和v6全都> = level（或者这种情况的任何泛化），则通过该算法生成两个平行平面，从v2和v6分离v4和v8。一个同样有效的解释是将所有四个点连接起来的单个连接的薄表面。这是最为人所知的歧义，尽管还有其他的。

该算法不会尝试解决这种模糊问题; 它是[R338]中的行军立方体的幼稚执行，但可能是使用更新技术（双行进立方体，延伸行进立方体，立方体行进方形等）开展工作的良好开端。

由于相邻立方体之间的相互作用，由该算法生成的等值面不能保证被关闭，特别是对于复杂的轮廓。此外，该算法不保证会返回单个轮廓。事实上，level无论连通性如何，都会找到交叉的所有等值面。

输出是一个由一组独特的顶点和连接三角形组成的三角形网格。输出列表中这些顶点和三角形的x,y,z顺序由轮廓中最小（按字典顺序）坐标确定。这是输入数组如何遍历的副作用，但可以依赖。

生成的网格从版本0.12开始保证一致的方向。

为了量化该算法产生的等值面的面积，将输出直接传递给skimage.measure.mesh_surface_area。

参考

marching_cubes_lewiner

skimage.measure.marching_cubes_lewiner(volume, level=None, spacing=(1.0, 1.0, 1.0), gradient_direction='descent', step_size=1, allow_degenerate=True, use_classic=False)[资源]

别名marching_cubes()。

mesh_surface_area

skimage.measure.mesh_surface_area(verts, faces)[资源]

计算表面积，给定顶点和三角形面

扩展内容

skimage.measure.marching_cubes, skimage.measure.marching_cubes_classic, skimage.measure.correct_mesh_orientation

注意

这个函数所期望的参数是skimage.measure.marching_cubes的前两个输出。 对于单位正确的输出，确保正确的间距已传递到skimage.measure.marching_cubes。

只有faces提供的都是三角形，该算法才能正常工作。

瞬间

skimage.measure.moments(image, order=3)[资源]

计算所有原始图像时刻达到一定的顺序。

可以从原始图像时刻计算以下属性：

• 面积为：m[0, 0]。

• 质心为：{ m[0, 1] / m[0, 0]，m[1, 0] / m[0, 0]}。

请注意，原始时刻既不是平移，也不是旋转不变。

参考

例子

>>> image = np.zeros((20, 20), dtype=np.double)
>>> image[13:17, 13:17] = 1
>>> m = moments(image)
>>> cr = m[0, 1] / m[0, 0]
>>> cc = m[1, 0] / m[0, 0]
>>> cr, cc
(14.5, 14.5)

moments_central

skimage.measure.moments_central(image, cr, cc, order=3)[资源]

计算所有的中心图像时刻达到一定的顺序。

中心坐标（cr，cc）可以从原始时刻计算为：{ m[0, 1] / m[0, 0]，m[1, 0] / m[0, 0]}。

请注意，中心矩是平移不变的，但不具有比例和旋转不变性。

参考

例子

>>> image = np.zeros((20, 20), dtype=np.double)
>>> image[13:17, 13:17] = 1
>>> m = moments(image)
>>> cr = m[0, 1] / m[0, 0]
>>> cc = m[1, 0] / m[0, 0]
>>> moments_central(image, cr, cc)
array([[ 16.,   0.,  20.,   0.],
       [  0.,   0.,   0.,   0.],
       [ 20.,   0.,  25.,   0.],
       [  0.,   0.,   0.,   0.]])

moments_hu

skimage.measure.moments_hu(nu)[资源]

计算胡的一组图像时刻。

请注意，这组时间可以证明是平移，缩放和旋转不变。

参考

moments_normalized

skimage.measure.moments_normalized(mu, order=3)[资源]

计算所有归一化的中心图像时刻，达到一定的顺序。

请注意，归一化的中心矩是平移和比例不变的，但不是旋转不变的。

参考

例子

>>> image = np.zeros((20, 20), dtype=np.double)
>>> image[13:17, 13:17] = 1
>>> m = moments(image)
>>> cr = m[0, 1] / m[0, 0]
>>> cc = m[1, 0] / m[0, 0]
>>> mu = moments_central(image, cr, cc)
>>> moments_normalized(mu)
array([[        nan,         nan,  0.078125  ,  0.        ],
       [        nan,  0.        ,  0.        ,  0.        ],
       [ 0.078125  ,  0.        ,  0.00610352,  0.        ],
       [ 0.        ,  0.        ,  0.        ,  0.        ]])

周长

skimage.measure.perimeter(image, neighbourhood=4)[资源]

计算二进制图像中所有对象的总周长。

参考

points_in_poly

skimage.measure.points_in_poly(points, verts)[资源]

测试点是否位于多边形内。

扩展内容

grid_points_in_poly

profile_line

skimage.measure.profile_line(img, src, dst, linewidth=1, order=1, mode='constant', cval=0.0)[资源]

返回沿扫描线测量的图像的强度分布。

例子

>>> x = np.array([[1, 1, 1, 2, 2, 2]])
>>> img = np.vstack([np.zeros_like(x), x, x, x, np.zeros_like(x)])
>>> img
array([[0, 0, 0, 0, 0, 0],
       [1, 1, 1, 2, 2, 2],
       [1, 1, 1, 2, 2, 2],
       [1, 1, 1, 2, 2, 2],
       [0, 0, 0, 0, 0, 0]])
>>> profile_line(img, (2, 1), (2, 4))
array([ 1.,  1.,  2.,  2.])
>>> profile_line(img, (1, 0), (1, 6), cval=4)
array([ 1.,  1.,  1.,  2.,  2.,  2.,  4.])

与标准numpy索引相比，目标点包含在配置文件中。例如：>>> profile_line（img，（1,0），（1，6））＃最后一个点超出数组（1.，1.，1.，2.，2.，2.， 0）>>> profile_line（img，（1,0），（1,5））＃这将访问完整的第一行数组（1.，1.，1.，2.，2.，2.）

ransac

skimage.measure.ransac(data, model_class, min_samples, residual_threshold, is_data_valid=None, is_model_valid=None, max_trials=100, stop_sample_num=inf, stop_residuals_sum=0, stop_probability=1, random_state=None)[资源]

使用RANSAC（随机样本一致性）算法将模型拟合到数据。

RANSAC是一个迭代算法，用于从完整数据集的内部子集中对参数进行鲁棒估计。每次迭代执行以下任务：

• min_samples从原始数据中选择随机样本并检查该组数据是否有效（请参阅is_data_valid）。

• 估计模型到随机子集（model_cls.estimate(*data[random_subset]）并检查估计模型是否有效（请参阅is_model_valid）。

• 通过计算估计模型的残差（model_cls.residuals(*data)），将所有数据分类为内部值或外部值- 所有残差小于该值的数据样本residual_threshold均视为内部值。

• 如果内部样本数量最大，则将估计模型保存为最佳模型。如果当前估计的模型具有相同数量的内点，则只有当它具有较少的残差总和时才被认为是最佳模型。

这些步骤要么执行最多次数，要么直到满足特殊停止条件之一。使用先前确定的最佳模型的所有inlier样本估计最终模型。

• success = estimate(*data)

• residuals(*data)

其中success表示模型估计是否成功（True或None成功，False失败）。

min_samples : int

适合模型的最小数据点数。

residual_threshold : float

一个数据点的最大距离被归类为一个inlier。

is_data_valid : function, optional

在模型适用之前，随机选择的数据调用该函数：is_data_valid(*random_data)。

is_model_valid : function, optional

使用估计模型和随机选择的数据调用该函数：is_model_valid(model, *random_data)，。

max_trials : int, optional

随机样本选择的最大迭代次数。

stop_sample_num : int, optional

如果至少找到这个数量的内点，停止迭代。

stop_residuals_sum : float, optional

如果残差总和小于或等于此阈值，则停止迭代。

stop_probability : float in range 0, 1, optional

如果至少有一个无异常值的训练数据集被采样probability >= stop_probability，RANSAC迭代将停止，取决于当前最佳模型的内点比率和试验次数。这需要至少生成N个样本（试验）：

N >= log(1 - probability) / log(1 - e**m)

其中概率（置信度）通常设置为诸如0.99的高值，并且e是当前的内部分数对于样本的总数。

random_state : int, RandomState instance or None, optional

如果是int，random_state是随机数发生器使用的种子; 如果RandomState实例，random_state是随机数生成器; 如果为None，则随机数生成器是np.random使用的RandomState实例。

Returns:  **model** : object

最大共识集合的最佳模式。

inliers : (N, ) array

内部分类为布尔值的掩码True。

参考

例子

无倾斜地生成椭圆数据并添加噪音：

>>> t = np.linspace(0, 2 * np.pi, 50)
>>> xc, yc = 20, 30
>>> a, b = 5, 10
>>> x = xc + a * np.cos(t)
>>> y = yc + b * np.sin(t)
>>> data = np.column_stack([x, y])
>>> np.random.seed(seed=1234)
>>> data += np.random.normal(size=data.shape)

添加一些错误数据：

>>> data[0] = (100, 100)
>>> data[1] = (110, 120)
>>> data[2] = (120, 130)
>>> data[3] = (140, 130)

使用所有可用数据估计椭圆模型：

>>> model = EllipseModel()
>>> model.estimate(data)
True
>>> np.round(model.params)  
array([ 72.,  75.,  77.,  14.,   1.])

使用RANSAC估计椭圆模型：

>>> ransac_model, inliers = ransac(data, EllipseModel, 20, 3, max_trials=50)
>>> abs(np.round(ransac_model.params))
array([ 20.,  30.,   5.,  10.,   0.])
>>> inliers 
array([False, False, False, False,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True], dtype=bool)
>>> sum(inliers) > 40
True

稳健估计几何变换：

>>> from skimage.transform import SimilarityTransform
>>> np.random.seed(0)
>>> src = 100 * np.random.rand(50, 2)
>>> model0 = SimilarityTransform(scale=0.5, rotation=1,
...                              translation=(10, 20))
>>> dst = model0(src)
>>> dst[0] = (10000, 10000)
>>> dst[1] = (-100, 100)
>>> dst[2] = (50, 50)
>>> model, inliers = ransac((src, dst), SimilarityTransform, 2, 10)
>>> inliers
array([False, False, False,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True,  True,  True,  True,  True,
        True,  True,  True,  True,  True], dtype=bool)

regionprops

skimage.measure.regionprops(label_image, intensity_image=None, cache=True)[资源]

测量标记的图像区域的属性。

扩展内容

label

注意

以下属性可以作为属性或键来访问：

area：region.bbox的像素数目：tupleBounding框（min_row，min_col，max_row，max_col）。属于边界框的像素处于半开区间[min_row; max_row）和[min_col; max_col）.bbox_area：边界的像素的数量box.centroid：arrayCentroid坐标元组（行，列）.convex_area：int的凸包像素的数目image.convex_image：（H，J）ndarrayBinary凸包图像，其大小与bounding box.coords：区域的（N，2）ndarray坐标列表（行，列）.eccentricity：与区域具有相同二次矩的椭圆的椭圆度。偏心率是焦距（焦点之间的距离）在长轴长度上的比率。该值位于区间[0，1）中。当它为0时，椭圆变为一个圆。equivalent_diameter：float与区域面积相同的圆的直径。euler_number：区域的intEuler特性。计算为对象数（= 1）减去孔的数量（8连通性）.extent：区域中像素的floatRatio与总边界框中的像素的比率。计算为area /（rows * cols）filled_area：int填充区域的像素数目。填充图像：（H，J）具有与边界框大小相同的填充空洞的ndarrayBinary区域图像。图像：（H，J）ndarray切片二进制区域与边界框尺寸相同的图像.inertia_tensor：（2，2）ndarrayInertia张量，用于围绕其mass.inertia_tensor_eigvals旋转的区域张量：tuple惯性张量的两个本征值，以递减顺序排列.intensity_image：ndarrayImage在区域边界框内.label：int标注的输入图像中的标签image.local_centroid：arrayCentroid坐标元组（行，列），相对于区域边界box.major_axis_length：float椭圆长轴的长度，与区域具有相同的归一化第二中心矩.max_intensity：floatValue，该区域中的最大强度.mean_intensity：floatValue，该区域的平均强度为.min_intensity：floatValue，该区域中的最小强度为.m inor_axis_length：float具有与region相同的归一化第二中心矩的椭圆短轴的长度.moments：（3，3）ndarray

空间时刻达3阶：

m_ji = sum{ array(x, y) * x^j * y^i }

其中总和超过x，y协调区域。

moments_central : (3, 3) ndarray

中央时刻（平移不变）达3阶：

mu_ji = sum{ array(x, y) * (x - x_c)^j * (y - y_c)^i }

其中总和超过x，y协调区域，并且x_c和y_c是该地区的质心的坐标。

moments_hu : tuple Hu时刻（平移，缩放和旋转不变）。moments_normalized : (3, 3) ndarray

归一化矩（平移和尺度不变）高达3阶：

nu_ji = mu_ji / m_00^[(i+j)/2 + 1]

m_00第零空间时刻所在的位置

orientation：floatAngle在X轴和具有与该区域相同的二阶矩的椭圆长轴之间。 从pi / 2逆时针方向到pi / 2 .perimeter：float对象的周长，通过使用4-connectivity.solidity：floatRatio将该区域中的像素近似为通过边界像素中心的线条 （3，3）image.weighted_centroid：arrayCentroid坐标元组（行，列）用强度加权image.weighted_local_centroid：arrayCentroid坐标元组（行，列），相对于区域边界框，用强度加权image.weighted_moments：（3,3）ndarray

强度图像的空间力矩高达3阶：

wm_ji = sum{ array(x, y) * x^j * y^i }

其中总和超过x，y协调区域。

weighted_moments_central : (3, 3) ndarray

强度图像的中心矩（平移不变量）达到3阶：

wmu_ji = sum{ array(x, y) * (x - x_c)^j * (y - y_c)^i }

其中总和超过x，y协调区域，并且x_c和y_c是该地区的加权质心坐标。

weighted_moments_hu : tupleHu时刻（平移，缩放和旋转不变）强度图像。weighted_moments_normalized : (3, 3) ndarray

强度图像的归一化矩（平移和尺度不变）高达3阶：

wnu_ji = wmu_ji / wm_00^[(i+j)/2 + 1]

wm_00零度空间时刻（强度加权区域）所在的位置

每个区域也支持迭代，所以你可以这样做：

for prop in region:
    print(prop, region[prop])

参考

例子

>>> from skimage import data, util
>>> from skimage.measure import label
>>> img = util.img_as_ubyte(data.coins()) > 110
>>> label_img = label(img, connectivity=img.ndim)
>>> props = regionprops(label_img)
>>> # centroid of first labeled object
>>> props[0].centroid
(22.729879860483141, 81.912285234465827)
>>> # centroid of first labeled object
>>> props[0]['centroid']
(22.729879860483141, 81.912285234465827)

shannon_entropy

skimage.measure.shannon_entropy(image, base=2)[资源]

计算图像的香农熵。

香农熵定义为S = -sum（pk * log（pk）），其中pk是值为k的像素的数量。

注意

返回的值以位或shannon（Sh）为基数= 2，自然单位（nat）为基数= np.e，hartley（Hart）为基数= 10测量。

参考

例子

>>> from skimage import data
>>> shannon_entropy(data.camera())
17.732031303342747

structural_similarity

skimage.measure.structural_similarity(X, Y, win_size=None, gradient=False, dynamic_range=None, multichannel=False, gaussian_weights=False, full=False, **kwargs)[资源]

弃用功能。compare_ssim改为使用。

subdivide_polygon

skimage.measure.subdivide_polygon(coords, degree=2, preserve_ends=False)[资源]

使用B样条对多边形曲线进行细分。

请注意，生成的曲线始终位于原始多边形的凸包内。细分后，圆形多边形保持关闭状态。

参考

CircleModel

class skimage.measure.CircleModel[资源]

基地： skimage.measure.fit.BaseModel

2D圆圈的总体最小二乘估计量。

圈子的功能模型是：

r**2 = (x - xc)**2 + (y - yc)**2

这个估计量最小化所有点到圆的平方距离：

min{ sum((r - sqrt((x_i - xc)**2 + (y_i - yc)**2))**2) }

最少需要3个点才能解决参数问题。

属性

__init__()[source]estimate(data)[source]

使用总体最小二乘法从数据中估计圆圈模型。

predict_xy(t, params=None)[资源]

使用估计的模型预测x和y坐标。

residuals(data)[资源]

确定要建模的数据的残差。

对于每个点，返回到圆的最短距离。

EllipseModel

class skimage.measure.EllipseModel[资源]

基地： skimage.measure.fit.BaseModel

2D椭圆的总体最小二乘估计量。

椭圆的功能模型是：

xt = xc + a*cos(theta)*cos(t) - b*sin(theta)*sin(t)
yt = yc + a*sin(theta)*cos(t) + b*cos(theta)*sin(t)
d = sqrt((x - xt)**2 + (y - yt)**2)

其中(xt, yt)是椭圆上最近的点(x, y)。因此d是从点到椭圆的最短距离。

估计器基于最小二乘法最小化。最佳解决方案是直接计算的，不需要迭代。这导致了一种简单，稳定和可靠的拟合方法。

该params属性按以下顺序包含参数：

xc, yc, a, b, theta

例子

>>> xy = EllipseModel().predict_xy(np.linspace(0, 2 * np.pi, 25),
...                                params=(10, 15, 4, 8, np.deg2rad(30)))
>>> ellipse = EllipseModel()
>>> ellipse.estimate(xy)
True
>>> np.round(ellipse.params, 2)
array([ 10.  ,  15.  ,   4.  ,   8.  ,   0.52])
>>> np.round(abs(ellipse.residuals(xy)), 5)
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.])

属性

__init__()[来源] estimate(data)[来源]

使用总体最小二乘法从数据中估计圆圈模型。

参考

predict_xy(t, params=None)[资源]

使用估计的模型预测x和y坐标。

residuals(data)[资源]

确定要建模的数据的残差。

对于每个点，返回到椭圆的最短距离。

LineModel

class skimage.measure.LineModel[资源]

基地： skimage.measure.fit.BaseModel

2D线的总最小二乘估计量。

使用极坐标将线条参数化为功能模型：

dist = x * cos(theta) + y * sin(theta)

与标准线型相比，此参数化可以模拟垂直线y = a*x + b。

这个估计量最小化所有点到线的平方距离：

min{ sum((dist - x_i * cos(theta) + y_i * sin(theta))**2) }

需要最少数量的2个点来解决参数。

已弃用的课程。LineModelND改为使用。

属性

__init__()[来源] estimate(data)[来源]

使用总体最小二乘法从数据中估计线模型。

predict_x(y, params=None)[资源]

使用估计的模型预测x坐标。

predict_y(x, params=None)[资源]

使用估计的模型预测y坐标。

residuals(data)[资源]

确定要建模的数据的残差。

对于每个点，返回到该线的最短距离。

LineModelND

class skimage.measure.LineModelND[资源]

基地： skimage.measure.fit.BaseModel

N维线的总体最小二乘估计量。

线根据以下矢量方程由点（原点）和单位矢量（方向）定义：

X = origin + lambda * direction

属性

__init__()[来源] estimate(data)[来源]

根据数据估计线模型。

predict(x, axis=0, params=None)[资源]

预测估计的线模型与正交于给定轴的超平面的交点。

predict_x(y, params=None)[资源]

使用估计的模型预测2D线的x坐标。

别名为：

predict(y, axis=1)[:, 0]

predict_y(x, params=None)[资源]

使用估计的模型预测二维线的y坐标。

别名为：

predict(x, axis=0)[:, 1]

residuals(data)[资源]

确定要建模的数据的残差。

对于每个点，返回到该线的最短距离。它是通过将数据投影到线上而获得的。