`skimage.graph`#

此模块提供基于图的图像处理实用程序。

这包括创建图像中像素的邻接图，查找图像中的中心像素，查找跨像素的（最小成本）路径，合并和切割图形等。

`skimage.graph.central_pixel`	查找具有最高接近中心性的像素。
`skimage.graph.cut_normalized`	在区域邻接图上执行归一化图切割。
`skimage.graph.cut_threshold`	合并权重小于阈值的区域。
`skimage.graph.merge_hierarchical`	执行RAG的分层合并。
`skimage.graph.pixel_graph`	创建图像中像素的邻接图。
`skimage.graph.rag_boundary`	基于区域边界计算RAG
`skimage.graph.rag_mean_color`	使用平均颜色计算区域邻接图。
`skimage.graph.route_through_array`	如何使用MCP和MCP_Geometric类的简单示例。
`skimage.graph.shortest_path`	查找从一侧到另一侧穿过n维数组的最短路径。
`skimage.graph.show_rag`	在图像上显示区域邻接图。
`skimage.graph.MCP`	一个用于查找给定n维成本数组中最短路径的类。
`skimage.graph.MCP_Connect`	使用距离加权最小成本函数连接源点。
`skimage.graph.MCP_Flexible`	查找穿过N维成本数组的最小成本路径。
`skimage.graph.MCP_Geometric`	查找穿过n维成本数组的距离加权最小成本路径。
`skimage.graph.RAG`	图像的区域邻接图（RAG），是`networkx.Graph`的子类。

skimage.graph.central_pixel(graph, nodes=None, shape=None, partition_size=100)[source]#

查找具有最高接近中心性的像素。

接近中心性是节点到所有其他节点的最短距离总和的倒数。

参数：

graphscipy.sparse.csr_matrix: 图的稀疏矩阵表示。
nodesint数组: 图中每个节点在图像中的展平索引。如果未提供，则返回值将是输入图中的索引。
shapeint元组: 节点嵌入其中的图像的形状。如果提供，则返回的坐标是与输入形状相同维度的NumPy多索引。否则，返回的坐标是在nodes中提供的展平索引。
partition_sizeint: 此函数计算图中每对节点之间的最短路径距离。这可能导致非常大的（N*N）矩阵。作为一个简单的性能调整，距离值以partition_size的数量计算，从而导致内存需求仅为partition_size*N。

返回值：

positionint或int元组: 如果给定shape，则图像中中心像素的坐标。否则，该像素的展平索引。
distancesfloat数组: 从每个节点到每个其他可达节点的距离总和。

使用像素图查找对象的测地线中心

skimage.graph.cut_normalized(labels, rag, thresh=0.001, num_cuts=10, in_place=True, max_edge=1.0, *, rng=None)[source]#

在区域邻接图上执行归一化图切割。

给定图像的标签及其相似性RAG，对其递归执行2路归一化切割。属于无法进一步切割的子图的所有节点在输出中被分配一个唯一的标签。

参数：

labelsndarray

标签数组。

ragRAG

区域邻接图。

threshfloat

阈值。如果N-cut的值超过thresh，则子图不会被进一步细分。

num_cutsint

在确定最佳N-cut之前要执行的N-cut次数。

in_placebool

如果设置，则就地修改rag。对于每个节点n，函数将设置一个新的属性rag.nodes[n]['ncut label']。

max_edgefloat，可选

RAG中边的最大可能值。这对应于相同区域之间的边。这用于在RAG中放置自环边。

rng{numpy.random.Generator, int}, 可选

伪随机数生成器。默认情况下，使用PCG64生成器（参见numpy.random.default_rng()）。如果rng是int，则将其用于播种生成器。

rng用于确定scipy.sparse.linalg.eigsh的起始点。

返回值：

outndarray: 新的标记数组。

参考文献

[1]

Shi, J.; Malik, J., “归一化切割和图像分割”，模式分析与机器智能，IEEE Transactions on，卷。22，第8期，第888-905页，2000年8月。

示例

>>> from skimage import data, segmentation, graph
>>> img = data.astronaut()
>>> labels = segmentation.slic(img)
>>> rag = graph.rag_mean_color(img, labels, mode='similarity')
>>> new_labels = graph.cut_normalized(labels, rag)

归一化切割

skimage.graph.cut_threshold(labels, rag, thresh, in_place=True)[source]#

合并权重小于阈值的区域。

给定图像的标签及其RAG，通过合并节点之间权重小于给定阈值的区域来输出新的标签。

参数：

labelsndarray: 标签数组。
ragRAG: 区域邻接图。
threshfloat: 阈值。由权重较小的边连接的区域将被合并。
in_placebool: 如果设置，则就地修改rag。该函数将删除权重小于thresh的边。如果设置为False，则该函数在继续之前会复制rag。

返回值：

outndarray: 新的标记数组。

参考文献

[1]

Alain Tremeau 和 Philippe Colantoni“应用于彩色图像分割的区域邻接图”DOI:10.1109/83.841950

示例

>>> from skimage import data, segmentation, graph
>>> img = data.astronaut()
>>> labels = segmentation.slic(img)
>>> rag = graph.rag_mean_color(img, labels)
>>> new_labels = graph.cut_threshold(labels, rag, 10)

区域邻接图（RAG）阈值化

skimage.graph.merge_hierarchical(labels, rag, thresh, rag_copy, in_place_merge, merge_func, weight_func)[source]#

执行RAG的分层合并。

贪婪地合并最相似的节点对，直到没有低于thresh的边为止。

参数：

labelsndarray: 标签数组。
ragRAG: 区域邻接图。
threshfloat: 由权重小于thresh的边连接的区域将被合并。
rag_copybool: 如果设置，则在修改前复制RAG。
in_place_mergebool: 如果设置，则节点将就地合并。否则，将为每次合并创建一个新节点。
merge_funccallable: 此函数在合并两个节点之前被调用。对于RAG graph，在合并src和dst时，它将按如下方式调用merge_func(graph, src, dst)。
weight_funccallable: 计算与合并节点相邻的节点的新权重的函数。这将直接作为参数weight_func提供给merge_nodes。

返回值：

outndarray: 新的标记数组。

区域邻接图（RAG）合并

区域边界RAG的分层合并

skimage.graph.pixel_graph(image, *, mask=None, edge_function=None, connectivity=1, spacing=None)[source]#

创建图像中像素的邻接图。

在mask为True的像素点是返回图中的节点，并且根据connectivity参数连接到它们的邻居。默认情况下，当给出mask时，或者当图像本身是mask时，边的*值*是像素之间的欧氏距离。

但是，如果给定一个int或float类型的图像，且没有mask，则边的值是相邻像素之间强度值的绝对差，并根据欧氏距离加权。

参数：

image数组: 输入图像。如果图像类型为bool，则也将用作mask。
maskbool型数组: 使用哪些像素。如果为None，则使用整个图像的图形。
edge_function可调用对象: 一个函数，它接受一个像素值数组、一个邻居像素值数组和一个距离数组，并返回边的值。如果没有给出函数，则边的值只是距离。
connectivityint: 像素邻域的正方形连通性：允许考虑像素为邻居的正交步数。有关详细信息，请参阅scipy.ndimage.generate_binary_structure。
spacing浮点数元组: 每个轴上像素之间的间距。

返回值：

graphscipy.sparse.csr_matrix: 一个稀疏邻接矩阵，其中条目(i, j)如果节点i和j是邻居则为1，否则为0。
nodesint数组: 图的节点。这些对应于mask中非零像素的展平索引。

使用像素图查找对象的测地线中心

skimage.graph.rag_boundary(labels, edge_map, connectivity=2)[source]#

基于区域边界计算RAG

给定图像的初始分割及其边缘图，此方法构建相应的区域邻接图(RAG)。RAG中的每个节点代表图像中一组具有labels中相同标签的像素。两个相邻区域之间的权重是它们边界上edge_map中的平均值。

labelsndarray: 带标签的图像。
edge_mapndarray: 这应该与labels的形状相同。对于两个相邻区域边界上的所有像素，edge_map中相应像素的平均值是它们之间的边权重。
connectivityint，可选: 彼此之间的平方距离小于connectivity的像素被认为是相邻的。它可以从1到labels.ndim。其行为与scipy.ndimage.generate_binary_structure中的connectivity参数相同。

示例

