def test_csgraph_from_dense():
np.random.seed(1234)
G = np.random.random((10, 10))
some_nulls = (G < 0.4)
all_nulls = (G < 0.8)
for null_value in [0, np.nan, np.inf]:
G[all_nulls] = null_value
olderr = np.seterr(invalid="ignore")
try:
G_csr = csgraph_from_dense(G, null_value=0)
finally:
np.seterr(**olderr)
G[all_nulls] = 0
assert_array_almost_equal(G, G_csr.toarray())
for null_value in [np.nan, np.inf]:
G[all_nulls] = 0
G[some_nulls] = null_value
olderr = np.seterr(invalid="ignore")
try:
G_csr = csgraph_from_dense(G, null_value=0)
finally:
np.seterr(**olderr)
G[all_nulls] = 0
assert_array_almost_equal(G, G_csr.toarray())
def main():
import heapq
import sys
input = sys.stdin.buffer.readline
N, M, L = map(int, input().split())
G = [[-1] * N for i in range(N)]
for i in range(M):
A, B, C = map(int, input().split())
A -= 1
B -= 1
G[A][B] = C
G[B][A] = C
g = csgraph_from_dense(G, null_value=-1)
D = dijkstra(g)
G2 = [[-1] * N for i in range(N)]
for i in range(N):
for j in range(N):
if D[i][j] >= 0 and D[i][j] <= L:
G2[i][j] = 1
g2 = csgraph_from_dense(G2, null_value=-1)
D = dijkstra(g2)
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
s -= 1
t -= 1
if D[s][t] <= N**2:
print(int(D[s][t]) - 1)
else:
print(-1)
def test_strong_connections():
X1de = np.array([[0, 1, 0],
[0, 0, 0],
[0, 0, 0]])
X2de = X1de + X1de.T
X1sp = csgraph.csgraph_from_dense(X1de, null_value=0)
X2sp = csgraph.csgraph_from_dense(X2de, null_value=0)
for X in X1sp, X1de:
n_components, labels =\
csgraph.connected_components(X, directed=True,
connection='strong')
assert_equal(n_components, 3)
labels.sort()
assert_array_almost_equal(labels, [0, 1, 2])
for X in X2sp, X2de:
n_components, labels =\
csgraph.connected_components(X, directed=True,
connection='strong')
assert_equal(n_components, 2)
labels.sort()
assert_array_almost_equal(labels, [0, 0, 1])
def test_csgraph_from_dense():
np.random.seed(1234)
G = np.random.random((10, 10))
some_nulls = (G < 0.4)
all_nulls = (G < 0.8)
for null_value in [0, np.nan, np.inf]:
G[all_nulls] = null_value
olderr = np.seterr(invalid="ignore")
try:
G_csr = csgraph_from_dense(G, null_value=0)
finally:
np.seterr(**olderr)
G[all_nulls] = 0
assert_array_almost_equal(G, G_csr.toarray())
for null_value in [np.nan, np.inf]:
G[all_nulls] = 0
G[some_nulls] = null_value
olderr = np.seterr(invalid="ignore")
try:
G_csr = csgraph_from_dense(G, null_value=0)
finally:
np.seterr(**olderr)
G[all_nulls] = 0
assert_array_almost_equal(G, G_csr.toarray())
def test_strong_connections():
X1de = np.array([[0, 1, 0],
[0, 0, 0],
[0, 0, 0]])
X2de = X1de + X1de.T
X1sp = csgraph.csgraph_from_dense(X1de, null_value=0)
X2sp = csgraph.csgraph_from_dense(X2de, null_value=0)
for X in X1sp, X1de:
n_components, labels =\
csgraph.connected_components(X, directed=True,
connection='strong')
assert_equal(n_components, 3)
labels.sort()
assert_array_almost_equal(labels, [0, 1, 2])
for X in X2sp, X2de:
n_components, labels =\
csgraph.connected_components(X, directed=True,
connection='strong')
assert_equal(n_components, 2)
labels.sort()
assert_array_almost_equal(labels, [0, 0, 1])
def dijkstra(self, graph_dense, s_i, s_j, t_i, t_j):
"""
Performs a graph search for source and target
graph_dense : dense graph retpresentation of the costmap
s_i, s_j : source coordinate on the costmap
t_i, t_j : target coordinate on the costmap
"""
source_id = self.graph_id(s_i, s_j)
target_id = self.graph_id(t_i, t_j)
graph_sparse = csgraph.csgraph_from_dense(graph_dense)
dist_matrix, predecessors = csgraph.dijkstra(
graph_sparse,
directed=not self.average_cost,
return_predecessors=True,
indices=source_id,
limit=np.inf)
path = []
path.append((t_i, t_j))
while True:
target_id_bkp = target_id
target_id = predecessors[target_id]
t_i, t_j = self.costmap_id(target_id)
s_i, s_j = self.costmap_id(target_id_bkp)
path.append((t_i, t_j))
if source_id == target_id:
break
return path
def _compute_adjacency_matrix(self, indexes):
"""
Construct the adjacency graph over all segments
:return:
:rtype: sp.csr_matrix
"""
if indexes:
segs = [self.segments[i] for i in indexes]
else:
segs = self.segments
# Generate an empty, N x N sparse graph
node_count = len(segs)
g_sparse = np.zeros((node_count, node_count), dtype=float)
# Generate all pairs of segments
segment_pairs = itertools.combinations(range(node_count), 2)
# Fill the graph with the distances between segments
for src, dst in segment_pairs:
src_pos = segs[src].location.nd
dst_pos = segs[dst].location.nd
distance = np.linalg.norm(src_pos - dst_pos)
g_sparse[src, dst] = distance
g_sparse = sp.csgraph_from_dense(g_sparse)
return g_sparse
def stitch(stack, numpix_threshold=0):
from scipy.sparse.csgraph import csgraph_from_dense, connected_components
nonzero_idx = np.any(stack, axis=2)
# get unique label combinations across stacks
labels_to_combine = np.unique(stack[nonzero_idx], axis=0)
conn_mat = np.zeros(
(labels_to_combine.max() + 1, labels_to_combine.max() + 1),
dtype='bool')
for row, label_combo in enumerate(labels_to_combine):
group = label_combo[np.nonzero(label_combo)]
for i in range(len(group) - 1):
for j in range(i + 1, len(group)):
conn_mat[group[i], group[j]] = True
conn_mat[group[j], group[i]] = True
np.fill_diagonal(conn_mat, True)
graph = csgraph_from_dense(conn_mat)
n_conncomp, graph_complabels = connected_components(graph, directed=False)
result = np.zeros_like(stack[:, :, 0])
for label in np.unique(stack):
mask = np.any(stack == label, axis=2)
if mask.sum() > numpix_threshold:
result[np.any(stack == label, axis=2)] = graph_complabels[label]
return result
def __find_cc_of_synapses(synapses, dist_threshold, skeleton=None):
points = np.array([syn.location_post for syn in synapses])
if skeleton is None:
dists = np.sqrt(((points.reshape(-1, 1, 3) -
points.reshape(1, -1, 3))**2).sum(axis=2))
else:
tree_node_ids = get_closest_treenode_ids(points, skeleton)
dists = np.zeros((len(synapses), len(synapses)))
for i, node_a in enumerate(tree_node_ids):
for j, node_b in enumerate(tree_node_ids):
dist = navis.graph_utils.dist_between(skeleton, node_a, node_b)
dists[i, j] = dist if dist != 0 else -1
# it is a symmetric matrix, remove redundancy
dists *= np.tri(*dists.shape)
dists[dists > dist_threshold] = np.NaN
dists[dists ==
0] = np.NaN # half of matrix set to np.nan to account for redundancy
dists[dists ==
-1] = 0 # Those distances that are actually 0, were marked with -1
sparsematrix = csgraph_from_dense(dists, null_value=np.NAN)
num_cc, labels = connected_components(sparsematrix, directed=False)
clusters_of_indeces = []
for label in np.unique(labels):
clusters_of_indeces.append(list(np.where(labels == label)[0]))
clustered_synapses = []
for cluster in clusters_of_indeces:
if len(cluster) > 1:
cluster = [synapses[ind] for ind in cluster]
clustered_synapses.append(cluster)
return clustered_synapses
def get_comp_freqs(adj, rel_freq):
sparseMatrix = csgraph_from_dense(adj)
connected = connected_components(sparseMatrix,
directed=False,
connection='weak',
return_labels=True)
comp_num = connected[0]
comp_list = connected[1]
comps_freqlist = np.zeros(comp_num)
comps_info = []
for i in range(comp_num):
comps_info.append([])
for i in range(len(rel_freq)):
freq = rel_freq[i]
comp = comp_list[i]
comps_freqlist[comp] += freq
comps_info[comp].append(i)
# print(i,freq)
max_comp = max(comps_freqlist)
# print(comp_list)
# print(comps_freqlist)
# print(comps_info)
# if list(comps_freqlist).count(max_comp)!=1:
# print(comps_freqlist)
# exit('ambiguous as to which component is biggest! Investigate')
# print('biggest comp percentage='+str(max_comp*100)+'%')
return comps_freqlist, list(comps_freqlist).index(max_comp), comps_info
def build_cluster_graph(self):
cluster_graph = collections.defaultdict(list)
for cluster in self.sim.clusters:
other_clusters = list(self.sim.clusters)
other_clusters.remove(cluster)
for other_cluster in other_clusters:
overlaps = set(cluster.tour.objects).intersection(
other_cluster.tour.objects)
if len(overlaps) > 0:
cluster_graph[cluster].append(other_cluster)
node_count = len(self.sim.clusters)
dense = np.zeros((node_count, node_count), dtype=float)
for cluster, neighbors in cluster_graph.items():
cluster_index = self.sim.clusters.index(cluster)
for neighbor in neighbors:
neighbor_index = self.sim.clusters.index(neighbor)
dense[cluster_index, neighbor_index] = 1
dense[neighbor_index, cluster_index] = 1
sparse = sp.csgraph_from_dense(dense)
return sparse
def join_clusters(self):
# Generate an empty, N x N sparse graph
node_count = len(self.clusters)
dense = np.zeros((node_count, node_count), dtype=float)
expand = {}
cluster_pairs = itertools.combinations(self.clusters, 2)
for cluster_pair in cluster_pairs:
weights, segs = self.compute_edge_weights(*cluster_pair)
c1_index = self.clusters.index(cluster_pair[0])
c2_index = self.clusters.index(cluster_pair[1])
dense[c1_index, c2_index] = weights[0]
dense[c2_index, c1_index] = weights[1]
expand[(c1_index, c2_index)] = segs[1]
expand[(c2_index, c1_index)] = segs[0]
sparse = sp.csgraph_from_dense(dense)
mst = sp.minimum_spanning_tree(sparse)
edges = mst.nonzero()
edges = zip(edges[0], edges[1])
for edge in edges:
cluster = self.clusters[edge[0]]
cluster.add(expand[edge])
cluster.intersections.append(self.clusters[edge[1]])
def create_data_model():
"""Stores the data for the problem."""
cities_map = create_cities_map()
path_DB = cities_map.get_path('D', 'B')
G2_data = np.array([[np.inf, np.inf, 1, np.inf, np.inf],
[np.inf, np.inf, 1, 2, 0],
[np.inf, 1, np.inf, np.inf, np.inf],
[np.inf, 2, np.inf, np.inf, np.inf],
[0, np.inf, np.inf, np.inf, np.inf]])
G2_data = cities_map.adjacency_matrix
G2_sparse = csgraph_from_dense(G2_data, null_value=CitiesMap.NAN_VALUE)
dist_matrix, predecessors = floyd_warshall(csgraph=G2_sparse,
directed=True,
return_predecessors=True)
data = {}
data['distance_matrix'] = dist_matrix
data['num_vehicles'] = 1
data['depot'] = cities_map.city_name_to_idx(cities_map.route_city_end)
return data, predecessors, cities_map
def main():
from scipy.sparse.csgraph import dijkstra, csgraph_from_dense
n, m = map(int, input().split())
s, t = map(int, input().split())
s -= 1
t -= 1
g = [[-1] * n for i in range(n)]
for i in range(m):
x, y, d = map(int, input().split())
x -= 1
y -= 1
g[x][y] = d
g[y][x] = d
G = csgraph_from_dense(g, null_value=-1)
sd = dijkstra(G, indices=s)
td = dijkstra(G, indices=t)
ans = -1
for i, xy in enumerate(zip(sd, td)):
x, y = xy
if x == y and x <= 1000:
ans = i + 1
break
print(ans)
def test_error_handling(self):
with np.testing.assert_raises(TypeError):
sp.seed_competition(self.seeds, image=0)
with np.testing.assert_raises(TypeError):
sp.seed_competition(self.seeds.flatten(), graph=0)
with np.testing.assert_raises(TypeError):
sp.dynamic_arc_weight(self.seeds, image=0)
with np.testing.assert_raises(ValueError):
sp.seed_competition(self.seeds, np.ones(self.seeds.size))
with np.testing.assert_raises(ValueError):
sp.dynamic_arc_weight(self.seeds, np.ones(self.seeds.size))
with np.testing.assert_raises(ValueError):
sp.seed_competition(self.seeds)
with np.testing.assert_raises(ValueError):
sp.seed_competition(self.seeds, image=self.image,
graph=csgraph.csgraph_from_dense(self.image))
with np.testing.assert_raises(ValueError):
sp.dynamic_arc_weight(self.seeds, self.image, alpha=-1.0)
with np.testing.assert_raises(ValueError):
sp.dynamic_arc_weight(self.seeds, self.image, mode='fake')
def process_component(only_seqs, only_freqs, component, comps_info, adj,
dists):
nodes_real_names = comps_info[component]
adj_comp, comp_size = smaller_adj(adj, nodes_real_names)
sparseMatrixComp = csgraph_from_dense(adj_comp)
path_dists = shortest_path(sparseMatrixComp,
method='auto',
directed=False,
return_predecessors=False,
unweighted=True,
overwrite=False)
links = []
for p in range(comp_size - 1):
for q in range(p + 1, comp_size):
realp = nodes_real_names[p]
realq = nodes_real_names[q]
s = [
p, q, dists[realp, realq], adj_comp[p][q], path_dists[p][q],
only_freqs[realp], only_freqs[realq]
]
links.append(s)
comp_seqs = {}
for k in nodes_real_names:
seq = str(only_seqs[k])
freq = only_freqs[k]
comp_seqs[seq] = freq
return links, comp_seqs, adj_comp, comp_size
def graphme(TransNet, fileList, output): #plots nx graph
sparse_graph = csgraph_from_dense(TransNet)
graph_obj = nx.from_scipy_sparse_matrix(sparse_graph,
create_using=nx.DiGraph())
nodeLabels = {}
edgeLabels = {}
for node in graph_obj.node:
#------------------------------------------------------------------------------------------
#this part generates names using some regex grab from your file names for cleaner charts
#for no regex, use
nodeLabels[node] = fileList[node]
#or match the unique part of your filename and use that instead of the full name (below)
# name=re.findall('.*_clipped/(.*)_unique.*',fileList[node])
# nodeLabels[node]=name
# name=re.findall('(.*).*',fileList[node])
# nodeLabels[node]=name
#------------------------------------------------------------------------------------------
edgeListIterator = 0
for edge in sparse_graph.data:
edgeLabels[graph_obj.edges()[edgeListIterator]] = str(edge)
edgeListIterator += 1
pos = nx.shell_layout(graph_obj, dim=2)
nx.draw_networkx_nodes(graph_obj, pos, node_shape="s")
nx.draw_networkx_edges(graph_obj, pos, arrows=True)
nx.draw_networkx_labels(graph_obj, pos, labels=nodeLabels)
nx.draw_networkx_edge_labels(graph_obj, pos, edge_labels=edgeLabels)
plt.axis('off')
plt.savefig(output)
def localEfficiencyCalc(GL):
nodeNum = len(GL)
localEfficiency = 0
if nodeNum > 1:
local1 = []
for boxName in nx.nodes_iter(GL):
radiusNodeList = GL.neighbors(boxName)
boxNet = nx.Graph(GL.subgraph(radiusNodeList))
boxNodes = len(boxNet)
boxMat = nx.to_numpy_matrix(boxNet)
boxSparse = csgraph_from_dense(boxMat)
boxMatPath = shortest_path(boxSparse, method='auto', directed=False, return_predecessors=False, unweighted=True, overwrite=False)
boxPathList = []
for i in range(boxNodes-1):
for j in range(i+1, boxNodes):
tempDist = boxMatPath[i][j]
if np.isfinite(tempDist):
boxPathList.append(np.divide(1, tempDist, dtype = float))
if len(boxPathList) > 0:
local1.append(np.mean(boxPathList))
else:
local1.append(0)
localEfficiency = np.mean(local1)
return localEfficiency
def calcDistances(haploNum, haploSize,
ordSeqs): #Calculate hamming distances between sequences
compNum = haploSize
compList = range(haploNum)
t = 0
adjMatrix = np.zeros((haploNum, haploNum))
kStepList = []
while compNum > 1:
t = t + 1
# Check each query sequence
for r1 in range(haploNum - 1):
haplotype1 = ordSeqs[r1]
for r2 in range(r1 + 1, haploNum):
if compList[r1] != compList[r2]:
haplotype2 = ordSeqs[r2]
tempDist = 0
for a, b in izip(haplotype1, haplotype2):
if a != b:
tempDist = tempDist + 1
if tempDist > t:
break
if tempDist == t:
adjMatrix[r1][r2] = 1
kStepList.append([r1, r2, t])
# Calculate components
sparseMatrix = csgraph_from_dense(adjMatrix)
connected = connected_components(sparseMatrix,
directed=False,
connection='weak',
return_labels=True)
compNum = connected[0]
compList = connected[1]
return kStepList
def inferTransNetFromEvolTimes(DSamp, failtime):
# print(DSamp)
# raw_input("press enter to continue")
numFiles = len(DSamp)
AMSamp = np.eye(numFiles)
for u in range(numFiles):
for v in range(u + 1, numFiles):
if DSamp[u, v] <= DSamp[v, u]:
if DSamp[u, v] < failtime - 20:
AMSamp[u, v] = 1
else:
if DSamp[v, u] < failtime - 20:
AMSamp[v, u] = 1
sparseMatrix = csgraph_from_dense(AMSamp)
connected = connected_components(sparseMatrix,
directed=False,
connection='weak',
return_labels=True)
S = connected[0]
C = connected[1]
transNets = []
for c in range(S):
tmp = np.where(C == c)
comp = tmp[0]
if len(comp) > 1:
DSamp_comp = reduceMat(DSamp, comp)
transNetsComp = findTransNetMCMC(DSamp_comp, failtime)
try:
transNets.append(transNetsComp[0])
except TypeError:
transNets.append(transNetsComp)
TransNet = transNets[0]
return TransNet
def _compute_adjacency_matrix(self, indexes):
"""
Construct the adjacency graph over all segments
:return:
:rtype: sp.csr_matrix
"""
if indexes:
segs = [self.segments[i] for i in indexes]
else:
segs = self.segments
# Generate an empty, N x N sparse graph
node_count = len(segs)
g_sparse = np.zeros((node_count, node_count), dtype=float)
# Generate all pairs of segments
segment_pairs = itertools.combinations(range(node_count), 2)
# Fill the graph with the distances between segments
for src, dst in segment_pairs:
src_pos = segs[src].location.nd
dst_pos = segs[dst].location.nd
distance = np.linalg.norm(src_pos - dst_pos)
g_sparse[src, dst] = distance
g_sparse = sp.csgraph_from_dense(g_sparse)
return g_sparse
def merge_cells(self):
"""
Find connected cells between multiple inferences and merge strongly connected
cells that have overlap more than a threshold.
"""
self.build_connectivity_matrix()
print("Connectivity matrix built")
#Filter out week connections
self.conn_matrix[self.conn_matrix < self.threshold] = 0
#Get connected components
np.fill_diagonal(self.conn_matrix, 1)
from scipy.sparse.csgraph import csgraph_from_dense, connected_components
graph = csgraph_from_dense(self.conn_matrix)
n_conn_comp, graph_labels = connected_components(graph, True)
print(self.conn_matrix.shape)
print(n_conn_comp)
print(graph_labels.shape)
print(type(graph_labels))
#Convert all labels to their group:
updated_labels = graph_labels[self.stack]
print("applied lookup")
print(updated_labels.shape)
self.masks = np.max(updated_labels, 2)
return self.masks
def calcKstep(haploNum, haploSize,
seqs): #Calculate hamming distances between sequences
ordSeqs = seqs.keys()
colors = []
compNum = haploSize
compList = range(haploNum)
t = 0
adjMatrix = np.zeros((haploNum, haploNum))
kStepList = []
while compNum > 1:
t = t + 1
# Check each query sequence
for r1 in range(haploNum - 1):
haplotype1 = ordSeqs[r1]
for r2 in range(r1 + 1, haploNum):
if compList[r1] != compList[r2]:
haplotype2 = ordSeqs[r2]
tempDist = 0
for a, b in izip(haplotype1, haplotype2):
if a != b:
tempDist = tempDist + 1
if tempDist > t:
break
if tempDist == t:
adjMatrix[r1][r2] = 1
# seqs[ordSeqs[r1]]
kStepList.append(
[seqs[ordSeqs[r1]], seqs[ordSeqs[r2]], t])
if seqs[ordSeqs[r1]] not in colors:
colors.append(seqs[ordSeqs[r1]])
if seqs[ordSeqs[r2]] not in colors:
colors.append(seqs[ordSeqs[r2]])
# Calculate components
sparseMatrix = csgraph_from_dense(adjMatrix)
connected = connected_components(sparseMatrix,
directed=False,
connection='weak',
return_labels=True)
compNum = connected[0]
compList = connected[1]
if t / haploSize > .42:
if sum(compList) == 1:
offender = ordSeqs[np.argmax(compList)]
splitname = seqs[offender].split("_")
if splitname[0] == "1":
f1counter -= 1
elif splitname[0] == "2":
f2counter -= 1
else:
both -= 1
del seqs[offender]
altwrapper(seqs, colors, haploNum - 1, haploSize, f1counter,
f2counter, both, output, drawmode)
sys.exit()
else:
sys.exit(
"FATAL ERROR: Your output will contain disconnected components at an unreconcilable distance from one another. Exiting"
)
return kStepList, colors, t
def _subgroups(edges):
graph = _matrix_from_edges(edges)
n_comp, comp = connected_components(csgraph_from_dense(graph), directed=False)
if n_comp < 2: return [edges]
groups = [[] for _n in xrange(n_comp)]
for edge in edges: groups[comp[edge[0]]].append(edge)
groups = [group for group in groups if group]
return groups
def test_csgraph_from_dense():
G = np.random.random((10, 10))
some_nulls = (G < 0.4)
all_nulls = (G < 0.8)
for null_value in [0, np.nan, np.inf]:
G[all_nulls] = null_value
G_csr = csgraph_from_dense(G, null_value=0)
G[all_nulls] = 0
assert_array_almost_equal(G, G_csr.toarray())
for null_value in [np.nan, np.inf]:
G[all_nulls] = 0
G[some_nulls] = null_value
G_csr = csgraph_from_dense(G, null_value=0)
G[all_nulls] = 0
assert_array_almost_equal(G, G_csr.toarray())
def test_csgraph_from_dense():
G = np.random.random((10, 10))
some_nulls = (G < 0.4)
all_nulls = (G < 0.8)
for null_value in [0, np.nan, np.inf]:
G[all_nulls] = null_value
G_csr = csgraph_from_dense(G, null_value=0)
G[all_nulls] = 0
assert_array_almost_equal(G, G_csr.toarray())
for null_value in [np.nan, np.inf]:
G[all_nulls] = 0
G[some_nulls] = null_value
G_csr = csgraph_from_dense(G, null_value=0)
G[all_nulls] = 0
assert_array_almost_equal(G, G_csr.toarray())
def stitch(stack, numpix_threshold=0):
'''
Combine multiple instance segmentations based on overlapping patches into a single
segmentation
Args
----
stack : np.ndarray
first two dimensions of stack should be the dimensions of the input image,
and the third dimension be the number of overlapping patches
numpix_threshold : int
a label will be retained in the output only if it has at least
numpix_threshold pixels
Returns
-------
result : numpy.ndarray
a 2-D array labels
'''
from scipy.sparse.csgraph import csgraph_from_dense, connected_components
# find foreground labels
nonzero_idx = np.any(stack,axis=2)
# get unique label combinations across patches in stack
labels_to_combine = np.unique(stack[nonzero_idx],axis=0)
# compute a "connectivity matrix" that indicates which labels overlap across patches
conn_mat = np.zeros((labels_to_combine.max()+1,labels_to_combine.max()+1), dtype='bool')
for row, label_combo in enumerate(labels_to_combine):
group = label_combo[np.nonzero(label_combo)]
for i in range(len(group)-1):
for j in range(i+1,len(group)):
conn_mat[group[i], group[j]] = True
conn_mat[group[j], group[i]] = True
#np.fill_diagonal(conn_mat, True)
# find connected components using this connectivity matrix
# each connected component will be a different label in the result (as long as it
# contains the minimum required number of pixels)
graph = csgraph_from_dense(conn_mat)
n_conncomp, graph_complabels = connected_components(graph, directed=False)
result = np.zeros_like(stack[:,:,0])
# reassign labels to the ids of the connected components
for label in np.unique(stack):
# get 2-D mask of voxels with a given label
mask = np.any(stack==label,axis=2)
# make sure that there are enough many pixels
if mask.sum() > numpix_threshold:
# if so, reassign this label to its corresponding connected component id
result[np.any(stack==label,axis=2)] = graph_complabels[label]
return result
def create_graph(bag_rules):
num_bags = len(bag_rules)
bags = list(bag_rules.keys())
g_dense = np.zeros((num_bags, num_bags), dtype=np.int64)
for i, rule in enumerate(bag_rules.values()):
for bg, num in rule.items():
g_dense[i, bags.index(bg)] = num
return csgraph.csgraph_from_dense(g_dense).astype(np.int64)
def test_graph_depth_first_trivial_graph():
csgraph = np.array([[0]])
csgraph = csgraph_from_dense(csgraph, null_value=0)
bfirst = np.array([[0]])
for directed in [True, False]:
bfirst_test = depth_first_tree(csgraph, 0, directed)
assert_array_almost_equal(csgraph_to_dense(bfirst_test), bfirst)
def shortest_paths(graph_dense):
graph_sparse = csgraph.csgraph_from_dense(graph_dense)
# print graph_sparse
# print graph_sparse.shape
dist_matrix, predecessors = csgraph.shortest_path(graph_sparse,
directed=False,
return_predecessors=True)
# print predecessors
return predecessors
def calcDistances(haploNum, haploSize,
asdf): #Calculate hamming distances between sequences
ordSeqs = asdf.keys()
# for seq in ordSeqs:
# print(seq,asdf[seq])
colors = []
compNum = haploSize
compList = range(haploNum)
t = 0
adjMatrix = np.zeros((haploNum, haploNum))
kStepList = []
while compNum > 1:
t = t + 1
# Check each query sequence
for r1 in range(haploNum - 1):
haplotype1 = ordSeqs[r1]
for r2 in range(r1 + 1, haploNum):
if compList[r1] != compList[r2]:
haplotype2 = ordSeqs[r2]
tempDist = 0
for a, b in izip(haplotype1, haplotype2):
if a != b:
tempDist = tempDist + 1
if tempDist > t:
break
if tempDist == t:
adjMatrix[r1][r2] = 1
asdf[ordSeqs[r1]]
kStepList.append(
[asdf[ordSeqs[r1]], asdf[ordSeqs[r2]], t])
if asdf[ordSeqs[r1]] not in colors:
colors.append(asdf[ordSeqs[r1]])
if asdf[ordSeqs[r2]] not in colors:
colors.append(asdf[ordSeqs[r2]])
# Calculate components
sparseMatrix = csgraph_from_dense(adjMatrix)
connected = connected_components(sparseMatrix,
directed=False,
connection='weak',
return_labels=True)
compNum = connected[0]
compList = connected[1]
# print(compNum)
# print(compList)
# print(t)
# print("=")
if t / haploSize > .42:
if sum(compList) == 1:
offender = ordSeqs[np.argmax(compList)]
del asdf[offender]
altwrapper(asdf, colors, haploNum - 1, haploSize)
sys.exit()
else:
sys.exit(
"Your output is going to look really messed up. Exiting")
return kStepList, colors
def test_csgraph_to_dense():
G = np.random.random((10, 10))
nulls = (G < 0.8)
G[nulls] = np.inf
G_csr = csgraph_from_dense(G)
for null_value in [0, 10, -np.inf, np.inf]:
G[nulls] = null_value
assert_array_almost_equal(G, csgraph_to_dense(G_csr, null_value))
def test_weak_connections():
Xde = np.array([[0, 1, 0], [0, 0, 0], [0, 0, 0]])
Xsp = csgraph.csgraph_from_dense(Xde, null_value=0)
for X in Xsp, Xde:
n_components, labels = csgraph.connected_components(X, directed=True, connection="weak")
assert_equal(n_components, 2)
assert_array_almost_equal(labels, [0, 0, 1])
def test_csgraph_to_dense():
G = np.random.random((10, 10))
nulls = (G < 0.8)
G[nulls] = np.inf
G_csr = csgraph_from_dense(G)
for null_value in [0, 10, -np.inf, np.inf]:
G[nulls] = null_value
assert_array_almost_equal(G, csgraph_to_dense(G_csr, null_value))
def _subgroups(edges):
graph = _matrix_from_edges(edges)
n_comp, comp = connected_components(csgraph_from_dense(graph),
directed=False)
if n_comp < 2: return [edges]
groups = [[] for _n in xrange(n_comp)]
for edge in edges:
groups[comp[edge[0]]].append(edge)
groups = [group for group in groups if group]
return groups
def graph(self):
'''Map elements of the kernel related to one another through fluctuations as a graph'''
k_size = len(self.kernel)
kernel_sig = map(self.signature, self.kernel)
adj = np.zeros([k_size, k_size])
for r, u in enumerate(self.kernel):
accessible = self.sim_anneal(u)
for w_sig in map(self.signature, accessible):
adj[r, kernel_sig.index(w_sig)] = 1
return csgraph.csgraph_from_dense(adj)
def test_graph_depth_first_trivial_graph():
csgraph = np.array([[0]])
csgraph = csgraph_from_dense(csgraph, null_value=0)
bfirst = np.array([[0]])
for directed in [True, False]:
bfirst_test = depth_first_tree(csgraph, 0, directed)
assert_array_almost_equal(csgraph_to_dense(bfirst_test),
bfirst)
def test_graph_breadth_first():
csgraph = np.array([[0, 1, 2, 0, 0], [1, 0, 0, 0, 3], [2, 0, 0, 7, 0],
[0, 0, 7, 0, 1], [0, 3, 0, 1, 0]])
csgraph = csgraph_from_dense(csgraph, null_value=0)
bfirst = np.array([[0, 1, 2, 0, 0], [0, 0, 0, 0, 3], [0, 0, 0, 7, 0],
[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]])
for directed in [True, False]:
bfirst_test = breadth_first_tree(csgraph, 0, directed)
assert_array_almost_equal(csgraph_to_dense(bfirst_test), bfirst)
def test_graph_depth_first():
if csgraph_from_dense is None:
raise SkipTest("Old version of scipy, doesn't have csgraph.")
csgraph = np.array([[0, 1, 2, 0, 0], [1, 0, 0, 0, 3], [2, 0, 0, 7, 0], [0, 0, 7, 0, 1], [0, 3, 0, 1, 0]])
csgraph = csgraph_from_dense(csgraph, null_value=0)
dfirst = np.array([[0, 1, 0, 0, 0], [0, 0, 0, 0, 3], [0, 0, 0, 0, 0], [0, 0, 7, 0, 0], [0, 0, 0, 1, 0]])
for directed in [True, False]:
dfirst_test = depth_first_tree(csgraph, 0, directed)
assert_array_almost_equal(csgraph_to_dense(dfirst_test), dfirst)
def _compute_adjacency_matrix(self):
"""
Build out the adjacency matrix based on the paths created by the
builder. This takes the cluster paths and builds out a matrix suitable
for use in Dijkstra's algorithm.
This routine just sets the value of the self.sim attribute.
:return: None
"""
i = 0
for clust in self.sim.clusters:
for seg_vertex in clust.tour.vertices:
seg = clust.tour.objects[seg_vertex]
if seg not in self._segment_indexes:
self._segment_indexes[seg] = i
i += 1
# First we need to get the total number of segments and relay nodes so
# we can create an N x N matrix. This is simply the number of segments
# plus the number of rendezvous points. As ToCS guarantees a single
# rendezvous point per cluster, we can just use the number of clusters.
node_count = len(self.sim.segments)
g_sparse = np.zeros((node_count, node_count), dtype=float)
g_sparse[:] = np.inf
for clust in self.sim.clusters:
cluster_tour = clust.tour
i = len(cluster_tour.vertices) - 1
j = 0
while j < len(cluster_tour.vertices):
start_vertex = cluster_tour.vertices[i]
stop_vertex = cluster_tour.vertices[j]
start_pt = cluster_tour.collection_points[start_vertex]
stop_pt = cluster_tour.collection_points[stop_vertex]
distance = np.linalg.norm(stop_pt - start_pt)
start_seg = cluster_tour.objects[start_vertex]
stop_seg = cluster_tour.objects[stop_vertex]
start_index = self._segment_indexes[start_seg]
stop_index = self._segment_indexes[stop_seg]
g_sparse[start_index, stop_index] = distance
i = j
j += 1
g_sparse = sp.csgraph_from_dense(g_sparse, null_value=np.inf)
return g_sparse
def _compute_adjacency_matrix(self):
"""
Build out the adjacency matrix based on the paths created by the
builder. This takes the cluster paths and builds out a matrix suitable
for use in Dijkstra's algorithm.
:return: The adjacency matrix for the simulation
:rtype: sp.csr_matrix
"""
# Set up a quick-reference index to map cells to indexes
for i, cell in enumerate(self.sim.cells):
self._cell_indexes[cell] = i
if all([self.sim.hub.cells == [self.sim.damaged],
self.sim.damaged not in self.sim.cells]):
# Add the "damaged" virtual cell to the index if we need it
self._cell_indexes[self.sim.damaged] = len(self.sim.cells)
node_count = len(list(self._cell_indexes.keys()))
g_sparse = np.zeros((node_count, node_count), dtype=float)
g_sparse[:] = np.inf
for cluster in self.sim.clusters + [self.sim.hub]:
cluster_tour = cluster.tour
i = len(cluster_tour.vertices) - 1
j = 0
while j < len(cluster_tour.vertices):
start_vertex = cluster_tour.vertices[i]
stop_vertex = cluster_tour.vertices[j]
start_pt = cluster_tour.points[start_vertex]
stop_pt = cluster_tour.points[stop_vertex]
distance = np.linalg.norm(stop_pt - start_pt)
start_seg = cluster_tour.objects[start_vertex]
stop_seg = cluster_tour.objects[stop_vertex]
start_index = self._cell_indexes[start_seg]
stop_index = self._cell_indexes[stop_seg]
g_sparse[start_index, stop_index] = distance
i = j
j += 1
g_sparse = sp.csgraph_from_dense(g_sparse, null_value=np.inf)
return g_sparse
def test_graph_breadth_first():
csgraph = np.array([[0, 1, 2, 0, 0],
[1, 0, 0, 0, 3],
[2, 0, 0, 7, 0],
[0, 0, 7, 0, 1],
[0, 3, 0, 1, 0]])
csgraph = csgraph_from_dense(csgraph, null_value=0)
bfirst = np.array([[0, 1, 2, 0, 0],
[0, 0, 0, 0, 3],
[0, 0, 0, 7, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]])
for directed in [True, False]:
bfirst_test = breadth_first_tree(csgraph, 0, directed)
assert_array_almost_equal(csgraph_to_dense(bfirst_test),
bfirst)
def induce_type1_cascades(tuple):
entity = tuple[0]
chains = tuple[1]
# entity_posts = tuple[1]['posts']
# Get the entity posts
entity_citation_posts = entity_posts_map_broadcast.value
entity_posts = entity_citation_posts[entity]
# log the connected chains of the entity
connected_chains = []
for chain in chains:
# new chain formed by filtering the chain with only entity citing posts
# Filter the chain down to include only posts citing the entity
new_chain = set()
for chain_edge in chain:
source = chain_edge.split("->")[0]
target = chain_edge.split("->")[1]
if source in entity_posts and target in entity_posts:
new_chain.add(chain_edge)
# too inefficient, better to convert to matrix form and then run this the graph
# 1. Induce maps between node label and ids
node_to_index = {}
index_to_node = {}
index = -1
for chain_edge in new_chain:
source = chain_edge.split("->")[0]
target = chain_edge.split("->")[1]
if source not in node_to_index:
index += 1
node_to_index[source] = index
index_to_node[index] = source
if target not in node_to_index:
index += 1
node_to_index[target] = index
index_to_node[index] = target
# 2. Populate the nd matrix
dim = len(node_to_index)
if dim > 1:
M = np.zeros(shape=(dim, dim))
for chain_edge in new_chain:
source = chain_edge.split("->")[0]
source_index = node_to_index[source]
target = chain_edge.split("->")[1]
target_index = node_to_index[target]
M[source_index, target_index] = 1
# 3. Induce the connected components from the matrix
# print(str(dim))
# print(str(M))
Msp = csgraph.csgraph_from_dense(M, null_value=0)
n_components, labels = csgraph.connected_components(Msp, directed=True)
# print("Number of connected components = " + str(n_components))
# print("Components labels = " + str(labels))
# get the components and their chains
for i in range(0, n_components):
# print("Component: " + str(i))
component_chain = []
# get the nodes in that component
# print(labels)
c_nodes = [j for j in range(len(labels)) if labels.item(j) is i]
# print(c_nodes)
# Only log the component if more than two nodes are in in
if len(c_nodes) > 1:
# build the canonical edges
for source_id in c_nodes:
for target_id in c_nodes:
if int(M[(source_id, target_id)]) is 1:
component_chain.append(str(source_id) + "->" + str(target_id))
if len(component_chain) > 0:
connected_chains.append(component_chain)
canonical_chains = connected_chains
print("Canonical Chains:")
print(canonical_chains)
# return back to the function the mapping between the entity and the connected chains
return (entity, canonical_chains)
#!/usr/bin/env python
import sys
import numpy as np
from scipy.sparse.csgraph import csgraph_from_dense, connected_components
if __name__ == '__main__':
lines = sys.stdin.read().strip().split('\n')
n = int(lines[0])
m = np.zeros((n, n))
adj = [[int(x) for x in line.split(' ')] for line in lines[1:]]
for edge in adj:
m[edge[0]-1, edge[1]-1] = 1
g = csgraph_from_dense(m)
print(connected_components(g, False)[0] - 1)
def _subgroups(edges):
graph = _matrix_from_edges(edges)
n_comp, comp = connected_components(csgraph_from_dense(graph), directed=False)
if n_comp < 2: return [edges]
groups = [[] for _n in xrange(n_comp)]
for edge in edges: groups[comp[edge[0]]].append(edge)
groups = [group for group in groups if group]
return groups
#end def
edges = [[1,2], [3,4], [5,6], [1,4], [3,4], [5,2], [7,8], [8,9], [7,10]]
graph = _matrix_from_edges(edges)
print graph
components = connected_components(csgraph_from_dense(graph), directed=False)
print components
groups = _subgroups(edges)
print np.array(groups)
# from timeit import timeit
# from tests.violin_plot import violin_plot
# from matplotlib.pyplot import figure, show
#
# lfor = [timeit('''
#A = 0
#for edge in edges:
# A += edge[0]*edge[1]
# ''', 'from __main__ import edges') for _i in xrange(100)]
