Python Networkx随机几何图限制半径r内的节点

我有networkx示例中的代码，但我试图找出如何将节点限制在半径“r”内，以便在圆的边界内绘制随机几何图形。我知道在逻辑上我会怎么做，但我有点困惑每件事是如何运作的，我一直在试图自己解决它，到目前为止还没有解决方案。谢谢你的帮助

import networkx as nx
import matplotlib.pyplot as plt

G = nx.random_geometric_graph(1000,0.1)

# position is stored as node attribute data for random_geometric_graph
pos = nx.get_node_attributes(G,'pos')

# find node near center (0.5,0.5)
dmin =1
ncenter =0
for n in pos:
    x,y = pos[n]
    d = (x-0.5)**2+(y-0.5)**2
    if d<dmin:
        ncenter = n
        dmin = d

# color by path length from node near center
p = nx.single_source_shortest_path_length(G,ncenter)

plt.figure(figsize=(8,8))
#node_color=p.values()
nx.draw_networkx_edges(G,pos,nodelist=[ncenter],alpha=0.4)
nx.draw_networkx_nodes(G,pos,nodelist=p.keys(),
                   node_size=80,
                   node_color='#0F1C95',
                   cmap=plt.cm.Reds_r)

plt.xlim(-0.05,1.05)
plt.ylim(-0.05,1.05)
plt.axis('off')
plt.savefig('random_geometric_graph.png')
plt.show()

将networkx导入为nx
将matplotlib.pyplot作为plt导入
G=nx.随机几何图（1000,0.1）
#位置存储为随机几何图的节点属性数据
pos=nx.获取节点属性（G，'pos'）
#查找中心附近的节点（0.5,0.5）
dmin=1
ncenter=0
对于pos中的n：
x、 y=位置[n]
d=（x-0.5）**2+（y-0.5）**2
如果d你可以使用一个dict理解，比如

p = {node:length for node, length in nx.single_source_shortest_path_length(G,ncenter).items()
     if length < 5}


你也可以替换

dmin =1
ncenter =0
for n in pos:
    x,y = pos[n]
    d = (x-0.5)**2+(y-0.5)**2
    if d<dmin:
        ncenter = n
        dmin = d


要仅绘制距离
ncenter
小于5的节点，请定义子图：

H = G.subgraph(p.keys())    
nx.draw_networkx_edges(H, pos, alpha = 0.4)
nx.draw_networkx_nodes(H, pos, node_size = 80, node_color = node_color,
                       cmap = plt.get_cmap('Reds_r'))


将networkx导入为nx
将matplotlib.pyplot作为plt导入
G=nx.随机几何图（1000，0.1）
#位置存储为随机几何图的节点属性数据
pos=nx.获取节点属性（G，'pos'）
#查找中心附近的节点（0.5,0.5）
ncenter，=min（pos.items（），key=lambda（node，（x，y））：（x-0.5）**2+（y-0.5）**2）
#从靠近中心的节点按路径长度设置颜色
p={node:length
对于节点，长度以nx为单位。单源最短路径长度（G，ncenter）。项（）
如果长度<5}
plt.图（figsize=（8,8））
节点颜色=p.值（）
H=G.子图（p.键（））
nx.绘制网络x_边（H，位置，α=0.4）
nx.绘制网络x节点（H，位置，节点大小=80，节点颜色=节点颜色，
cmap=plt.get\u cmap（'Reds\u r'））
plt.xlim（-0.05,1.05）
plt.ylim（-0.05,1.05）
打印轴（“关闭”）
plt.savefig（'random\u geometric\u graph.png'））
plt.show（）

一个问题的答案
可用于更有效地执行此操作，例如