>>> from skimage import data, segmentation, filters, color, graph
>>> img = data.chelsea()
>>> labels = segmentation.slic(img)
>>> edge_map = filters.sobel(color.rgb2gray(img))
>>> rag = graph.rag_boundary(labels, edge_map)

基于区域边界的区域邻接图(RAG)

区域边界RAG的分层合并

skimage.graph.rag_mean_color(image, labels, connectivity=2, mode='distance', sigma=255.0)[source]#

使用平均颜色计算区域邻接图。

给定一个图像及其初始分割，此方法构建相应的区域邻接图(RAG)。RAG中的每个节点代表image中一组具有labels中相同标签的像素。两个相邻区域之间的权重表示根据mode参数，两个区域的相似度或差异程度。

参数：

imagendarray，形状(M, N[, …, P], 3): 输入图像。
labelsndarray，形状(M, N[, …, P]): 带标签的图像。这应该比image少一个维度。如果image的维度为(M, N, 3)，则labels的维度应为(M, N)。
connectivityint，可选: 彼此之间的平方距离小于connectivity的像素被认为是相邻的。它可以从1到labels.ndim。其行为与scipy.ndimage.generate_binary_structure中的connectivity参数相同。
mode{'distance'，'similarity'}，可选: 分配边权重的策略。

‘distance’：两个相邻区域之间的权重是\(|c_1 - c_2|\)，其中\(c_1\)和\(c_2\)是两个区域的平均颜色。它表示它们平均颜色之间的欧氏距离。

‘similarity’：两个相邻区域之间的权重是\(e^{-d^2/sigma}\)，其中\(d=|c_1 - c_2|\)，其中\(c_1\)和\(c_2\)是两个区域的平均颜色。它表示两个区域的相似程度。
sigmafloat，可选: 当mode为“similarity”时使用。它控制两个颜色应该有多接近，才能使其对应的边权重具有显著性。一个非常大的sigma值可能使任何两个颜色表现得好像它们是相似的。

返回值：

outRAG: 区域邻接图。

参考文献

[1]

Alain Tremeau 和 Philippe Colantoni“应用于彩色图像分割的区域邻接图”DOI:10.1109/83.841950

示例

>>> from skimage import data, segmentation, graph
>>> img = data.astronaut()
>>> labels = segmentation.slic(img)
>>> rag = graph.rag_mean_color(img, labels)

skimage.graph.route_through_array(array, start, end, fully_connected=True, geometric=True)[source]#

如何使用MCP和MCP_Geometric类的简单示例。

请参阅MCP和MCP_Geometric类的文档以了解路径查找算法的解释。

参数：

arrayndarray: 成本数组。
start可迭代对象: 到array的n维索引，定义起点
end可迭代对象: 到array的n维索引，定义终点
fully_connectedbool（可选）: 如果为True，则允许对角移动，如果为False，则仅允许轴向移动。
geometricbool（可选）: 如果为True，则使用MCP_Geometric类计算成本，如果为False，则使用MCP基类。请参阅类文档以了解MCP和MCP_Geometric之间差异的解释。

返回值：

path列表: 定义从start到end路径的n维索引元组列表。
costfloat: 路径的成本。如果geometric为False，则路径的成本是路径上array的值之和。如果geometric为True，则会进行更精细的计算（请参阅MCP_Geometric类的文档）。

另请参阅

MCP，MCP_Geometric

示例

>>> import numpy as np
>>> from skimage.graph import route_through_array
>>>
>>> image = np.array([[1, 3], [10, 12]])
>>> image
array([[ 1,  3],
       [10, 12]])
>>> # Forbid diagonal steps
>>> route_through_array(image, [0, 0], [1, 1], fully_connected=False)
([(0, 0), (0, 1), (1, 1)], 9.5)
>>> # Now allow diagonal steps: the path goes directly from start to end
>>> route_through_array(image, [0, 0], [1, 1])
([(0, 0), (1, 1)], 9.19238815542512)
>>> # Cost is the sum of array values along the path (16 = 1 + 3 + 12)
>>> route_through_array(image, [0, 0], [1, 1], fully_connected=False,
... geometric=False)
([(0, 0), (0, 1), (1, 1)], 16.0)
>>> # Larger array where we display the path that is selected
>>> image = np.arange((36)).reshape((6, 6))
>>> 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]])
>>> # Find the path with lowest cost
>>> indices, weight = route_through_array(image, (0, 0), (5, 5))
>>> indices = np.stack(indices, axis=-1)
>>> path = np.zeros_like(image)
>>> path[indices[0], indices[1]] = 1
>>> path
array([[1, 1, 1, 1, 1, 0],
       [0, 0, 0, 0, 0, 1],
       [0, 0, 0, 0, 0, 1],
       [0, 0, 0, 0, 0, 1],
       [0, 0, 0, 0, 0, 1],
       [0, 0, 0, 0, 0, 1]])

skimage.graph.shortest_path(arr, reach=1, axis=-1, output_indexlist=False)[source]#

查找从一侧到另一侧穿过n维数组的最短路径。

参数：

arrfloat64型ndarray
reachint，可选: 默认情况下（reach = 1），最短路径每向前移动一步，只能向上或向下移动一行（即，路径梯度限制为1）。reach定义了在每一步中可以跳过的每个非轴维度上的元素数量。
axisint，可选: 路径必须始终向前移动的轴（默认为-1）
output_indexlistbool，可选: 请参阅返回值p以了解说明。

返回值：

pint的可迭代对象: 沿axis轴的每一步，最短路径的坐标。如果output_indexlist为True，则路径将作为n维元组列表返回，这些元组索引到arr中。如果为False，则路径将作为数组返回，该数组列出沿非轴维度的路径坐标，用于沿轴维度的每一步。也就是说，p.shape == (arr.shape[axis], arr.ndim-1)，但在返回之前会压缩p，因此如果arr.ndim == 2，则p.shape == (arr.shape[axis],)。
costfloat: 路径的成本。这是路径上所有差异的绝对总和。

skimage.graph.show_rag(labels, rag, image, border_color='black', edge_width=1.5, edge_cmap='magma', img_cmap='bone', in_place=True, ax=None)[source]#

在图像上显示区域邻接图。

给定一个标记图像及其对应的RAG，使用指定的颜色在图像上显示RAG的节点和边。边在图像中两个相邻区域的质心之间显示。

参数：

labelsndarray，形状 (M, N): 带标签的图像。
ragRAG: 区域邻接图。
imagendarray，形状 (M, N[, 3]): 输入图像。如果colormap为None，则图像应为RGB格式。
border_color颜色规范，可选: 绘制区域之间边框的颜色。
edge_width浮点数，可选: 绘制RAG边的粗细。
edge_cmapmatplotlib.colors.Colormap，可选: 绘制边的任何matplotlib颜色图。
img_cmapmatplotlib.colors.Colormap，可选: 绘制图像的任何matplotlib颜色图。如果设置为None，则按原样绘制图像。
in_place布尔值，可选: 如果设置，则RAG会就地修改。对于每个节点n，该函数将设置一个新的属性rag.nodes[n]['centroid']。
axmatplotlib.axes.Axes，可选: 要绘制的坐标轴。如果未指定，则创建新的坐标轴并在其上绘制。

返回值：

lcmatplotlib.collections.LineCollection: 表示图形边的线集合。它可以传递给matplotlib.figure.Figure.colorbar()函数。

示例

>>> from skimage import data, segmentation, graph
>>> import matplotlib.pyplot as plt
>>>
>>> img = data.coffee()
>>> labels = segmentation.slic(img)
>>> g =  graph.rag_mean_color(img, labels)
>>> lc = graph.show_rag(labels, g, img)
>>> cbar = plt.colorbar(lc)

基于区域边界的区域邻接图(RAG)

绘制区域邻接图(RAG)

区域边界RAG的分层合并

class skimage.graph.MCP(costs, offsets=None, fully_connected=True, sampling=None)#

基类：object

一个用于查找给定n维成本数组中最短路径的类。

给定一个n维成本数组，可以使用此类查找从任何一组点到任何另一组点的通过该数组的最小成本路径。基本用法是初始化类并使用一个或多个起始索引（以及可选的结束索引列表）调用find_costs()。之后，多次调用traceback()以查找从任何给定结束位置到最近的起始索引的路径。可以通过重复调用find_costs()来查找通过相同成本数组的新路径。

