def test_mcis(self):
# Example graphs from DOI: 10.1002/spe.588
graph1 = nx.Graph()
graph1.add_edges_from([(1, 2), (2, 3), (2, 4), (3, 4), (4, 5)])
graph1.nodes[1]['color'] = 0
graph2 = nx.Graph()
graph2.add_edges_from([(1, 2), (2, 3), (2, 4), (3, 4), (3, 5),
(5, 6), (5, 7), (6, 7)])
graph2.nodes[1]['color'] = 1
graph2.nodes[6]['color'] = 2
graph2.nodes[7]['color'] = 2
ismags = iso.ISMAGS(graph1, graph2, node_match=iso.categorical_node_match('color', None))
assert list(ismags.subgraph_isomorphisms_iter(True)) == []
assert list(ismags.subgraph_isomorphisms_iter(False)) == []
found_mcis = _matches_to_sets(ismags.largest_common_subgraph())
expected = _matches_to_sets([{2: 2, 3: 4, 4: 3, 5: 5},
{2: 4, 3: 2, 4: 3, 5: 5}])
assert expected == found_mcis
ismags = iso.ISMAGS(graph2, graph1, node_match=iso.categorical_node_match('color', None))
assert list(ismags.subgraph_isomorphisms_iter(True)) == []
assert list(ismags.subgraph_isomorphisms_iter(False)) == []
found_mcis = _matches_to_sets(ismags.largest_common_subgraph())
# Same answer, but reversed.
expected = _matches_to_sets([{2: 2, 3: 4, 4: 3, 5: 5},
{4: 2, 2: 3, 3: 4, 5: 5}])
assert expected == found_mcis
def max_comp_element_alg(nodes, graph, comp_graph, max_arr):
em = isomorphism.categorical_edge_match('colour', '')
nm = isomorphism.categorical_node_match('text', '')
GM = isomorphism.DiGraphMatcher(comp_graph,
graph,
node_match=nm,
edge_match=em)
if GM.subgraph_is_isomorphic():
max_arr.append(graph)
else:
for obj in nodes['children']:
new_graph = copy.deepcopy(graph)
curr_graph = del_nodes(new_graph, obj['_id'], nodes)
em = isomorphism.categorical_edge_match('colour', '')
nm = isomorphism.categorical_node_match('text', '')
GM = isomorphism.DiGraphMatcher(comp_graph,
curr_graph,
node_match=nm,
edge_match=em)
if GM.subgraph_is_isomorphic():
max_arr.append(curr_graph)
else:
curr_graph.remove_edge(nodes['_id'], obj['_id'])
curr_graph.remove_node(nodes['_id'])
max_comp_element_alg(obj, curr_graph, comp_graph, max_arr)
def equal_graphs(g1, g2,
node_attrs=('resid', 'resname', 'atomname', 'chain', 'charge_group', 'atype'),
edge_attrs=()):
"""
Parameters
----------
g1: networkx.Graph
g2: networkx.Graph
node_attrs: collections.abc.Iterable or None
Node attributes to consider. If `None`, the node attribute dicts must
be equal.
edge_attrs: collections.abc.Iterable or None
Edge attributes to consider. If `None`, the edge attribute dicts must
be equal.
Returns
-------
bool
True if `g1` and `g2` are isomorphic, False otherwise.
"""
if node_attrs is None:
node_equal = operator.eq
else:
node_equal = iso.categorical_node_match(node_attrs, [''] * len(node_attrs))
if edge_attrs is None:
edge_equal = operator.eq
else:
edge_equal = iso.categorical_node_match(edge_attrs, [''] * len(edge_attrs))
matcher = iso.GraphMatcher(g1, g2, node_match=node_equal, edge_match=edge_equal)
return matcher.is_isomorphic()
def test_symmetry_mcis(self):
graph1 = nx.Graph()
nx.add_path(graph1, range(4))
graph2 = nx.Graph()
nx.add_path(graph2, range(3))
graph2.add_edge(1, 3)
# Only the symmetry of graph2 is taken into account here.
ismags1 = iso.ISMAGS(graph1, graph2, node_match=iso.categorical_node_match('color', None))
assert list(ismags1.subgraph_isomorphisms_iter(True)) == []
found_mcis = _matches_to_sets(ismags1.largest_common_subgraph())
expected = _matches_to_sets([{0: 0, 1: 1, 2: 2},
{1: 0, 3: 2, 2: 1}])
assert expected == found_mcis
# Only the symmetry of graph1 is taken into account here.
ismags2 = iso.ISMAGS(graph2, graph1, node_match=iso.categorical_node_match('color', None))
assert list(ismags2.subgraph_isomorphisms_iter(True)) == []
found_mcis = _matches_to_sets(ismags2.largest_common_subgraph())
expected = _matches_to_sets([{3: 2, 0: 0, 1: 1},
{2: 0, 0: 2, 1: 1},
{3: 0, 0: 2, 1: 1},
{3: 0, 1: 1, 2: 2},
{0: 0, 1: 1, 2: 2},
{2: 0, 3: 2, 1: 1}])
assert expected == found_mcis
found_mcis1 = _matches_to_sets(ismags1.largest_common_subgraph(False))
found_mcis2 = ismags2.largest_common_subgraph(False)
found_mcis2 = [{v: k for k, v in d.items()} for d in found_mcis2]
found_mcis2 = _matches_to_sets(found_mcis2)
expected = _matches_to_sets([{3: 2, 1: 3, 2: 1},
{2: 0, 0: 2, 1: 1},
{1: 2, 3: 3, 2: 1},
{3: 0, 1: 3, 2: 1},
{0: 2, 2: 3, 1: 1},
{3: 0, 1: 2, 2: 1},
{2: 0, 0: 3, 1: 1},
{0: 0, 2: 3, 1: 1},
{1: 0, 3: 3, 2: 1},
{1: 0, 3: 2, 2: 1},
{0: 3, 1: 1, 2: 2},
{0: 0, 1: 1, 2: 2}])
assert expected == found_mcis1
assert expected == found_mcis2
def test_graph(self):
db = self.inst
strict, loose = db.build_matrices()
graph = db.build_graph()
self.assertRaises(IOError, nx.nx_agraph.write_dot, graph, '/check.dot')
mol2_graph = nx.read_gpickle("test/basic/molecules.gpickle")
dic1_nodes = graph.nodes(data=True)
dic1_edges = graph.edges(data=True)
dic2_nodes = mol2_graph.nodes(data=True)
dic2_edges = mol2_graph.edges(data=True)
self.assertEqual(True, dic1_nodes == dic2_nodes)
self.assertEqual(True, dic2_edges == dic2_edges)
nm = iso.categorical_node_match(['fname_comp', 'ID'], ['noname', -1])
em = iso.categorical_edge_match(['strict_flag', 'similarity'],
[False, -1.0])
self.assertEqual(
True,
nx.is_isomorphic(graph, mol2_graph, node_match=nm, edge_match=em))
def _mapped_graph_list(G1, liblist):
"""
find all matches of library element in the graph
"""
logging.info("Matching circuit Graph from library elements")
mapped_graph_list = {}
for lib_ele in liblist:
G2 = lib_ele['lib_graph']
sub_block_name = lib_ele['name']
#print("Matching:",sub_block_name)
logging.info("G: %s : %s", sub_block_name, str(' '.join(G2.nodes())))
GM = isomorphism.GraphMatcher(
G1,
G2,
node_match=isomorphism.categorical_node_match(['inst_type'],
['nmos']),
edge_match=isomorphism.categorical_edge_match(['weight'], [1]))
if GM.subgraph_is_isomorphic():
logging.info("ISOMORPHIC : %s", sub_block_name)
map_list = []
for Gsub in GM.subgraph_isomorphisms_iter():
map_list.append(Gsub)
logging.info("Matched Lib: %s", str(' '.join(Gsub.values())))
logging.info("Matched Circuit: %s", str(' '.join(Gsub)))
mapped_graph_list[sub_block_name] = map_list
return mapped_graph_list
def test_graph_radial_hub_fingerprint(self):
db = DBMolecules('test/radial/',
radial=True,
fingerprint=True,
fast=True,
hub="ejm_46.mol2")
strict, loose = db.build_matrices()
graph = db.build_graph()
mol2_graph = nx.read_gpickle(
"test/radial/radial_hub_fingerprint_fast.gpickle")
dic1_nodes = graph.nodes(data=True)
dic1_edges = graph.edges(data=True)
dic2_nodes = mol2_graph.nodes(data=True)
dic2_edges = mol2_graph.edges(data=True)
self.assertEqual(True, dic1_nodes == dic2_nodes)
self.assertEqual(True, dic2_edges == dic2_edges)
nm = iso.categorical_node_match(['fname_comp', 'ID'], ['noname', -1])
em = iso.categorical_edge_match(['strict_flag', 'similarity'],
[False, -1.0])
self.assertEqual(
True,
nx.is_isomorphic(graph, mol2_graph, node_match=nm, edge_match=em))
def _calculate_reward(self):
"""
Calculates the shaped reward for current timestep using state and task
state is EnvState from Agent.py. The comparison needs to be done
between the current graph and intended graph
FIXME: task right now is hand-coded, need to include in meta-reasoner
"""
# nx does not support different tolerances for different edges
# therefore the comparison is a two-step process for xy and theta
node_condition = iso.categorical_node_match(['length', 'width'],
[1, 1])
edge_condition1 = iso.numerical_edge_match(['delx', 'dely'], [0, 0],
rtol=self._errortolerancexy)
edge_condition2 = iso.numerical_edge_match(
['deltheta'], [0], rtol=self._errortolerancetheta)
result1 = nx.is_isomorphic(self._expectation.ws_state,
self._blocks.ws_state,
edge_match=edge_condition1,
node_match=node_condition)
result2 = nx.is_isomorphic(self._expectation.ws_state,
self._blocks.ws_state,
edge_match=edge_condition2,
node_match=node_condition)
result = result1 and result2
if result:
shaped_reward = self._gamma * len(
self._missions[self._mission_ptr]) - (self._mission_ptr + 1)
return (-1 + shaped_reward)
else:
return -1
def _is_isomorphic_graphs(self):
nm = iso.categorical_node_match('label', '')
em = iso.numerical_edge_match('weight', 1)
return nx.is_isomorphic(self.graph1,
self.graph2,
node_match=nm,
edge_match=em)
def isomorphism_check(G1, G2):
plagiarised = -1
#TODO: change gamma
gamma = 0.9
nm = iso.categorical_node_match(
'node_type', 'motion'
) #just putting motion as the default value anyway all nodes will have node_type
GM = iso.DiGraphMatcher(G1, G2, node_match=nm)
num_nodes = min(nx.number_of_nodes(G1), nx.number_of_nodes(G2)) #----
max_num_node = max(nx.number_of_nodes(G1), nx.number_of_nodes(G2))
#settings.OutputLogFile.write("Isomorphism_check: min number of nodes = "+str(num_nodes)+"\n")
#DiGraphMatcher.subgraph_isomorphisms_iter()
#settings.OutputLogFile.write("Subgraphs:\n")
for subgraph in GM.subgraph_isomorphisms_iter():
#print("type of subgraph: ",type(subgraph)) #WAS COMMENTED OUT BEFORE
#print(subgraph) #WAS COMMENTED OUT BEFORE
settings.OutputLogFile.write("subgraph:\n" + str(subgraph) + '\n')
settings.OutputLogFile.write(str(subgraph) + '\n')
if (len(subgraph) >=
gamma * num_nodes): #passing it through the filter
#settings.OutputLogFile.write("Plagiarised subgraph:\n" + str(subgraph)+'\n')
#plagiarised = True
plagiarised = (len(subgraph) /
max_num_node if max_num_node != 0 else 0)
break
return plagiarised
def main(n_minus_1_pattern_path,n_pattern_level_path):
selected_patterns_parent=[]
selected_patterns_child=[]
all_parent_permuted_graphs=[]
with open(n_minus_1_pattern_path,'r') as f:
for line in f.readlines():
selected_patterns_parent.append(Pattern(None,os.path.join(line.replace("RESULTS","PATTERNS").rstrip()+"/"+line.split("/")[-1].rstrip().replace("/","")+".gml")))
with open(n_pattern_level_path,'r') as f:
for line in f.readlines():
selected_patterns_child.append(Pattern(None,os.path.join(line.replace("RESULTS","PATTERNS").rstrip()+"/"+line.split("/")[-1].rstrip().replace("/","")+".gml")))
nm = iso.categorical_node_match('label', 'label')
print "Loaded all selected graphs ..."
subgraphs=get_all_subgraphs_child(selected_patterns_child)
print "Found all subgraphs ..."
found_matches={}
counter=1
for pattern_path in subgraphs.keys():
print "Processing ",counter,"child pattern"
counter+=1
match_found=False
for parent in selected_patterns_parent:
if match_found:
break
for subgr in subgraphs[pattern_path]:
if nx.is_isomorphic(subgr.pattern_graph,parent.pattern_graph,nm):
match_found=True
found_matches[pattern_path]=parent.pattern_path
break
print "Nr matches: ",len(found_matches)
for m in found_matches.keys():
with open(os.path.join(m).replace("gml","parent"),"w") as f:
f.write(found_matches[m].split("/")[-1].replace(".gml",""))
def test_build_unique_fragments(self):
edges = {(e[0], e[1]): None for e in self.pc_edges}
mol_graph = MoleculeGraph.with_edges(self.pc, edges)
unique_fragments = mol_graph.build_unique_fragments()
self.assertEqual(len(unique_fragments), 295)
nm = iso.categorical_node_match("specie", "ERROR")
for ii in range(295):
# Test that each fragment is unique
for jj in range(ii + 1, 295):
self.assertFalse(
nx.is_isomorphic(unique_fragments[ii].graph,
unique_fragments[jj].graph,
node_match=nm))
# Test that each fragment correctly maps between Molecule and graph
self.assertEqual(len(unique_fragments[ii].molecule),
len(unique_fragments[ii].graph.nodes))
species = nx.get_node_attributes(unique_fragments[ii].graph, "specie")
coords = nx.get_node_attributes(unique_fragments[ii].graph, "coords")
mol = unique_fragments[ii].molecule
for ss, site in enumerate(mol):
self.assertEqual(str(species[ss]), str(site.specie))
self.assertEqual(coords[ss][0], site.coords[0])
self.assertEqual(coords[ss][1], site.coords[1])
self.assertEqual(coords[ss][2], site.coords[2])
# Test that each fragment is connected
self.assertTrue(nx.is_connected(unique_fragments[ii].graph.to_undirected()))
def subgraph_is_isomorphic(graph, subgraph):
"""
determines whether main graph contains a subgraph which is isomorphic to input subgraph
:param graph: main graph
:param subgraph: a subgraph to be searched in main graph
:return: boolean
"""
graph_gspan = networkx_to_gspan(graph, 0)
subgraph_gspan = networkx_to_gspan(subgraph, 1)
# create temporary files during gspan processing
input_fd, input_filename = tempfile.mkstemp()
output_fd, output_filename = tempfile.mkstemp()
with os.fdopen(input_fd, 'w', encoding='utf-8') as input_handler:
input_handler.write(graph_gspan + subgraph_gspan)
orig_stdout = sys.stdout
sys.stdout = os.fdopen(output_fd, 'w', encoding='utf-8')
subgraph_miner = gSpan(input_filename, 2, where=True)
subgraph_miner.run()
sys.stdout = orig_stdout
mined_subgraphs = parse_mined_gspan_file(output_filename)
# remove temporary files
os.remove(input_filename)
os.remove(output_filename)
em = iso.numerical_edge_match('weight', 0)
nm = iso.categorical_node_match('name', None)
for mined_subgraph in mined_subgraphs:
graph_matcher = iso.GraphMatcher(mined_subgraph, subgraph, node_match=nm, edge_match=em)
if graph_matcher.is_isomorphic():
return True
return False
def isomorphism(pattern, target, nx_structures):
"""
Uses the NetworkX isomorphism algorithm to check if the pattern graph and the target graph are isomorphic.
The faster_could_be_isomorphic method is used to discount two structures if they could not be isomorphic.
:param pattern: a molecule object which is to be tested for isomorphism
:param target: a molecule object which pattern graph is to be compared against
:return: None if the graphs are not isomorphic
:return: a dictionary which maps the indices of the two NetworkX graphs together if they are isomorphic
"""
if pattern not in nx_structures:
nx_structures[pattern] = create_nx_graph(pattern, nx_structures)
if target not in nx_structures:
nx_structures[target] = create_nx_graph(target, nx_structures)
if not nx.faster_could_be_isomorphic(nx_structures[pattern],
nx_structures[target]):
# Graphs are definitely not isomorphic
return None
#print pattern, target
# Ensures the isomorphism considers the vertex label and edge type
matcher = iso.GraphMatcher(
nx_structures[pattern],
nx_structures[target],
node_match=iso.categorical_node_match('label', 'C'),
edge_match=iso.categorical_edge_match('type', 'single'))
if matcher.is_isomorphic():
return matcher.mapping
def uniquelist(l1, l2, fva):
l = []
temp = []
# li=[]
nm = iso.categorical_node_match('elem', 'C')
em = iso.numerical_edge_match('weight', 1)
for i, k in zip(l1, fva):
flag = 1
# c=0
for j in l2:
# c+=1
# GM = nx.algorithms.isomorphism.GraphMatcher(i,j)
if iso.is_isomorphic(i, j, edge_match=em, node_match=nm):
# print "1"
flag = 0
# li.append(c)
break
if flag == 1:
l.append(i)
temp.append(k)
# print len(l)
# print len(li)
# print li
# c=0
# for i in range(0,len(l2)):
# c=0
# if i+1 not in li:
# l.append(l2[c])
# print "hola"
# else:
# c+=1
return l, temp
def compare(cc1, cc2):
s1 = {a.id for a in cc1.atoms}
s2 = {a.id for a in cc2.atoms}
b1 = {b.lexicographic_str() for b in cc1.rt.bonds}
b2 = {b.lexicographic_str() for b in cc2.rt.bonds}
if s1 == s2 and b1 == b2:
#print(cc1.name, "the same")
return
G1 = graph_from_chemcomp(cc1)
G2 = graph_from_chemcomp(cc2)
node_match = isomorphism.categorical_node_match('Z', 0)
GM = isomorphism.GraphMatcher(G1, G2, node_match=node_match)
if GM.is_isomorphic():
print(cc1.name, 'is isomorphic')
# we could use GM.match(), but here we try to find the shortest diff
short_diff = None
for n, mapping in enumerate(GM.isomorphisms_iter()):
diff = {k: v for k, v in mapping.items() if k != v}
if short_diff is None or len(diff) < len(short_diff):
short_diff = diff
if n == 10000: # don't spend too much here
print(' (it may not be the simplest isomorphism)')
break
for id1, id2 in short_diff.items():
print('\t', id1, '->', id2)
else:
print(cc1.name, 'differs')
if s2 - s1:
print('\tmissing:', ' '.join(s2 - s1))
if s1 - s2:
print('\textra: ', ' '.join(s1 - s2))
def _get_subgraph_N_X_N(self, graph1, graph2, name1, name2):
ret = {'subgraph_N_0_N': 0}
# TODO: not worth counting all of them
# ret = {
# 'subgraph_N_0_N' : 0,
# 'subgraph_N_1_N' : 0,
# 'subgraph_N_2_N' : 0
# }
subgraphs1 = self._get_subgraphs(graph1, name1, 2)
subgraphs2 = self._get_subgraphs(graph2, name2, 2)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(
r[0],
r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
for u, v, d in r[0].edges(data=True):
if d['color'] == 0:
ret['subgraph_N_0_N'] += 1
# print u + " " + v + " 0"
# TODO: appears to be unuseful
# elif d['color'] == 1:
# ret['subgraph_N_1_N'] += 1
# # print u + " " + v + " 1"
# elif d['color'] == 2:
# ret['subgraph_N_2_N'] += 1
# # print u + " " + v + " 2"
return ret
def _get_subgraph_N_X_N(self, graph1, graph2, name1, name2):
ret = {
'subgraph_N_0_N' : 0
}
# TODO: not worth counting all of them
# ret = {
# 'subgraph_N_0_N' : 0,
# 'subgraph_N_1_N' : 0,
# 'subgraph_N_2_N' : 0
# }
subgraphs1 = self._get_subgraphs(graph1, name1, 2)
subgraphs2 = self._get_subgraphs(graph2, name2, 2)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(r[0], r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
for u, v, d in r[0].edges(data=True):
if d['color'] == 0:
ret['subgraph_N_0_N'] += 1
# print u + " " + v + " 0"
# TODO: appears to be unuseful
# elif d['color'] == 1:
# ret['subgraph_N_1_N'] += 1
# # print u + " " + v + " 1"
# elif d['color'] == 2:
# ret['subgraph_N_2_N'] += 1
# # print u + " " + v + " 2"
return ret
def __eq__(self, other): # two rules are equal if the LHSs match and RHSs are isomorphic
g1 = nx.convert_node_labels_to_integers(self.graph)
g2 = nx.convert_node_labels_to_integers(other.graph)
# and nx.fast_could_be_isomorphic(g1, g2) \
return self.lhs == other.lhs \
and nx.is_isomorphic(g1, g2, edge_match=iso.numerical_edge_match('weight', 1.0),
node_match=iso.categorical_node_match('label', ''))
def isIsomorphism(n, G1, G2):
drawIsomorphic(n, G1)
# g1 = nx.DiGraph()
# g2 = nx.DiGraph()
# nx.add_path(G1, G1, weight=1)
# nx.add_path(G2, G2, weight=2)
# em = iso.numerical_edge_match("weight", 1)
# nx.is_isomorphic(G1, G2) # no weights considered
# g = nx.is_isomorphic(G1, G2)
# print("is isomorphic? ", g)
g1 = nx.MultiDiGraph()
g2 = nx.MultiDiGraph()
g1.add_nodes_from(G1, fill="red")
g2.add_nodes_from(G2, fill="red")
nx.add_path(g1, G1, weight=3, linewidth=2.5)
nx.add_path(g2, G2, weight=3)
nm = iso.categorical_node_match("fill", "red")
nx.is_isomorphic(g1, g2, node_match=nm)
g = nx.is_isomorphic(g1, g2, node_match=nm)
print("is isomorphic? ", g)
g3 = nx.Graph()
# g1.add_node("a")
g3.add_edges_from(G2)
nx.draw(g3)
plt.savefig("G2.png") # save as png
plt.show()
return g
def has_isomorphism_with(g, graphs):
for oldgraph in graphs:
if nx.is_isomorphic(g,
oldgraph,
node_match=iso.categorical_node_match(
'nodetype', 'dumb')):
return True
return False
def build(self):
self.nm = iso.categorical_node_match("color", "")
self.em = iso.numerical_edge_match("weight", 1)
self.g1.add_node("A", color="red")
self.g2.add_node("C", color="blue")
self.g1.add_edge("A", "B", weight=1)
self.g2.add_edge("C", "D", weight=1)
def build(self):
self.nm = iso.categorical_node_match('color', '')
self.em = iso.numerical_edge_match('weight', 1)
self.g1.add_node('A', color='red')
self.g2.add_node('C', color='blue')
self.g1.add_edge('A', 'B', weight=1)
self.g2.add_edge('C', 'D', weight=1)
def get_mapping_ts_template(larger_graph, smaller_graph):
logger.info('Getting mapping of molecule onto the TS template')
logger.info('Running isomorphism')
graph_matcher = isomorphism.GraphMatcher(
larger_graph,
smaller_graph,
node_match=isomorphism.categorical_node_match('atom_label', 'C'),
edge_match=isomorphism.categorical_edge_match('active', False))
return next(graph_matcher.match())
def _mapped_graph_list(G1, liblist, CLOCK=None, DIGITAL=False):
"""
find all matches of library element in the graph
"""
logger.debug("Matching circuit Graph from library elements")
mapped_graph_list = {}
for lib_ele in liblist:
G2 = lib_ele['graph']
# DIgital blocks only transistors:
nd = [node for node in G2.nodes()
if 'net' not in G2.nodes[node]["inst_type"]]
if DIGITAL and len(nd)>1:
continue
sub_block_name = lib_ele['name']
logger.debug(f"Matching: {sub_block_name} : {' '.join(G2.nodes())}")
GM = isomorphism.GraphMatcher(
G1, G2,
node_match=isomorphism.categorical_node_match(['inst_type'],
['nmos']),
edge_match=isomorphism.categorical_edge_match(['weight'], [1]))
if GM.subgraph_is_isomorphic():
logger.debug(f"ISOMORPHIC : {sub_block_name}")
map_list = []
for Gsub in GM.subgraph_isomorphisms_iter():
all_nd = [
key for key in Gsub
if 'net' not in G1.nodes[key]["inst_type"]]
logger.debug(f"matched inst: {all_nd}")
if len(all_nd)>1 and dont_touch_clk(Gsub,CLOCK):
logger.debug("Discarding match due to clock")
continue
if sub_block_name.startswith('DP') or sub_block_name.startswith('CMC'):
if G1.nodes[all_nd[0]]['values'] == G1.nodes[all_nd[1]]['values'] and \
compare_balanced_tree(G1,get_key(Gsub,'DA'),get_key(Gsub,'DB')) :
if 'SA' in Gsub.values() and \
compare_balanced_tree(G1,get_key(Gsub,'SA'),get_key(Gsub,'SB')) :
map_list.append(Gsub)
logger.debug(f"Matched Lib: {' '.join(Gsub.values())}")
logger.debug(f"Matched Circuit: {' '.join(Gsub)}")
else:
map_list.append(Gsub)
logger.debug(f"Matched Lib: {' '.join(Gsub.values())}")
logger.debug(f"Matched Circuit: {' '.join(Gsub)}")
else:
logger.debug(f"Discarding match {sub_block_name}, {G1.nodes[all_nd[0]]['values']}, {G1.nodes[all_nd[1]]['values']}")
else:
map_list.append(Gsub)
logger.debug(f"Matched Lib: {' '.join(Gsub.values())}")
logger.debug(f"Matched Circuit: {' '.join(Gsub)}")
mapped_graph_list[sub_block_name] = map_list
return mapped_graph_list
def build(self):
self.nm = iso.categorical_node_match('color', '')
self.em = iso.numerical_edge_match('weight', 1)
self.g1.add_node('A', color='red')
self.g2.add_node('C', color='blue')
self.g1.add_edge('A','B', weight=1)
self.g2.add_edge('C','D', weight=1)
def gammaIso(G1, G2):
nm = isomorphism.categorical_node_match(['fillcolor', 'shape'],
['', ''])
em = isomorphism.categorical_multiedge_match('color', '')
#G1.remove_nodes_from(nx.isolates(G1)) #Drop Isolates
#G2.remove_nodes_from(nx.isolates(G2)) #Drop Isolates
#Create set of induced subgraphs for the Graphs and check for isomorphism.
len_G1_nodes = len(G1.nodes())
len_G2_nodes = len(G2.nodes())
min_len = min(len_G1_nodes, len_G2_nodes)
max_len = max(len_G1_nodes, len_G2_nodes)
G1_list = createAllComboList(G1.nodes(), min_len)
G2_list = createAllComboList(G2.nodes(), min_len)
induced_subgraph_G1 = [
G1.subgraph(node_list) for node_list in G1_list
]
induced_subgraph_G2 = [
G2.subgraph(node_list) for node_list in G2_list
]
new_induced_subgraph_G1 = []
new_induced_subgraph_G2 = []
#Remove graphs with empty nodes and empty edges
for g in induced_subgraph_G1:
if (len(g.nodes()) == 0 or len(g.edges()) == 0):
continue
new_induced_subgraph_G1.append(g)
for g in induced_subgraph_G2:
if (len(g.nodes()) == 0 or len(g.edges()) == 0):
continue
new_induced_subgraph_G2.append(g)
induced_subgraph_G1_rev = new_induced_subgraph_G1[::-1]
induced_subgraph_G2_rev = new_induced_subgraph_G2[::-1]
similarity = 0
for g1 in induced_subgraph_G1_rev:
for g2 in induced_subgraph_G2_rev:
if (len(g1.nodes()) == len(g2.nodes())
and len(g1.edges()) == len(g2.edges())):
GM = isomorphism.MultiDiGraphMatcher(g1, g2, nm, em)
if (GM.is_isomorphic()):
similarity = max(similarity,
len(g1.nodes()) / float(max_len))
return similarity, GM.mapping
return 0, {}
def max_isom_substree(G, H):
#gm_one = isomorphism.DiGraphMatcher(G, H)
#gm_two = isomorphism.DiGraphMatcher(H, G)
nm = isomorphism.categorical_node_match('text', '')
gm_one = isomorphism.DiGraphMatcher(G, H, node_match=nm)
gm_two = isomorphism.DiGraphMatcher(H, G, node_match=nm)
if gm_one.subgraph_is_isomorphic():
return af.count_nodes(H)
if gm_two.subgraph_is_isomorphic():
return af.count_nodes(G)
return 0
def is_subgraph_isomorphic(larger_graph, smaller_graph):
logger.info('Running subgraph isomorphism')
graph_matcher = isomorphism.GraphMatcher(
larger_graph,
smaller_graph,
node_match=isomorphism.categorical_node_match('atom_label', 'C'),
edge_match=isomorphism.categorical_edge_match('active', False))
if graph_matcher.subgraph_is_isomorphic():
return True
return False
def thread_function(graph, subGraphs):
vec = np.zeros(len(subGraphs))
for s_idx, subgraph in enumerate(subGraphs):
GM = iso.GraphMatcher(
graph,
subgraph,
node_match=iso.categorical_node_match('label', ''),
edge_match=iso.categorical_edge_match('label', ''))
if GM.subgraph_is_isomorphic():
vec[s_idx] = 1
return vec
def _match_graphs(pattern, candidate, exact):
""" Compare two pattern graphs for isomorphism """
node_matcher = categorical_node_match('id', default=None)
if exact:
return nx.is_isomorphic(pattern._as_graph(),
candidate._as_graph(),
node_match=node_matcher)
else:
return GraphMatcher(candidate._as_graph(),
pattern._as_graph(),
node_match=node_matcher).subgraph_is_isomorphic()
def equals(g1, g2):
#---
assert isinstance(g1, nx.Graph) and isinstance(g2, nx.Graph)
#---
return nx.isomorphism.GraphMatcher(
g1,
g2,
#node_match=nm,
node_match=iso.categorical_node_match('type', ''),
#edge_match=em
edge_match=iso.categorical_multiedge_match('prop',
'')).is_isomorphic()
def _get_subgraph_3_nodes(self, graph1, graph2, name1, name2):
ret = {
'subgraph_3N' : 0
}
subgraphs1 = self._get_subgraphs(graph1, name1, 3)
subgraphs2 = self._get_subgraphs(graph2, name2, 3)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(r[0], r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
ret['subgraph_3N'] += 1
return ret
def __ne__(self, other):
''' Function has two molecules as input and decides whether or not
they are the same molecule based on the graph.
Both the node labels and graph topology must match to be equal '''
# set up the function that is called to determine the node attribute
# used to determine equality of the nodes
nm = iso.categorical_node_match('atom', Atom(0,'Xx'))
# check that both networks are isomorphic - same number of
# nodes and same edge connection pattern and that the node atom types
# are equivalent
return nx.is_isomorphic(self.topology, other.topology, node_match=nm)
def get_redox_graph_mapping(G1, G2):
"""Given two graphs, returns subgraph mapping (after removing redox protons)
***Now also returns oxygens binded to redox protons in a tuple with the mapping***
This is a function written for the ease of my research process"""
if nx.number_of_nodes(G1) > nx.number_of_nodes(G2):
G1 = G1
x = remove_redox_protons(G1)
G1, Hydroxy_oxygen = x[0], x[1]
Hydroxy_oxygen.append(True)
else:
G2 = G2
x = remove_redox_protons(G2)
G2, Hydroxy_oxygen = x[0], x[1]
Hydroxy_oxygen.append(False)
Gm = iso.GraphMatcher(G1,G2,node_match=iso.categorical_node_match(['Element'],['C']))
Gm.is_isomorphic()
return (Gm.mapping,Hydroxy_oxygen)
def _get_subgraph_N(self, graph1, graph2, name1, name2):
ret = 0
subgraphs1 = self._get_subgraphs(graph1, name1, 1)
subgraphs2 = self._get_subgraphs(graph2, name2, 1)
for r in itertools.product(subgraphs1, subgraphs2):
GM = nx.algorithms.isomorphism.GraphMatcher(r[0], r[1],
node_match=iso.categorical_node_match(['str_name'], ['name']),
edge_match=iso.numerical_edge_match(['color'], [-1]))
if GM.is_isomorphic():
is_upper = False
for n, d in r[0].nodes_iter(data=True):
if d['str_name'].isupper():
is_upper = True
if not is_upper:
ret = 1
return {'subgraph_N' : ret}
def supportValue(gList, sg):
'''
求支持数量，即gList中包含sg的图的数量
gList [Graph, ]
sg Graph
'''
print '*** start ***'
v = 0
sptList = []
for i in range(len(gList)):
g = gList[i]
GM = nx.isomorphism.DiGraphMatcher(g, sg, node_match=iso.categorical_node_match('name', None))
if GM.subgraph_is_isomorphic():
v += 1
sptList.append(i)
print '*** end.. ***'
return v, sptList
def listener():
global G,spatial_nodes_counter,temporal_nodes_counter,labels,A,G0,Activities
rospy.init_node('Graphs2')
rospy.Subscriber("QSRs", QSR, callback_graphs)
r = rospy.Rate(10) # 10hz
time.sleep(1)
nm = iso.categorical_node_match('type1', '')
em = iso.categorical_edge_match('dirx', '')
while not rospy.is_shutdown():
plotting = False
G1 = graph_maker(A.o1,A.o2,A.spatial,A.temporal,A.objects,plotting)
results = []
for i in range(len(Activities)):
flag = 1
G_copy = G1
counter = 0
while flag==1:
GM = iso.GraphMatcher(G_copy,Activities[int(i)],node_match=nm,edge_match=em)
if GM.subgraph_is_isomorphic():
counter +=1
used_nodes1 = GM.mapping
if used_nodes1 != {}:
#print list(used_nodes1)
#print [n for n in list(used_nodes1) if G_copy.node[n]['type2']=='temporal']
used_nodes2 = []
used_nodes2 = np.append(used_nodes2, [n for n in list(used_nodes1) if G_copy.node[n]['type2']=='temporal'])
G_copy.remove_nodes_from(used_nodes2) # remove temporal nodes from the graph
else:
flag = 0
results = np.append(results,counter)
msg = []
for i in range(len(activities_names)):
msg = np.append(msg,activities_names[i]+'='+str(results[i]))
print msg
r.sleep()
def _match_graphs(pattern, candidate, exact, count):
""" Compare two pattern graphs for isomorphism """
node_matcher = categorical_node_match('id', default=None)
if exact:
match = nx.is_isomorphic(pattern._as_graph(),
candidate._as_graph(),
node_match=node_matcher)
return 1 if count else match
else:
gm = GraphMatcher(
candidate._as_graph(), pattern._as_graph(),
node_match=node_matcher
)
if count:
if pattern.match_once:
return 1 if gm.subgraph_is_isomorphic() else 0
return sum(1 for _ in gm.subgraph_isomorphisms_iter())
else:
return gm.subgraph_is_isomorphic()
def categorize_functional_groups(self, groups):
"""
Determine classes of functional groups present in a set.
:param groups: Set of functional groups.
:return: dict containing representations of the groups, the indices of
where the group occurs in the MoleculeGraph, and how many of each
type of group there is.
"""
categories = {}
em = iso.numerical_edge_match("weight", 1)
nm = iso.categorical_node_match("specie", "C")
for group in groups:
atoms = [self.molecule[a] for a in group]
species = [a.specie for a in atoms]
coords = [a.coords for a in atoms]
adaptor = BabelMolAdaptor(Molecule(species, coords))
# Use Canonical SMILES to ensure uniqueness
smiles = adaptor.pybel_mol.write("can").strip()
if smiles in categories:
this_subgraph = self.molgraph.graph.subgraph(list(group)).to_undirected()
for other in categories[smiles]["groups"]:
other_subgraph = self.molgraph.graph.subgraph(list(other)).to_undirected()
if not nx.is_isomorphic(this_subgraph, other_subgraph,
edge_match=em, node_match=nm):
break
if group not in categories[smiles]["groups"]:
categories[smiles]["groups"].append(group)
categories[smiles]["count"] += 1
else:
categories[smiles] = {"groups": [group],
"count": 1}
return categories
def generate_all_unique_dependency_subgraphs(graphs, node_attrib='label',
edge_attrib='label'):
same_node_label = iso.categorical_node_match(node_attrib, '')
same_edge_label = iso.categorical_edge_match(edge_attrib, '')
if len(graphs) == 0:
return []
elif len(graphs) == 1:
return list(get_dependency_subgraphs(graphs[0], node_attrib=node_attrib))
else:
unique_subgraphs = list(get_dependency_subgraphs(
graphs[0], node_attrib=node_attrib, edge_attrib=edge_attrib))
for graph in graphs[1:]:
for subgraph in get_dependency_subgraphs(graph):
sg_combs = itertools.product([subgraph], unique_subgraphs)
if not any(nx.is_isomorphic(new_sg, old_sg,
node_match=same_node_label,
edge_match=same_edge_label)
for new_sg, old_sg in sg_combs):
unique_subgraphs.append(subgraph)
return unique_subgraphs
def _nx_isomorphism(self, pattern, target):
"""
Uses the NetworkX isomorphism algorithm to check if the pattern graph and the target graph are isomorphic.
The faster_could_be_isomorphic method is used to discount two structures if they could not be isomorphic.
:param pattern: a molecule object which is to be tested for isomorphism
:param target: a molecule object which pattern graph is to be compared against
:return: None if the graphs are not isomorphic
:return: a dictionary which maps the indices of the two NetworkX graphs together if they are isomorphic
"""
if pattern not in self.structure_nx:
self._create_nx_graph(pattern)
if target not in self.structure_nx:
self._create_nx_graph(target)
if not nx.faster_could_be_isomorphic(self.structure_nx[pattern], self.structure_nx[target]):
# Graphs are definitely not isomorphic
return None
# Ensures the isomorphism considers the vertex label and edge type
matcher = iso.GraphMatcher(self.structure_nx[pattern], self.structure_nx[target],
node_match=iso.categorical_node_match('label', 'C'),
edge_match=iso.categorical_edge_match('type', 'single'))
if matcher.is_isomorphic():
return matcher.mapping
def listener():
global G,spatial_nodes_counter,temporal_nodes_counter,labels,A1,G0,Activities,activity,ID
# initialize ROS node
rospy.init_node('sub_activity')
rospy.Subscriber('QSRs', QSR, callback_graphs)
rospy.Subscriber('CAD120_act', ActivityName, callback_activity)
r = rospy.Rate(10) # 20hz
# important delay - keep it
time.sleep(3)
# matching proporties
nm = iso.categorical_node_match('type1', '')
em = iso.categorical_edge_match('dirx', '')
# preparing the sub_activity matrix
window = 250
number = len(activities_names)
th = 15 # thickness of qsr lines
name_window = 200 # left margin to write activity names
subA_vector = np.zeros(shape=(number, window), dtype=int) # initilize the sub_activity matrix actual one
subA = np.zeros(shape=(th*number, window, 3), dtype=int)+255 # initilize the sub_activity matrix for image
subA_interval = np.zeros(shape=(number, window, 1), dtype=int) # initilize the sub_activity matrix for intervals
# preparing the image
img = np.zeros((th*number,window+name_window,3), np.uint8)+255 # initializing the image
img[:,name_window-5:name_window,:] = np.zeros((th*number,5,3), np.uint8)
# writing on the image
counter = 0
for i in range(len(activities_names)):
cv2.putText(img,activities_names[i],(10,(th*(counter+1))-5), cv2.FONT_HERSHEY_SIMPLEX, .5,(0,0,0),1)
counter = counter+1
# writing on file the histogram
f = open('/home/omari/catkin_ws/src/cad120/src/histogram'+'.txt', 'w')
ID=0
ID_old = 0
activity_old = 'nothing'
while not rospy.is_shutdown():
G1 = graph_maker(A1.o1,A1.o2,A1.spatial,A1.temporal,A1.objects,False)
results = []
for i in range(len(Activities)):
flag = 1
G_copy = G1
counter = 0
while flag==1:
GM = iso.GraphMatcher(G_copy,Activities[int(i)],node_match=nm,edge_match=em)
if GM.subgraph_is_isomorphic():
counter +=1
used_nodes1 = GM.mapping
if used_nodes1 != {}:
#print list(used_nodes1)
#print [n for n in list(used_nodes1) if G_copy.node[n]['type2']=='temporal']
used_nodes2 = []
used_nodes2 = np.append(used_nodes2, [n for n in list(used_nodes1) if G_copy.node[n]['type2']=='temporal'])
G_copy.remove_nodes_from(used_nodes2) # remove temporal nodes from the graph
else:
flag = 0
results = np.append(results,counter)
subA[:,0:window-1,:] = subA[:,1:window,:]
subA_vector[:,0:window-1] = subA_vector[:,1:window]
counter = 0
for i1 in results:
if i1>0:
subA[th*counter:th*(counter+1),window-1,:] = [255,0,0]
subA_vector[counter,window-1] = 1
else:
subA[th*counter:th*(counter+1),window-1,:] = [255,255,255]
subA_vector[counter,window-1] = 0
counter += 1
# If you ever needed to do the interval,
# 1 find sub_interval
# 2 find the first positive number because thats where the first pick is
"""
subA_interval = subA[th,:,2]-subA[0,:,2]
index_pk = list(np.where(subA_interval==255))
index_pc = np.where(subA_interval==-255)
if list(index_pk[0]) !=[]:
I_pk = list(index_pk[0])[0]
for j1 in range(len(list(index_pk[0]))-1):
if list(index_pk[0])[j1+1]-list(index_pk[0])[j1] > 1:
I_pk = np.append(I_pk,list(index_pk[0])[j1+1])
if list(index_pc[0]) !=[]:
I_pc = list(index_pc[0])[0]
for j1 in range(len(list(index_pc[0]))-1):
if list(index_pc[0])[j1+1]-list(index_pc[0])[j1] > 1:
I_pc = np.append(I_pc,list(index_pc[0])[j1+1])
"""
counter_sub_acivities = np.zeros((number), np.uint8)
for i1 in range(number):
index_pk = list(np.where(subA_vector[i1,:]==1))
if list(index_pk[0]) !=[]:
counter_sub_acivities[i1] = 1
for j1 in range(len(list(index_pk[0]))-1):
if list(index_pk[0])[j1+1]-list(index_pk[0])[j1] > 1:
counter_sub_acivities[i1] += 1
if ID_old != ID:
#-------------------#
f.write(activity_old+',')
f.write(str(counter_sub_acivities))
f.write('\n')
#-------------------#
print activity_old,ID_old,counter_sub_acivities
ID_old = ID
activity_old = activity[0].split('/')[0]
if ID[0] == '1204145902':
f.close()
print 'Done'
subA_vector = np.zeros(shape=(number, window), dtype=int) # initilize the sub_activity matrix actual one
img[:,name_window:window+name_window,:] = subA
r.sleep()
cv2.imshow('sub activities',img)
k = cv2.waitKey(1) & 0xFF
def __eq__(self, other):
"""Return True if the two structures are isomorphic."""
func_vals = iso.categorical_node_match(self.funcs.polarizing + self.funcs.labeling, repeat(None))
func_name = iso.categorical_edge_match("func", None)
return nx.is_isomorphic(self, other, func_vals, func_name)
def listener():
global G,spatial_nodes_counter,temporal_nodes_counter,labels,A1,G0,Activities,activity,ID
# initialize ROS node
rospy.init_node('sub_activity')
rospy.Subscriber('QSRs', QSR, callback_graphs)
rospy.Subscriber('CAD120_act', ActivityName, callback_activity)
r = rospy.Rate(10) # 20hz
# important delay - keep it
time.sleep(3)
# matching proporties
nm = iso.categorical_node_match('type1', '')
em = iso.categorical_edge_match('dirx', '')
# preparing the sub_activity matrix
window = 150
number = len(activities_names)
th = 15 # thickness of qsr lines
name_window = 200 # left margin to write activity names
subA_vector = np.zeros(shape=(number, window), dtype=int) # initilize the sub_activity matrix actual one
subA = np.zeros(shape=(th*number, window, 3), dtype=int)+255 # initilize the sub_activity matrix for image
subA_interval = np.zeros(shape=(number, window, 1), dtype=int) # initilize the sub_activity matrix for intervals
# preparing the image
img = np.zeros((th*number,window+name_window,3), np.uint8)+255 # initializing the image
img[:,name_window-5:name_window,:] = np.zeros((th*number,5,3), np.uint8)
# writing on the image
counter = 0
for i in range(len(activities_names)):
cv2.putText(img,activities_names[i],(10,(th*(counter+1))-5), cv2.FONT_HERSHEY_SIMPLEX, .5,(0,0,0),1)
counter = counter+1
# KNN
knn = Training()
KNN_Timer = 0
Main_Counter = 0
while not rospy.is_shutdown():
G1 = graph_maker(A1.o1,A1.o2,A1.spatial,A1.temporal,A1.objects,False)
results = []
for i in range(len(Activities)):
flag = 1
G_copy = G1
counter = 0
while flag==1:
GM = iso.GraphMatcher(G_copy,Activities[int(i)],node_match=nm,edge_match=em)
if GM.subgraph_is_isomorphic():
counter +=1
used_nodes1 = GM.mapping
if used_nodes1 != {}:
#print list(used_nodes1)
#print [n for n in list(used_nodes1) if G_copy.node[n]['type2']=='temporal']
used_nodes2 = []
used_nodes2 = np.append(used_nodes2, [n for n in list(used_nodes1) if G_copy.node[n]['type2']=='temporal'])
G_copy.remove_nodes_from(used_nodes2) # remove temporal nodes from the graph
else:
flag = 0
results = np.append(results,counter)
subA[:,0:window-1,:] = subA[:,1:window,:]
subA_vector[:,0:window-1] = subA_vector[:,1:window]
counter = 0
for i1 in results:
if i1>0:
subA[th*counter:th*(counter+1),window-1,:] = [255,0,0]
subA_vector[counter,window-1] = 1
else:
subA[th*counter:th*(counter+1),window-1,:] = [255,255,255]
subA_vector[counter,window-1] = 0
counter += 1
# If you ever needed to do the interval,
# 1 find sub_interval
# 2 find the first positive number because thats where the first pick is
"""
subA_interval = subA[th,:,2]-subA[0,:,2]
index_pk = list(np.where(subA_interval==255))
index_pc = np.where(subA_interval==-255)
if list(index_pk[0]) !=[]:
I_pk = list(index_pk[0])[0]
for j1 in range(len(list(index_pk[0]))-1):
if list(index_pk[0])[j1+1]-list(index_pk[0])[j1] > 1:
I_pk = np.append(I_pk,list(index_pk[0])[j1+1])
if list(index_pc[0]) !=[]:
I_pc = list(index_pc[0])[0]
for j1 in range(len(list(index_pc[0]))-1):
if list(index_pc[0])[j1+1]-list(index_pc[0])[j1] > 1:
I_pc = np.append(I_pc,list(index_pc[0])[j1+1])
"""
# testing the hitogram
if KNN_Timer == 5:
counter_sub_acivities = np.array(np.zeros((1,40)), dtype = np.float32)
for i1 in range(number):
index_pk = list(np.where(subA_vector[i1,:]==1))
if list(index_pk[0]) !=[]:
counter_sub_acivities[0,i1] = 1
for j1 in range(len(list(index_pk[0]))-1):
if list(index_pk[0])[j1+1]-list(index_pk[0])[j1] > 1:
counter_sub_acivities[0,i1] += 1
#ret,result,neighbours,dist = knn.find_nearest(counter_sub_acivities[0:1,:],k=1)
print counter_sub_acivities
KNN_Timer = 0
Main_Counter +=1
else:
KNN_Timer += 1
img[:,name_window:window+name_window,:] = subA
cv2.imshow('sub activities',img)
k = cv2.waitKey(1) & 0xFF
r.sleep()
def listener():
global QSR_msg,Activities
# initialize ROS node
rospy.init_node('sub_activity')
rospy.Subscriber('QSRs', QSR, callback_graphs)
pub = rospy.Publisher('SubActivities', SubAct)
r = rospy.Rate(5) # 5hz
# important delay - keep it
time.sleep(1)
# matching proporties
nm = iso.categorical_node_match('type1', '')
em = iso.categorical_edge_match('dirx', '')
# preparing the sub_activity matrix
window = 150
number = len(activities_names)
th = 15 # thickness of qsr lines
name_window = 200 # left margin to write activity names
subA_vector = np.zeros(shape=(number, window), dtype=int) # initilize the sub_activity matrix actual one
subA = np.zeros(shape=(th*number, window, 3), dtype=int)+255 # initilize the sub_activity matrix for image
#subA_interval = np.zeros(shape=(number, window, 1), dtype=int) # initilize the sub_activity matrix for intervals
# preparing the image
img = np.zeros((th*number,window+name_window,3), np.uint8)+255 # initializing the image
img[:,name_window-5:name_window,:] = np.zeros((th*number,5,3), np.uint8)
# writing on the image
counter = 0
for i in range(len(activities_names)):
cv2.putText(img,activities_names[i],(10,(th*(counter+1))-5), cv2.FONT_HERSHEY_SIMPLEX, .5,(0,0,0),1)
counter = counter+1
A1 = 0
while not rospy.is_shutdown():
# if A1 dont change then no need to do all the calculation !
if A1 != QSR_msg:
A1 = QSR_msg
G1 = graph_maker(A1.o1,A1.o2,A1.spatial,A1.temporal,A1.objects,False)
results = []
for i in range(len(Activities)):
flag = 1
G_copy = G1
counter = 0
nodes1 = Activities[int(i)].nodes()
nodes2 = G_copy.nodes()
obj_nodes1 = []
obj_nodes2 = []
obj_nodes1 = np.append(obj_nodes1,[n for n in list(nodes1) if Activities[int(i)].node[n]['type2']=='object'])
obj_nodes2 = np.append(obj_nodes2,[n for n in list(nodes2) if G_copy.node[n]['type2']=='object'])
obj_exist = []
for n in obj_nodes1:
obj_exist = np.append(obj_exist, np.where(obj_nodes2==n))
#print len(obj_exist),len(obj_nodes1)
print i
#print Activities[int(i)].node[n]['type2']=='temporal'
if len(obj_exist)==len(obj_nodes1):
while flag==1:
GM = iso.GraphMatcher(G_copy,Activities[int(i)],node_match=nm,edge_match=em)
if GM.subgraph_is_isomorphic():
counter +=1
used_nodes1 = GM.mapping
if used_nodes1 != {}:
#print list(used_nodes1)
#print [n for n in list(used_nodes1) if G_copy.node[n]['type2']=='temporal']
used_nodes2 = []
used_nodes2 = np.append(used_nodes2, [n for n in list(used_nodes1) if G_copy.node[n]['type2']=='temporal'])
G_copy.remove_nodes_from(used_nodes2) # remove temporal nodes from the graph
else:
flag = 0
results = np.append(results,counter)
else:
flag = 0
results = np.append(results,counter)
#print i
subA[:,0:window-1,:] = subA[:,1:window,:]
subA_vector[:,0:window-1] = subA_vector[:,1:window]
counter = 0
for i1 in results:
if i1>0:
subA[th*counter:th*(counter+1),window-1,:] = [255,0,0]
subA_vector[counter,window-1] = 1
else:
subA[th*counter:th*(counter+1),window-1,:] = [255,255,255]
subA_vector[counter,window-1] = 0
counter += 1
# If you ever needed to do the interval,
# 1 find sub_interval
# 2 find the first positive number because thats where the first pick is
"""
subA_interval = subA[th,:,2]-subA[0,:,2]
index_pk = list(np.where(subA_interval==255))
index_pc = np.where(subA_interval==-255)
if list(index_pk[0]) !=[]:
I_pk = list(index_pk[0])[0]
for j1 in range(len(list(index_pk[0]))-1):
if list(index_pk[0])[j1+1]-list(index_pk[0])[j1] > 1:
I_pk = np.append(I_pk,list(index_pk[0])[j1+1])
if list(index_pc[0]) !=[]:
I_pc = list(index_pc[0])[0]
for j1 in range(len(list(index_pc[0]))-1):
if list(index_pc[0])[j1+1]-list(index_pc[0])[j1] > 1:
I_pc = np.append(I_pc,list(index_pc[0])[j1+1])
"""
counter_sub_acivities = np.zeros((number), np.uint8)
for i1 in range(number):
index_pk = list(np.where(subA_vector[i1,:]==1))
if list(index_pk[0]) !=[]:
counter_sub_acivities[i1] = 1
for j1 in range(len(list(index_pk[0]))-1):
if list(index_pk[0])[j1+1]-list(index_pk[0])[j1] > 1:
counter_sub_acivities[i1] += 1
pub.publish(tuple(counter_sub_acivities))
img[:,name_window:window+name_window,:] = subA
r.sleep()
cv2.imshow('sub activities',img)
if cv2.waitKey(1) & 0xFF == 27:
break
def get_value(self):
# comment tekens moeten weg wnn het op pi gaat runnen
stream = io.BytesIO()
self.camera.capture(stream, format='jpeg')
image = np.fromstring(stream.getvalue(), dtype=np.uint8)
center, figures = image_processing.get_figures_data(image)
self.message('Figures: %s' % figures)
# _, figures = image_processing.get_figures_image(image)
if (len(figures) < 3):
print "found less than three figures"
return None
img_graph = self.build_graph_image(figures)
if img_graph is None:
print "IMG GRAPH IS NONE"
return None
nm = iso.categorical_node_match('fig', None)
GM = iso.GraphMatcher(self.grid_graph,img_graph, node_match = nm)
best_match = 0
list_of_best_matches = []
number_of_isomorphisms = 0
for mapping_i in GM.subgraph_isomorphisms_iter():
number_of_isomorphisms += 1
if number_of_isomorphisms == 10:
print "more than 10 color isomorphisms"
return None
score_mapping_i = 0
# print mapping_i
for j in mapping_i.keys():
# print self.grid_graph.node[j]['fig']
# print img_graph.node[mapping_i[j]]['fig']
if self.grid_graph.node[j]['fig'].shape == img_graph.node[mapping_i[j]]['fig'].shape:
score_mapping_i += 1
# print "+1"
if score_mapping_i == best_match:
# print
list_of_best_matches.append(mapping_i)
elif score_mapping_i > best_match:
list_of_best_matches = []
list_of_best_matches.append(mapping_i)
best_match = score_mapping_i
print list_of_best_matches
if len(list_of_best_matches) == 0:
print "FOUT BIJ KLEURHERKENNING !!! (NAKIJKEN)"
return None
if len(list_of_best_matches) > 1:
print "meerdere mogelijke matches gevonden, we returnen None"
return None
inv_map = {v:k for k, v in list_of_best_matches[0].items()}
# print "INVMAP"
# print inv_map
# ORIENTATION GEBEURD NU VIA MATRIX !!
# coordinates_img_fig1 = img_graph.node[0]['fig'].get_coordinate()
# coordinates_img_fig2 = img_graph.node[1]['fig'].get_coordinate()
# vector_in_img = (coordinates_img_fig2[0]-coordinates_img_fig1[0],coordinates_img_fig2[1]-coordinates_img_fig1[1])
# coordinates_grid_fig1 = self.grid_graph.node[inv_map[0]]['fig'].get_coordinate()
# coordinates_grid_fig2 = self.grid_graph.node[inv_map[1]]['fig'].get_coordinate()
# vector_in_grid = (coordinates_grid_fig2[0]-coordinates_grid_fig1[0],coordinates_grid_fig2[1]-coordinates_grid_fig1[1])
# turn_to_right = get_angle(vector_in_grid,vector_in_img)
# #TODO uitleg
# orientation = (turn_to_right + math.pi*3/2) % 2*math.pi
# VANAF HIER IS ALLES VOOR LEAST-SQUARES
w = inv_map.keys()[0]
x = img_graph.node[w]['fig'].get_coordinate()
x_reference = np.array((x[0],x[1]))
x_rel = np.zeros_like((2,1))
x_coordinate = inv_map[w] % 12
y_coordinate = math.floor(inv_map[w]/12)
x1 = x_coordinate*length + (y_coordinate % 2)*length/2
y1 = y_coordinate*height
b_reference = np.array((x1,y1))
b_rel = np.zeros_like((2,1))
i = 1
print "b4 while, invmap"
print inv_map
print "imggraph"
print img_graph.nodes()
for i in inv_map.keys():
# while i < len(inv_map.keys()):
# print img_graph.node[i]['fig']
x = img_graph.node[i]['fig'].get_coordinate()
x = np.array((x[0],x[1]))
x_rel = np.column_stack((x_rel,x-x_reference))
x_coordinate = inv_map[i] % 12
y_coordinate = math.floor(inv_map[i]/12)
x1 = x_coordinate*length + (y_coordinate % 2)*length/2
y1 = y_coordinate*height
b = np.array((x1,y1))
b_rel = np.column_stack((b_rel,b-b_reference))
# i+=1
# print x_rel
# print b_rel
at = np.linalg.lstsq(np.transpose(x_rel), np.transpose(b_rel))[0]
a = np.transpose(at)
# TODO
# center = (image.shape[1]/2, image.shape[0]/2)
location = np.dot(a,center-x_reference)+b_reference
alpha = math.atan(a[1][0]/a[0][0])
s = math.sqrt(a[0][0]**2 + a[1][0]**2)
if not math.copysign(1, math.cos(alpha)*s) == math.copysign(1, a[0][0]):
alpha = alpha-math.pi
orientation = (1.5*math.pi-(2*math.pi+alpha)) % (2*math.pi)
print orientation*180/math.pi
loc_and_or = {'location': location, 'orientation': orientation}
print loc_and_or
return loc_and_or
def get_isomorphic_subgraph_mapping(G1, G2):
"""Returns a dictionary mapping one graph onto another if one graph is a
subgraph of the other"""
Gm = iso.GraphMatcher(G1,G2,node_match=iso.categorical_node_match(['Element'],['C']))
Gm.is_isomorphic()
return Gm.mapping
def test_categorical_node_match():
nm = iso.categorical_node_match(['x', 'y', 'z'], [None]*3)
assert_true(nm(dict(x=1, y=2, z=3), dict(x=1, y=2, z=3)))
assert_true(not nm(dict(x=1, y=2, z=2), dict(x=1, y=2, z=1)))