import numpy as np
from scipy import spatial
import networkx as nx
import matplotlib.pyplot as plt
n = 100
radius = 0.4
# random sample n points in disc using rejection
positions =  np.random.uniform(low=-radius, high=radius, size=(n*2.0,2))
disc = np.array([p for p in positions if np.linalg.norm(p) < radius][0:n])
# kdtree data structure of points in disc
kdtree = spatial.KDTree(disc)
# make graph
G = nx.Graph()
G.add_nodes_from(range(n))
r = 0.1 # connect nodes if distance < r
pairs = kdtree.query_pairs(r)
G.add_edges_from(list(pairs))
# draw
pos = dict(zip(range(n),disc))
nx.draw(G,pos,with_labels=False,node_size=25)
circ=plt.Circle((0,0),radius=radius,alpha=0.1)
ax=plt.gca()
plt.axis('equal')
ax.add_patch(circ)
plt.savefig('disc.png')
plt.show()

将numpy导入为np
从scipy导入空间
将networkx导入为nx
将matplotlib.pyplot作为plt导入
n=100
半径=0.4
#使用拒收法在圆盘中随机抽取n个点
位置=np.随机.均匀（低=半径，高=半径，大小=（n*2.0,2））
disc=np.数组（[p表示位置中的p，如果np.linalg.norm（p）<半径][0:n]）
#光盘中点的kdtree数据结构
kdtree=spatial.kdtree（光盘）
#作图
G=nx.Graph（）
G.add_nodes_from（范围（n））
r=0.1#如果距离小于r，则连接节点
pairs=kdtree.query\u pairs（r）
G.从（列表（对））中添加边
#画
pos=dict（压缩（范围n，光盘））
nx.绘图（G，位置，带标签=False，节点大小=25）
圆=圆（（0,0），半径=半径，α=0.1）
ax=plt.gca（）
plt.轴（“相等”）
ax.添加补丁（循环）
plt.savefig（'disc.png'））
plt.show（）

谢谢！这很有帮助。如果只想在半径内绘制边，该怎么办？重写原始的随机几何图函数会更有效吗？
H = G.subgraph(p.keys())    
nx.draw_networkx_edges(H, pos, alpha = 0.4)
nx.draw_networkx_nodes(H, pos, node_size = 80, node_color = node_color,
                       cmap = plt.get_cmap('Reds_r'))

import networkx as nx
import matplotlib.pyplot as plt
G = nx.random_geometric_graph(1000, 0.1)

# position is stored as node attribute data for random_geometric_graph
pos = nx.get_node_attributes(G, 'pos')

# find node near center (0.5,0.5)
ncenter, _ = min(pos.items(), key = lambda (node, (x, y)): (x-0.5)**2+(y-0.5)**2)

# color by path length from node near center
p = {node:length
     for node, length in nx.single_source_shortest_path_length(G, ncenter).items()
     if length < 5}

plt.figure(figsize = (8, 8))
node_color = p.values()
H = G.subgraph(p.keys())    
nx.draw_networkx_edges(H, pos, alpha = 0.4)
nx.draw_networkx_nodes(H, pos, node_size = 80, node_color = node_color,
                       cmap = plt.get_cmap('Reds_r'))

plt.xlim(-0.05, 1.05)
plt.ylim(-0.05, 1.05)
plt.axis('off')
plt.savefig('random_geometric_graph.png')
plt.show()

import numpy as np
from scipy import spatial
import networkx as nx
import matplotlib.pyplot as plt
n = 100
radius = 0.4
# random sample n points in disc using rejection
positions =  np.random.uniform(low=-radius, high=radius, size=(n*2.0,2))
disc = np.array([p for p in positions if np.linalg.norm(p) < radius][0:n])
# kdtree data structure of points in disc
kdtree = spatial.KDTree(disc)
# make graph
G = nx.Graph()
G.add_nodes_from(range(n))
r = 0.1 # connect nodes if distance < r
pairs = kdtree.query_pairs(r)
G.add_edges_from(list(pairs))
# draw
pos = dict(zip(range(n),disc))
nx.draw(G,pos,with_labels=False,node_size=25)
circ=plt.Circle((0,0),radius=radius,alpha=0.1)
ax=plt.gca()
plt.axis('equal')
ax.add_patch(circ)
plt.savefig('disc.png')
plt.show()