路径的成本简单地计算为路径上每个点处costs数组值的总和。另一方面，MCP_Geometric类考虑了对角线移动与轴向移动长度不同的因素，并相应地对路径成本进行加权。

具有无限或负成本的数组元素将被简单地忽略，路径的累积成本溢出到无限也会被忽略。

参数：

costsndarray
offsets可迭代对象，可选: 偏移量元组列表：每个偏移量指定从给定n维位置的有效移动。如果未提供，则使用make_offsets()根据fully_connected参数值构造对应于单连接或全连接n维邻域的偏移量。
fully_connected布尔值，可选: 如果没有提供offsets，则这将确定生成的邻域的连接性。如果为真，则路径可能沿着costs数组元素之间的对角线移动；否则只允许轴向移动。
sampling元组，可选: 对于每个维度，指定两个单元格/体素之间的距离。如果未给出或为None，则假设距离为单位距离。

属性：

offsetsndarray: 等效于提供给构造函数的offsets，或者如果没有提供，则为为请求的n维邻域创建的偏移量。这些对于解释find_costs()方法返回的traceback数组很有用。

__init__(costs, offsets=None, fully_connected=True, sampling=None)#: 请参阅类文档。

find_costs(starts, ends=None, find_all_ends=True, max_coverage=1.0, max_cumulative_cost=None, max_cost=None)#

查找从给定起始点到目标点的最小成本路径。

此方法从指定的起始索引中的任何一个找到到指定结束索引的最小成本路径。如果没有给出结束位置，则将找到到成本数组中每个位置的最小成本路径。

参数：

starts可迭代对象: n维起始索引列表（其中n是costs数组的维度）。将找到到最近/最便宜的起始点的最小成本路径。
ends可迭代对象，可选: n维结束索引列表。
find_all_ends布尔值，可选: 如果为“True”（默认值），则将找到到每个指定的结束位置的最小成本路径；否则，当找到到任何结束位置的路径时，算法将停止。（如果未指定ends，则此参数无效。）

返回值：

cumulative_costsndarray: 与costs数组形状相同；此数组记录从最近/最便宜的起始索引到每个考虑索引的最小成本路径。（如果指定了ends，则不一定会考虑数组中的所有元素：未评估的位置的累积成本将为inf。如果find_all_ends为“False”，则只有指定的结束位置之一将具有有限的累积成本。）
tracebackndarray: 与costs数组形状相同；此数组包含从其前驱索引到任何给定索引的偏移量。偏移量索引索引到offsets属性中，该属性是n维偏移量的数组。在二维情况下，如果offsets[traceback[x, y]]为(-1, -1)，则表示[x, y]在到某个起始位置的最小成本路径中的前驱为[x+1, y+1]。请注意，如果offset_index为-1，则表示未考虑给定索引。

goal_reached(index, cumcost)#

int goal_reached(int index, float cumcost) 此方法在从堆中弹出索引后，在检查邻居之前，每次迭代都会被调用。

此方法可以被重载以修改MCP算法的行为。例如，当达到某个累积成本时，或者当前面距离种子点一定距离时，可以停止算法。

如果算法不应检查当前点的邻居，则此方法应返回1；如果算法现在已完成，则返回2。

offsets#

traceback(end)#

追踪预先计算的回溯数组中的最小成本路径。

此便捷函数从先前必须调用过的 find_costs() 提供的起始索引之一，重建到给定结束位置的最小成本路径。在运行 find_costs() 之后，可以根据需要多次调用此函数。

参数：

end可迭代对象: 一个 n 维索引，指向 costs 数组。

返回值：

tracebackn 维元组列表: 一个指向 costs 数组的索引列表，从传递给 find_costs() 的起始位置之一开始，以给定的 end 索引结束。这些索引指定从任何给定起始索引到 end 索引的最小成本路径。（该路径的总成本可以从 find_costs() 返回的 cumulative_costs 数组中读取。）

class skimage.graph.MCP_Connect(costs, offsets=None, fully_connected=True)#

基类：MCP

使用距离加权最小成本函数连接源点。

从每个种子点同时扩展一个前沿，同时跟踪前沿的来源。当两个前沿相遇时，调用 create_connection()。此方法必须被重载，以便以适合应用程序的方式处理找到的边。

__init__(*args, **kwargs)#

create_connection(id1, id2, tb1, tb2, cost1, cost2)#

create_connection id1, id2, pos1, pos2, cost1, cost2)

重载此方法以跟踪在 MCP 处理过程中找到的连接。请注意，可以多次找到具有相同 id 的连接（但位置和成本不同）。

在调用此方法时，这两个点都已“冻结”，并且 MCP 算法将不再访问它们。

参数：

id1int: 第一个邻居起源的种子点 id。
id2int: 第二个邻居起源的种子点 id。
pos1元组: 连接中第一个邻居的索引。
pos2元组: 连接中第二个邻居的索引。
cost1float: 在 pos1 处的累积成本。
cost2float: 在 pos2 处的累积成本。

find_costs(starts, ends=None, find_all_ends=True, max_coverage=1.0, max_cumulative_cost=None, max_cost=None)#

查找从给定起始点到目标点的最小成本路径。

此方法从指定的起始索引中的任何一个找到到指定结束索引的最小成本路径。如果没有给出结束位置，则将找到到成本数组中每个位置的最小成本路径。

参数：

starts可迭代对象: n维起始索引列表（其中n是costs数组的维度）。将找到到最近/最便宜的起始点的最小成本路径。
ends可迭代对象，可选: n维结束索引列表。
find_all_ends布尔值，可选: 如果为“True”（默认值），则将找到到每个指定的结束位置的最小成本路径；否则，当找到到任何结束位置的路径时，算法将停止。（如果未指定ends，则此参数无效。）

返回值：

cumulative_costsndarray: 与costs数组形状相同；此数组记录从最近/最便宜的起始索引到每个考虑索引的最小成本路径。（如果指定了ends，则不一定会考虑数组中的所有元素：未评估的位置的累积成本将为inf。如果find_all_ends为“False”，则只有指定的结束位置之一将具有有限的累积成本。）
tracebackndarray: 与 costs 数组形状相同；此数组包含从其前驱索引到任何给定索引的偏移量。偏移量索引指向 offsets 属性，该属性是 n 维偏移量数组。在二维情况下，如果 offsets[traceback[x, y]] 为 (-1, -1)，则表示到某个起始位置的最小成本路径中 [x, y] 的前驱为 [x+1, y+1]。请注意，如果 offset_index 为 -1，则表示未考虑给定索引。

goal_reached(index, cumcost)#

int goal_reached(int index, float cumcost) 此方法在从堆中弹出索引后，在检查邻居之前，每次迭代都会被调用。

此方法可以被重载以修改MCP算法的行为。例如，当达到某个累积成本时，或者当前面距离种子点一定距离时，可以停止算法。

如果算法不应检查当前点的邻居，则此方法应返回1；如果算法现在已完成，则返回2。

offsets#

traceback(end)#

追踪预先计算的回溯数组中的最小成本路径。

此便捷函数从先前必须调用过的 find_costs() 提供的起始索引之一，重建到给定结束位置的最小成本路径。在运行 find_costs() 之后，可以根据需要多次调用此函数。

参数：

end可迭代对象: 一个 n 维索引，指向 costs 数组。

返回值：

tracebackn 维元组列表: 一个指向 costs 数组的索引列表，从传递给 find_costs() 的起始位置之一开始，以给定的 end 索引结束。这些索引指定从任何给定起始索引到 end 索引的最小成本路径。（该路径的总成本可以从 find_costs() 返回的 cumulative_costs 数组中读取。）

class skimage.graph.MCP_Flexible(costs, offsets=None, fully_connected=True)#

基类：MCP

查找穿过N维成本数组的最小成本路径。

有关完整详细信息，请参阅 MCP 的文档。此类与 MCP 的区别在于，可以重载（从纯 Python）几种方法以修改算法的行为和/或基于 MCP 创建自定义算法。请注意，也可以在 MCP 类中重载 goal_reached。

__init__(costs, offsets=None, fully_connected=True, sampling=None)#: 请参阅类文档。

examine_neighbor(index, new_index, offset_length)#

此方法在每个相邻节点对上调用一次，只要两个节点都冻结。

此方法可以被重载以获取有关相邻节点的信息和/或修改 MCP 算法的行为。一个例子是 MCP_Connect 类，它使用此钩子检查是否满足前沿。

find_costs(starts, ends=None, find_all_ends=True, max_coverage=1.0, max_cumulative_cost=None, max_cost=None)#

查找从给定起始点到目标点的最小成本路径。

此方法从指定的起始索引中的任何一个找到到指定结束索引的最小成本路径。如果没有给出结束位置，则将找到到成本数组中每个位置的最小成本路径。

参数：

starts可迭代对象: n维起始索引列表（其中n是costs数组的维度）。将找到到最近/最便宜的起始点的最小成本路径。
ends可迭代对象，可选: n维结束索引列表。
find_all_ends布尔值，可选: 如果为“True”（默认值），则将找到到每个指定的结束位置的最小成本路径；否则，当找到到任何结束位置的路径时，算法将停止。（如果未指定ends，则此参数无效。）

返回值：

cumulative_costsndarray: 与costs数组形状相同；此数组记录从最近/最便宜的起始索引到每个考虑索引的最小成本路径。（如果指定了ends，则不一定会考虑数组中的所有元素：未评估的位置的累积成本将为inf。如果find_all_ends为“False”，则只有指定的结束位置之一将具有有限的累积成本。）
tracebackndarray: 与 costs 数组形状相同；此数组包含从其前驱索引到任何给定索引的偏移量。偏移量索引指向 offsets 属性，该属性是 n 维偏移量数组。在二维情况下，如果 offsets[traceback[x, y]] 为 (-1, -1)，则表示到某个起始位置的最小成本路径中 [x, y] 的前驱为 [x+1, y+1]。请注意，如果 offset_index 为 -1，则表示未考虑给定索引。

goal_reached(index, cumcost)#

int goal_reached(int index, float cumcost) 此方法在从堆中弹出索引后，在检查邻居之前，每次迭代都会被调用。

此方法可以被重载以修改MCP算法的行为。例如，当达到某个累积成本时，或者当前面距离种子点一定距离时，可以停止算法。

如果算法不应检查当前点的邻居，则此方法应返回1；如果算法现在已完成，则返回2。

offsets#

traceback(end)#

追踪预先计算的回溯数组中的最小成本路径。

此便捷函数从先前必须调用过的 find_costs() 提供的起始索引之一，重建到给定结束位置的最小成本路径。在运行 find_costs() 之后，可以根据需要多次调用此函数。

参数：

end可迭代对象: 一个 n 维索引，指向 costs 数组。

返回值：

tracebackn 维元组列表: 一个指向 costs 数组的索引列表，从传递给 find_costs() 的起始位置之一开始，以给定的 end 索引结束。这些索引指定从任何给定起始索引到 end 索引的最小成本路径。（该路径的总成本可以从 find_costs() 返回的 cumulative_costs 数组中读取。）

travel_cost(old_cost, new_cost, offset_length)#: 此方法计算从当前节点到下一个节点的行程成本。默认实现返回 new_cost。重载此方法以调整算法的行为。

update_node(index, new_index, offset_length)#

当节点更新时，在将 new_index 推送到堆并更新回溯映射后，调用此方法。

此方法可以被重载以跟踪算法的特定实现使用的其他数组。例如，MCP_Connect 类使用它来更新 id 映射。

class skimage.graph.MCP_Geometric(costs, offsets=None, fully_connected=True)#

基类：MCP

查找穿过n维成本数组的距离加权最小成本路径。

有关完整详细信息，请参阅 MCP 的文档。此类与 MCP 的区别在于路径的成本不仅仅是该路径上成本的总和。

此类假设 costs 数组在每个位置都包含穿过该位置的单位距离的“成本”。例如，在二维空间中从 (1, 1) 移动到 (1, 2) 被假定为起源于像素 (1, 1) 的中心并终止于 (1, 2) 的中心。整个移动距离为 1，一半穿过 (1, 1)，另一半穿过 (1, 2)；因此，该移动的成本为 (1/2)*costs[1,1] + (1/2)*costs[1,2]。

另一方面，从 (1, 1) 移动到 (2, 2) 是沿着对角线移动，长度为 sqrt(2)。此移动的一半在像素 (1, 1) 内，另一半在 (2, 2) 内，因此此移动的成本计算为 (sqrt(2)/2)*costs[1,1] + (sqrt(2)/2)*costs[2,2]。

这些计算在偏移量大于 1 时没有多大意义。请使用 sampling 参数来处理各向异性数据。

__init__(costs, offsets=None, fully_connected=True, sampling=None)#: 请参阅类文档。

find_costs(starts, ends=None, find_all_ends=True, max_coverage=1.0, max_cumulative_cost=None, max_cost=None)#

查找从给定起始点到目标点的最小成本路径。

此方法从指定的起始索引中的任何一个找到到指定结束索引的最小成本路径。如果没有给出结束位置，则将找到到成本数组中每个位置的最小成本路径。

参数：

starts可迭代对象: n维起始索引列表（其中n是costs数组的维度）。将找到到最近/最便宜的起始点的最小成本路径。
ends可迭代对象，可选: n维结束索引列表。
find_all_ends布尔值，可选: 如果为“True”（默认值），则将找到到每个指定的结束位置的最小成本路径；否则，当找到到任何结束位置的路径时，算法将停止。（如果未指定ends，则此参数无效。）

返回值：

cumulative_costsndarray: 与costs数组形状相同；此数组记录从最近/最便宜的起始索引到每个考虑索引的最小成本路径。（如果指定了ends，则不一定会考虑数组中的所有元素：未评估的位置的累积成本将为inf。如果find_all_ends为“False”，则只有指定的结束位置之一将具有有限的累积成本。）
tracebackndarray: 与 costs 数组形状相同；此数组包含从其前驱索引到任何给定索引的偏移量。偏移量索引索引到 offsets 属性，该属性是 n 维偏移量的数组。在二维情况下，如果 offsets[traceback[x, y]] 为 (-1, -1)，则表示到达某个起始位置的最小成本路径中 [x, y] 的前驱为 [x+1, y+1]。请注意，如果 offset_index 为 -1，则表示未考虑给定索引。

goal_reached(index, cumcost)#

int goal_reached(int index, float cumcost) 此方法在从堆中弹出索引后，在检查邻居之前，每次迭代都会被调用。

此方法可以被重载以修改MCP算法的行为。例如，当达到某个累积成本时，或者当前面距离种子点一定距离时，可以停止算法。

如果算法不应检查当前点的邻居，则此方法应返回1；如果算法现在已完成，则返回2。

offsets#

traceback(end)#

追踪预先计算的回溯数组中的最小成本路径。

此便捷函数从先前必须调用过的 find_costs() 提供的起始索引之一，重建到给定结束位置的最小成本路径。在运行 find_costs() 之后，可以根据需要多次调用此函数。

参数：

end可迭代对象: 一个 n 维索引，指向 costs 数组。

返回值：

tracebackn 维元组列表: 一个指向 costs 数组的索引列表，从传递给 find_costs() 的起始位置之一开始，以给定的 end 索引结束。这些索引指定从任何给定起始索引到 end 索引的最小成本路径。（该路径的总成本可以从 find_costs() 返回的 cumulative_costs 数组中读取。）

class skimage.graph.RAG(label_image=None, connectivity=1, data=None, **attr)[source]#

基类：Graph

图像的区域邻接图（RAG），是networkx.Graph的子类。

参数：

label_imageint 型数组: 初始分割，每个区域标记为不同的整数。label_image 中的每个唯一值都将对应于图中的一个节点。
connectivityint，取值范围为 {1, …, label_image.ndim}，可选: label_image 中像素之间的连接性。对于二维图像，连接性 1 对应于上下左右的直接邻居，而连接性 2 还包括对角邻居。请参阅 scipy.ndimage.generate_binary_structure()。
datanetworkx.Graph 规范，可选: 要传递给 networkx.Graph 构造函数的初始或其他边。有效的边规范包括边列表（元组列表）、NumPy 数组和 SciPy 稀疏矩阵。
**attr关键字参数，可选: 要添加到图中的其他属性。

__init__(label_image=None, connectivity=1, data=None, **attr)[source]#

使用边、名称或图形属性初始化图形。

参数：

incoming_graph_data输入图（可选，默认值：None）: 初始化图形的数据。如果为 None（默认值），则创建空图。数据可以是边列表，或任何 NetworkX 图对象。如果安装了相应的可选 Python 包，则数据还可以是二维 NumPy 数组、SciPy 稀疏数组或 PyGraphviz 图。
attr关键字参数，可选（默认值：无属性）: 要作为键值对添加到图中的属性。

另请参阅

转换

示例

>>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G = nx.Graph(name="my graph")
>>> e = [(1, 2), (2, 3), (3, 4)]  # list of edges
>>> G = nx.Graph(e)

可以分配任意图属性对（键=值）

>>> G = nx.Graph(e, day="Friday")
>>> G.graph
{'day': 'Friday'}

add_edge(u, v, attr_dict=None, **attr)[source]#: 在 u 和 v 之间添加一条边，同时更新最大节点 ID。

另请参阅

networkx.Graph.add_edge.

add_edges_from(ebunch_to_add, **attr)[source]#

添加 ebunch_to_add 中的所有边。

参数：

ebunch_to_add边容器: 容器中给出的每条边都将添加到图中。边必须以 2 元组 (u, v) 或 3 元组 (u, v, d) 的形式给出，其中 d 是包含边数据的字典。
attr关键字参数，可选: 可以使用关键字参数分配边数据（或标签或对象）。

另请参阅

add_edge: 添加一条边
add_weighted_edges_from: 添加加权边的便捷方法

注释

添加相同的边两次不会产生任何影响，但每次添加重复边时，任何边数据都将更新。

在 ebunch 中指定的边属性优先于通过关键字参数指定的属性。

当从迭代器中添加边到正在更改的图时，可能会引发 RuntimeError，并显示消息：RuntimeError: dictionary changed size during iteration。当在迭代期间修改图的基础字典时，就会发生这种情况。为避免此错误，请将迭代器评估为单独的对象，例如使用 list(iterator_of_edges)，并将此对象传递给 G.add_edges_from。

示例

>>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_edges_from([(0, 1), (1, 2)])  # using a list of edge tuples
>>> e = zip(range(0, 3), range(1, 4))
>>> G.add_edges_from(e)  # Add the path graph 0-1-2-3

将数据关联到边

>>> G.add_edges_from([(1, 2), (2, 3)], weight=3)
>>> G.add_edges_from([(3, 4), (1, 4)], label="WN2898")

如果使用迭代器修改同一图，则评估图上的迭代器

>>> G = nx.Graph([(1, 2), (2, 3), (3, 4)])
>>> # Grow graph by one new node, adding edges to all existing nodes.
>>> # wrong way - will raise RuntimeError
>>> # G.add_edges_from(((5, n) for n in G.nodes))
>>> # correct way - note that there will be no self-edge for node 5
>>> G.add_edges_from(list((5, n) for n in G.nodes))

add_node(n, attr_dict=None, **attr)[source]#: 添加节点 n，同时更新最大节点 ID。

另请参阅

networkx.Graph.add_node.

add_nodes_from(nodes_for_adding, **attr)[source]#

添加多个节点。

参数：

nodes_for_adding可迭代容器: 节点容器（列表、字典、集合等）。或 (节点，属性字典) 元组的容器。节点属性使用属性字典更新。
attr关键字参数，可选（默认值：无属性）: 更新 nodes 中所有节点的属性。作为元组在 nodes 中指定的节点属性优先于通过关键字参数指定的属性。

另请参阅

add_node

注释

当从正在更改的图的迭代器中添加节点时，可能会引发 RuntimeError，并显示消息：RuntimeError: dictionary changed size during iteration。这是因为在迭代期间修改了图的基础字典。为了避免此错误，请将迭代器评估为一个单独的对象，例如使用 list(iterator_of_nodes)，并将此对象传递给 G.add_nodes_from。

示例

>>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_nodes_from("Hello")
>>> K3 = nx.Graph([(0, 1), (1, 2), (2, 0)])
>>> G.add_nodes_from(K3)
>>> sorted(G.nodes(), key=str)
[0, 1, 2, 'H', 'e', 'l', 'o']

使用关键字更新每个节点的特定节点属性。

>>> G.add_nodes_from([1, 2], size=10)
>>> G.add_nodes_from([3, 4], weight=0.4)

使用 (节点，attrdict) 元组更新特定节点的属性。

>>> G.add_nodes_from([(1, dict(size=11)), (2, {"color": "blue"})])
>>> G.nodes[1]["size"]
11
>>> H = nx.Graph()
>>> H.add_nodes_from(G.nodes(data=True))
>>> H.nodes[1]["size"]
11

如果使用迭代器修改同一图，则评估图上的迭代器

>>> G = nx.Graph([(0, 1), (1, 2), (3, 4)])
>>> # wrong way - will raise RuntimeError
>>> # G.add_nodes_from(n + 1 for n in G.nodes)
>>> # correct way
>>> G.add_nodes_from(list(n + 1 for n in G.nodes))

add_weighted_edges_from(ebunch_to_add, weight='weight', **attr)[source]#

在 ebunch_to_add 中添加具有指定权重属性的加权边

参数：

ebunch_to_add边容器: 列表或容器中给定的每条边都将添加到图中。边必须以 3 元组 (u, v, w) 的形式给出，其中 w 是一个数字。
weight字符串，可选（默认值为“weight”）: 要添加的边权重的属性名称。
attr关键字参数，可选（默认值：无属性）: 要为所有边添加/更新的边属性。

另请参阅

add_edge: 添加一条边
add_edges_from: 添加多条边

注释

对于 Graph/DiGraph，添加相同的边两次只会更新边数据。对于 MultiGraph/MultiDiGraph，重复的边会被存储。

当从正在更改的图的迭代器中添加边时，可能会引发 RuntimeError，并显示消息：RuntimeError: dictionary changed size during iteration。这是因为在迭代期间修改了图的基础字典。为了避免此错误，请将迭代器评估为一个单独的对象，例如使用 list(iterator_of_edges)，并将此对象传递给 G.add_weighted_edges_from。

示例

>>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_weighted_edges_from([(0, 1, 3.0), (1, 2, 7.5)])

在传递边迭代器之前对其进行评估

>>> G = nx.Graph([(1, 2), (2, 3), (3, 4)])
>>> weight = 0.1
>>> # Grow graph by one new node, adding edges to all existing nodes.
>>> # wrong way - will raise RuntimeError
>>> # G.add_weighted_edges_from(((5, n, weight) for n in G.nodes))
>>> # correct way - note that there will be no self-edge for node 5
>>> G.add_weighted_edges_from(list((5, n, weight) for n in G.nodes))

property adj#

保存每个节点邻居的图邻接对象。

此对象是一个类似字典的只读结构，具有节点键和邻居字典值。邻居字典以邻居为键，对应于边数据字典。因此，G.adj[3][2][‘color’] = ‘blue’ 将边 (3, 2) 的颜色设置为 “blue”。

遍历 G.adj 的行为类似于字典。有用的用法包括 for nbr, datadict in G.adj[n].items():。

邻居信息也可以通过对图进行下标访问来获取。因此，for nbr, foovalue in G[node].data(‘foo’, default=1): 可以正常工作。

对于有向图，G.adj 保存的是出度（后继）信息。

adjacency()[source]#

返回所有节点的 (节点，邻接字典) 元组的迭代器。

对于有向图，仅包含出度邻居/邻接关系。

返回值：

adj_iter迭代器: 图中所有节点的 (节点，邻接字典) 的迭代器。

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> [(n, nbrdict) for n, nbrdict in G.adjacency()]
[(0, {1: {}}), (1, {0: {}, 2: {}}), (2, {1: {}, 3: {}}), (3, {2: {}})]

adjlist_inner_dict_factory#: dict 的别名

adjlist_outer_dict_factory#: dict 的别名

clear()[source]#

删除图中的所有节点和边。

这也将删除名称以及所有图、节点和边属性。

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.clear()
>>> list(G.nodes)
[]
>>> list(G.edges)
[]

clear_edges()[source]#

删除图中的所有边，而不改变节点。

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.clear_edges()
>>> list(G.nodes)
[0, 1, 2, 3]
>>> list(G.edges)
[]

copy()[source]#: 复制图及其最大节点 ID。

另请参阅

networkx.Graph.copy.

property degree#

图的 DegreeView，如 G.degree 或 G.degree()。

节点度数是与节点相邻的边的数量。加权节点度数是连接到该节点的边的权重之和。

此对象提供 (节点，度数) 的迭代器以及单个节点度数的查找。

参数：

nbunch单个节点、容器或所有节点（默认值为所有节点）: 该视图仅报告与这些节点关联的边。
weight字符串或 None，可选（默认值为 None）: 保存用作权重的数值的边属性的名称。如果为 None，则每条边的权重为 1。度数是与节点相邻的边权重之和。

返回值：

DegreeView 或 int: 如果请求多个节点（默认值），则返回一个 DegreeView，将节点映射到它们的度数。如果请求单个节点，则返回该节点的度数（整数）。

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.degree[0]  # node 0 has degree 1
1
>>> list(G.degree([0, 1, 2]))
[(0, 1), (1, 2), (2, 2)]

edge_attr_dict_factory#: dict 的别名

edge_subgraph(edges)[source]#

返回由指定边诱导的子图。

诱导子图包含 edges 中的每条边以及与其中任何一条边关联的每个节点。

参数：

edges可迭代对象: 此图中边的可迭代对象。

返回值：

G图: 此图的边诱导子图，具有相同的边属性。

注释

返回的子图视图中的图、边和节点属性是对此图中相应属性的引用。该视图是只读的。

要创建具有其自身边或节点属性副本的子图的完整图版本，请使用

G.edge_subgraph(edges).copy()

示例

>>> G = nx.path_graph(5)
>>> H = G.edge_subgraph([(0, 1), (3, 4)])
>>> list(H.nodes)
[0, 1, 3, 4]
>>> list(H.edges)
[(0, 1), (3, 4)]

property edges#

图的 EdgeView，如 G.edges 或 G.edges()。

edges(self, nbunch=None, data=False, default=None)

EdgeView 对边元组提供类似集合的操作以及边属性查找。当被调用时，它还提供了一个 EdgeDataView 对象，该对象允许控制对边属性的访问（但不提供类似集合的操作）。因此，G.edges[u, v][‘color’] 提供边 (u, v) 的颜色属性的值，而 for (u, v, c) in G.edges.data(‘color’, default=’red’): 遍历所有边，产生颜色属性，如果不存在颜色属性，则使用默认值 ‘red’。

参数：

nbunch单个节点、容器或所有节点（默认值为所有节点）: 该视图仅报告来自这些节点的边。
data字符串或布尔值，可选（默认值为 False）: 在 3 元组 (u, v, ddict[data]) 中返回的边属性。如果为 True，则在 3 元组 (u, v, ddict) 中返回边属性字典。如果为 False，则返回 2 元组 (u, v)。
default值，可选（默认值为 None）: 用于没有请求属性的边的值。仅当 data 不是 True 或 False 时才相关。

返回值：

edgesEdgeView: 边属性的视图，通常它迭代边元组 (u, v) 或 (u, v, d)，但也可用于属性查找，如 edges[u, v][‘foo’]。

注释

不在图中的 nbunch 中的节点将被（静默地）忽略。对于有向图，这将返回出边。

示例

>>> G = nx.path_graph(3)  # or MultiGraph, etc
>>> G.add_edge(2, 3, weight=5)
>>> [e for e in G.edges]
[(0, 1), (1, 2), (2, 3)]
>>> G.edges.data()  # default data is {} (empty dict)
EdgeDataView([(0, 1, {}), (1, 2, {}), (2, 3, {'weight': 5})])
>>> G.edges.data("weight", default=1)
EdgeDataView([(0, 1, 1), (1, 2, 1), (2, 3, 5)])
>>> G.edges([0, 3])  # only edges from these nodes
EdgeDataView([(0, 1), (3, 2)])
>>> G.edges(0)  # only edges from node 0
EdgeDataView([(0, 1)])

fresh_copy()[source]#

返回具有相同数据结构的新副本图。

新副本没有节点、边或图属性。它与当前图具有相同的数据结构。此方法通常用于创建图的空版本。

当使用 networkx v2 对 Graph 进行子类化时，这是必需的，并且不会导致 v1 出现问题。以下是网络从 1.x 迁移到 2.x 文档中的更多详细信息

With the new GraphViews (SubGraph, ReversedGraph, etc)
you can't assume that ``G.__class__()`` will create a new
instance of the same graph type as ``G``. In fact, the
call signature for ``__class__`` differs depending on
whether ``G`` is a view or a base class. For v2.x you
should use ``G.fresh_copy()`` to create a null graph of
the correct type---ready to fill with nodes and edges.

get_edge_data(u, v, default=None)[source]#

返回与边 (u, v) 关联的属性字典。

这与 G[u][v] 相同，只是如果边不存在，则返回默认值而不是引发异常。

参数：

u, v节点
default: 任何 Python 对象（默认值为 None）: 如果未找到边 (u, v)，则返回的值。

返回值：

edge_dict字典: 边属性字典。

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G[0][1]
{}

警告：不允许赋值给 G[u][v]。但可以安全地赋值属性 G[u][v][‘foo’]

>>> G[0][1]["weight"] = 7
>>> G[0][1]["weight"]
7
>>> G[1][0]["weight"]
7

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.get_edge_data(0, 1)  # default edge data is {}
{}
>>> e = (0, 1)
>>> G.get_edge_data(*e)  # tuple form
{}
>>> G.get_edge_data("a", "b", default=0)  # edge not in graph, return 0
0

graph_attr_dict_factory#: dict 的别名

has_edge(u, v)[source]#

如果图中存在边 (u, v)，则返回 True。

这与 v in G[u] 相同，但不会引发 KeyError 异常。

参数：

u, v节点: 节点可以是字符串或数字等。节点必须是可哈希的（且不为 None）Python 对象。

返回值：

edge_indbool: 如果边在图中，则为 True，否则为 False。

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.has_edge(0, 1)  # using two nodes
True
>>> e = (0, 1)
>>> G.has_edge(*e)  #  e is a 2-tuple (u, v)
True
>>> e = (0, 1, {"weight": 7})
>>> G.has_edge(*e[:2])  # e is a 3-tuple (u, v, data_dictionary)
True

以下语法等效

>>> G.has_edge(0, 1)
True
>>> 1 in G[0]  # though this gives KeyError if 0 not in G
True

has_node(n)[source]#

如果图包含节点 n，则返回 True。

与 n in G 相同

参数：

nnode

示例

>>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.has_node(0)
True

使用以下方式更易读和简单

>>> 0 in G
True

is_directed()[source]#: 如果图是有向图，则返回 True，否则返回 False。

is_multigraph()[source]#: 如果图是多重图，则返回 True，否则返回 False。

merge_nodes(src, dst, weight_func=<function min_weight>, in_place=True, extra_arguments=None, extra_keywords=None)[source]#

合并节点 src 和 dst。

新的组合节点与 src 和 dst 的所有邻居相邻。 weight_func 用于确定与新节点关联的边的权重。

参数：

src, dstint: 要合并的节点。
weight_funccallable, optional: 用于确定与新节点关联的边属性的函数。对于 src 和 dst 的每个邻居 n，将按如下方式调用 weight_func： weight_func(src, dst, n, *extra_arguments, **extra_keywords)。 src、dst 和 n 是 RAG 对象中顶点的 ID，RAG 对象是 networkx.Graph 的子类。它应该返回一个包含结果边属性的字典。
in_place布尔值，可选: 如果设置为 True，则合并节点的 ID 为 dst，否则合并节点将有一个新的 ID，该 ID 将被返回。
extra_argumentssequence, optional: 传递给 weight_func 的额外位置参数序列。
extra_keywordsdictionary, optional: 传递给 weight_func 的关键字参数字典。

返回值：

idint: 新节点的 ID。

注释

如果 in_place 为 False，则结果节点将具有一个新的 ID，而不是 dst。

property name#

图的字符串标识符。

此图属性出现在属性字典 G.graph 中，以字符串 “name” 为键，以及属性（严格来说是属性）G.name。这完全由用户控制。

nbunch_iter(nbunch=None)[source]#

返回包含在 nbunch 中且也在图中的节点的迭代器。

检查 nbunch 中的节点是否属于图，如果不属于，则会静默忽略。

参数：

nbunch单个节点、容器或所有节点（默认值为所有节点）: 该视图仅报告与这些节点关联的边。

返回值：

niteriterator: nbunch 中也存在于图中的节点的迭代器。如果 nbunch 为 None，则迭代图中的所有节点。

引发:

NetworkXError: 如果 nbunch 不是节点或节点序列。如果 nbunch 中的节点不可哈希。

另请参阅

Graph.__iter__

注释

当 nbunch 是迭代器时，返回的迭代器直接从 nbunch 生成值，当 nbunch 耗尽时也会耗尽。

要测试 nbunch 是否是单个节点，即使在使用此例程处理后，也可以使用“if nbunch in self:”。

如果 nbunch 不是节点或（可能是空的）序列/迭代器或 None，则会引发 NetworkXError。此外，如果 nbunch 中的任何对象不可哈希，则会引发 NetworkXError。

neighbors(n)[source]#

返回节点 n 的所有邻居的迭代器。

这与 iter(G[n]) 相同

参数：

nnode: 图中的一个节点

返回值：

neighborsiterator: 节点 n 的所有邻居的迭代器

引发:

NetworkXError: 如果节点 n 不在图中。

注释

访问邻居的其他方法是 G.adj[n] 或 G[n]

>>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_edge("a", "b", weight=7)
>>> G["a"]
AtlasView({'b': {'weight': 7}})
>>> G = nx.path_graph(4)
>>> [n for n in G[0]]
[1]

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> [n for n in G.neighbors(0)]
[1]

next_id()[source]#

返回要插入的新节点的 id。

当前实现返回最大 id 加 1。

返回值：

idint: 要插入的新节点的 id。

node_attr_dict_factory#: dict 的别名

node_dict_factory#: dict 的别名

property nodes#

图的 NodeView，表示为 G.nodes 或 G.nodes()。

可用于数据查找和集合式操作，如 G.nodes。也可用于 G.nodes(data=’color’, default=None) 返回 NodeDataView，它报告特定的节点数据，但不执行集合操作。它也提供了类似字典的接口，G.nodes.items() 迭代 (node, nodedata) 2 元组，G.nodes[3][‘foo’] 提供节点 3 的 foo 属性的值。此外，视图 G.nodes.data(‘foo’) 提供了节点 foo 属性的类似字典的接口。G.nodes.data(‘foo’, default=1) 为没有属性 foo 的节点提供默认值。

参数：

data字符串或布尔值，可选（默认值为 False）: 在 2 元组 (n, ddict[data]) 中返回的节点属性。如果为 True，则返回整个节点属性字典作为 (n, ddict)。如果为 False，则仅返回节点 n。
default值，可选（默认值为 None）: 用于没有请求属性的节点的值。仅当数据不是 True 或 False 时才相关。

返回值：

NodeView

允许对节点进行类似集合的操作，以及节点属性字典查找和调用以获取 NodeDataView。NodeDataView 迭代 (n, data) 并且没有集合操作。NodeView 迭代 n 并包含集合操作。

当被调用时，如果 data 为 False，则为节点的迭代器。否则为 2 元组 (节点，属性值) 的迭代器，其中属性在 data 中指定。如果 data 为 True，则属性变为整个数据字典。

注释

如果不需要节点数据，则使用表达式 for n in G 或 list(G) 更简单且等效。

示例

有两种简单的方法可以获取图中所有节点的列表

>>> G = nx.path_graph(3)
>>> list(G.nodes)
[0, 1, 2]
>>> list(G)
[0, 1, 2]

要获取节点数据以及节点

>>> G.add_node(1, time="5pm")
>>> G.nodes[0]["foo"] = "bar"
>>> list(G.nodes(data=True))
[(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]
>>> list(G.nodes.data())
[(0, {'foo': 'bar'}), (1, {'time': '5pm'}), (2, {})]

>>> list(G.nodes(data="foo"))
[(0, 'bar'), (1, None), (2, None)]
>>> list(G.nodes.data("foo"))
[(0, 'bar'), (1, None), (2, None)]

>>> list(G.nodes(data="time"))
[(0, None), (1, '5pm'), (2, None)]
>>> list(G.nodes.data("time"))
[(0, None), (1, '5pm'), (2, None)]

>>> list(G.nodes(data="time", default="Not Available"))
[(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]
>>> list(G.nodes.data("time", default="Not Available"))
[(0, 'Not Available'), (1, '5pm'), (2, 'Not Available')]

如果某些节点具有属性，而其余节点假定具有默认属性值，则可以使用 default 关键字参数从节点/属性对创建字典，以确保值永远不会为 None

>>> G = nx.Graph()
>>> G.add_node(0)
>>> G.add_node(1, weight=2)
>>> G.add_node(2, weight=3)
>>> dict(G.nodes(data="weight", default=1))
{0: 1, 1: 2, 2: 3}

number_of_edges(u=None, v=None)[source]#

返回两个节点之间的边数。

参数：

u, vnodes, optional (default=all edges): 如果指定了 u 和 v，则返回 u 和 v 之间的边数。否则返回所有边的总数。

返回值：

nedgesint: 图中边的数量。如果指定了节点 u 和 v，则返回这两个节点之间的边数。如果图是有向图，则仅返回从 u 到 v 的边数。

另请参阅

size

示例

对于无向图，此方法计算图中边的总数

>>> G = nx.path_graph(4)
>>> G.number_of_edges()
3

如果指定两个节点，则计算连接这两个节点的边的总数

>>> G.number_of_edges(0, 1)
1

对于有向图，此方法可以计算从 u 到 v 的有向边的总数

>>> G = nx.DiGraph()
>>> G.add_edge(0, 1)
>>> G.add_edge(1, 0)
>>> G.number_of_edges(0, 1)
1

number_of_nodes()[source]#

返回图中节点的数量。

返回值：

nnodesint: 图中节点的数量。

另请参阅

order: 相同的方法
__len__: 相同的方法

示例

>>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.number_of_nodes()
3

order()[source]#

返回图中节点的数量。

返回值：

nnodesint: 图中节点的数量。

另请参阅

节点数: 相同的方法
__len__: 相同的方法

示例

>>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.order()
3

remove_edge(u, v)[source]#

移除节点 u 和 v 之间的边。

参数：

u, v节点: 移除节点 u 和 v 之间的边。

引发:

NetworkXError: 如果节点 u 和 v 之间不存在边。

另请参阅

remove_edges_from: 移除一组边

示例

>>> G = nx.path_graph(4)  # or DiGraph, etc
>>> G.remove_edge(0, 1)
>>> e = (1, 2)
>>> G.remove_edge(*e)  # unpacks e from an edge tuple
>>> e = (2, 3, {"weight": 7})  # an edge with attribute data
>>> G.remove_edge(*e[:2])  # select first part of edge tuple

remove_edges_from(ebunch)[source]#

移除 ebunch 中指定的所有边。

参数：

ebunch: 边元组列表或容器

列表或容器中给出的每条边都将从图中移除。边可以是

2 元组 (u, v) u 和 v 之间的边。

3 元组 (u, v, k) 其中 k 被忽略。

另请参阅

remove_edge: 移除一条边

注释

如果 ebunch 中的边不在图中，则会静默失败。

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> ebunch = [(1, 2), (2, 3)]
>>> G.remove_edges_from(ebunch)

remove_node(n)[source]#

移除节点 n。

移除节点 n 及其所有相邻边。尝试移除不存在的节点将引发异常。

参数：

nnode: 图中的一个节点

引发:

NetworkXError: 如果 n 不在图中。

另请参阅

remove_nodes_from

示例

>>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> list(G.edges)
[(0, 1), (1, 2)]
>>> G.remove_node(1)
>>> list(G.edges)
[]

remove_nodes_from(nodes)[source]#

移除多个节点。

参数：

nodes可迭代容器: 节点容器（列表、字典、集合等）。如果容器中的节点不在图中，则会静默忽略。

另请参阅

remove_node

注释

当从正在更改的图上的迭代器中移除节点时，将引发 RuntimeError，并显示消息：RuntimeError: dictionary changed size during iteration。这种情况发生在迭代过程中修改了图的基础字典时。为了避免此错误，请将迭代器评估为一个单独的对象，例如使用 list(iterator_of_nodes)，并将此对象传递给 G.remove_nodes_from。

示例

>>> G = nx.path_graph(3)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> e = list(G.nodes)
>>> e
[0, 1, 2]
>>> G.remove_nodes_from(e)
>>> list(G.nodes)
[]

如果使用迭代器修改同一图，则评估图上的迭代器

>>> G = nx.Graph([(0, 1), (1, 2), (3, 4)])
>>> # this command will fail, as the graph's dict is modified during iteration
>>> # G.remove_nodes_from(n for n in G.nodes if n < 2)
>>> # this command will work, since the dictionary underlying graph is not modified
>>> G.remove_nodes_from(list(n for n in G.nodes if n < 2))

size(weight=None)[source]#

返回边的数量或所有边权重的总和。

参数：

weight字符串或 None，可选（默认值为 None）: 保存用作权重的数值的边属性。如果为 None，则每条边的权重为 1。

返回值：

size数值型

边的数量或（如果提供了 weight 关键字）权重总和。

如果 weight 为 None，则返回一个整数。否则返回一个浮点数（或者如果权重更通用，则返回更通用的数值）。

另请参阅

number_of_edges

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.size()
3

>>> G = nx.Graph()  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> G.add_edge("a", "b", weight=2)
>>> G.add_edge("b", "c", weight=4)
>>> G.size()
2
>>> G.size(weight="weight")
6.0

subgraph(nodes)[source]#

返回在 nodes 上诱导的子图的 SubGraph 视图。

图的诱导子图包含 nodes 中的节点以及这些节点之间的边。

参数：

nodes列表，可迭代对象: 将被迭代一次的节点容器。

返回值：

G子图视图: 图的子图视图。无法更改图结构，但可以更改节点/边属性，并且与原始图共享。

注释

图、边和节点属性与原始图共享。视图排除了对图结构的更改，但对属性的更改反映在原始图中。

要创建具有其自身边/节点属性副本的子图，请使用：G.subgraph(nodes).copy()

要将图就地缩减为子图，您可以移除节点：G.remove_nodes_from([n for n in G if n not in set(nodes)])

子图视图有时不是您想要的。在大多数情况下，如果您想做的不仅仅是查看诱导的边，那么创建子图作为其自身的图更有意义，代码如下

# Create a subgraph SG based on a (possibly multigraph) G
SG = G.__class__()
SG.add_nodes_from((n, G.nodes[n]) for n in largest_wcc)
if SG.is_multigraph():
    SG.add_edges_from(
        (n, nbr, key, d)
        for n, nbrs in G.adj.items()
        if n in largest_wcc
        for nbr, keydict in nbrs.items()
        if nbr in largest_wcc
        for key, d in keydict.items()
    )
else:
    SG.add_edges_from(
        (n, nbr, d)
        for n, nbrs in G.adj.items()
        if n in largest_wcc
        for nbr, d in nbrs.items()
        if nbr in largest_wcc
    )
SG.graph.update(G.graph)

示例

>>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
>>> H = G.subgraph([0, 1, 2])
>>> list(H.edges)
[(0, 1), (1, 2)]

to_directed(as_view=False)[source]#

返回图的有向表示。

返回值：

G有向图: 一个具有相同名称、相同节点的有向图，并且每条边 (u, v, data) 都被替换为两条有向边 (u, v, data) 和 (v, u, data)。

注释

这将返回边、节点和图属性的“深拷贝”，它试图完全复制所有数据和引用。

这与类似的 D=DiGraph(G) 形成对比，后者返回数据的浅拷贝。

有关浅拷贝和深拷贝的更多信息，请参阅 Python copy 模块，https://docs.pythonlang.cn/3/library/copy.html。

警告：如果您已对 Graph 进行子类化以在数据结构中使用类似字典的对象，则这些更改不会转移到此方法创建的 DiGraph 中。

示例

>>> G = nx.Graph()  # or MultiGraph, etc
>>> G.add_edge(0, 1)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1), (1, 0)]

如果已经是定向的，则返回一个（深）副本

>>> G = nx.DiGraph()  # or MultiDiGraph, etc
>>> G.add_edge(0, 1)
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1)]

to_directed_class()[source]#

返回用于空有向副本的类。

如果您对基类进行子类化，请使用此方法指定用于 to_directed() 副本的有向类。

to_undirected(as_view=False)[source]#

返回图的无向副本。

参数：

as_view布尔值（可选，默认为 False）: 如果为 True，则返回原始无向图的视图。

返回值：

G图/多图: 图的深拷贝。

另请参阅

Graph，copy，add_edge，add_edges_from

注释

这将返回边、节点和图属性的“深拷贝”，它试图完全复制所有数据和引用。

这与类似的 G = nx.DiGraph(D) 形成对比，后者返回数据的浅拷贝。

有关浅拷贝和深拷贝的更多信息，请参阅 Python copy 模块，https://docs.pythonlang.cn/3/library/copy.html。

警告：如果您已对 DiGraph 进行子类化以在数据结构中使用类似字典的对象，则这些更改不会转移到此方法创建的 Graph 中。

示例

>>> G = nx.path_graph(2)  # or MultiGraph, etc
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1), (1, 0)]
>>> G2 = H.to_undirected()
>>> list(G2.edges)
[(0, 1)]

to_undirected_class()[source]#

返回用于空无向副本的类。

如果您对基类进行子类化，请使用此方法指定用于 to_directed() 副本的有向类。

update(edges=None, nodes=None)[source]#

使用节点/边/图作为输入更新图。

类似于 dict.update，此方法将图作为输入，并将图的节点和边添加到此图中。它还可以接受两个输入：边和节点。最后，它可以接受边或节点。要仅指定节点，必须使用关键字 nodes。

边和节点的集合与 add_edges_from/add_nodes_from 方法类似。当迭代时，它们应该产生 2 元组 (u, v) 或 3 元组 (u, v, datadict)。

参数：

edges图对象，边集合或 None: 第一个参数可以是图或一些边。如果它具有属性 nodes 和 edges，则将其视为图状对象，并且这些属性用作要添加到图中的节点和边的集合。如果第一个参数没有这些属性，则将其视为边集合并添加到图中。如果第一个参数为 None，则不添加任何边。
nodes节点集合或 None: 第二个参数被视为要添加到图中的节点集合，除非它为 None。如果edges 为 None 且nodes 为 None，则会引发异常。如果第一个参数是 Graph，则忽略nodes。

另请参阅

add_edges_from: 向图中添加多条边
add_nodes_from: 向图中添加多个节点

注释

如果您想使用邻接结构更新图，则可以轻松地从邻接结构中获取边/节点。以下示例提供了常见情况，您的邻接结构可能略有不同，需要对这些示例进行调整。

>>> # dict-of-set/list/tuple
>>> adj = {1: {2, 3}, 2: {1, 3}, 3: {1, 2}}
>>> e = [(u, v) for u, nbrs in adj.items() for v in nbrs]
>>> G.update(edges=e, nodes=adj)

>>> DG = nx.DiGraph()
>>> # dict-of-dict-of-attribute
>>> adj = {1: {2: 1.3, 3: 0.7}, 2: {1: 1.4}, 3: {1: 0.7}}
>>> e = [(u, v, {"weight": d}) for u, nbrs in adj.items() for v, d in nbrs.items()]
>>> DG.update(edges=e, nodes=adj)

>>> # dict-of-dict-of-dict
>>> adj = {1: {2: {"weight": 1.3}, 3: {"color": 0.7, "weight": 1.2}}}
>>> e = [(u, v, {"weight": d}) for u, nbrs in adj.items() for v, d in nbrs.items()]
>>> DG.update(edges=e, nodes=adj)

>>> # predecessor adjacency (dict-of-set)
>>> pred = {1: {2, 3}, 2: {3}, 3: {3}}
>>> e = [(v, u) for u, nbrs in pred.items() for v in nbrs]

>>> # MultiGraph dict-of-dict-of-dict-of-attribute
>>> MDG = nx.MultiDiGraph()
>>> adj = {
...     1: {2: {0: {"weight": 1.3}, 1: {"weight": 1.2}}},
...     3: {2: {0: {"weight": 0.7}}},
... }
>>> e = [
...     (u, v, ekey, d)
...     for u, nbrs in adj.items()
...     for v, keydict in nbrs.items()
...     for ekey, d in keydict.items()
... ]
>>> MDG.update(edges=e)

示例

>>> G = nx.path_graph(5)
>>> G.update(nx.complete_graph(range(4, 10)))
>>> from itertools import combinations
>>> edges = (
...     (u, v, {"power": u * v})
...     for u, v in combinations(range(10, 20), 2)
...     if u * v < 225
... )
>>> nodes = [1000]  # for singleton, use a container
>>> G.update(edges, nodes)

skimage.graph#

`skimage.graph`#