def edge_attachment_test(seed=None): import math if seed==None: seed = npr.randint(1E6) print('rnd seed: %d'%seed) npr.seed(seed) random.seed(seed) nn = 30 G = nx.watts_strogatz_graph(n=nn, k=4, p=0.0) print('All new edges should lie close to the cycle') pos = {node:(math.cos(float(node)/nn * math.pi * 2),math.sin(float(node)/nn * math.pi * 2)) for node in G} def visualize_rewiring(G, added_edges_set, deled_edges_set, tpl_data): old_G = G.copy() old_G.remove_edges_from(added_edges_set) old_G.add_edges_from(deled_edges_set) print('added edges: ') print(added_edges_set) print('deled edges: ') print(deled_edges_set) benchmarks.editing_demo_draw(G=old_G, new_G=G, seed=1, pos=pos) print(tpl_data) pylab.show() params = {} params['edit_edges_tester'] = visualize_rewiring params['edge_edit_rate'] = [0.10] params['node_edit_rate'] = [0.] params['node_growth_rate'] = [0.] params['verbose'] = True algorithms.generate_graph(G, params=params)
def coarsening_test(): #visualizes coarsening import matplotlib as mpl def build_block_G(pin=0.1, pout=0.01, block_size=32, num_blocks=4): G = nx.Graph() nn = block_size*num_blocks G.add_nodes_from([i for i in range(nn)]) for nodeA in G: for nodeB in G: if nodeA / block_size == nodeB / block_size: if random.random() < pin: G.add_edge(nodeA, nodeB) else: if random.random() < pout: G.add_edge(nodeA, nodeB) G.remove_edges_from(G.selfloop_edges()) return G G = build_block_G(pin=0.1, pout=0.01) def visualize_coarsening(G, G_coarse, c_data): npr.seed(10) random.seed(10) pos = nx.fruchterman_reingold_layout(G) seeds = list(c_data['aggregates'].keys()) for seed in seeds: trapped_nodes = c_data['aggregates'][seed][:] trapped_nodes.remove(seed) #rnd_color = random.choice(['r', 'b', 'g', 'c', 'm', 'y', 'w']) #[npr.rand(), npr.rand(), npr.rand(), npr.rand()] #rnd_color = mpl.colors.rgb2hex((npr.rand(), npr.rand(), npr.rand())) #rnd_color = random.random() #rnd_color = random.choice(mpl.colors.cnames.keys()) rnd_color = (npr.rand(), npr.rand(), npr.rand(), 1.) color_seed = np.ones((1,4)) color_rest = np.ones((len(trapped_nodes),4)) for i,val in enumerate(rnd_color): color_seed[:,i] *= val color_rest[:,i] *= val nx.draw_networkx_nodes(G, pos=pos, nodelist=[seed], node_color=color_seed, cmap=pylab.hot, node_size=500, with_labels=True, node_shape='s') nx.draw_networkx_nodes(G, pos=pos, nodelist=trapped_nodes, node_color=color_rest, cmap=pylab.hot, node_size=200, with_labels=True, node_shape='o') nx.draw_networkx_edges(G, pos=pos, alpha=1.0) nx.draw_networkx_labels(G, pos=pos) pylab.show() params = {} params['do_coarsen_tester'] = visualize_coarsening params['edge_edit_rate'] = [0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001] params['node_edit_rate'] = [0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001] params['node_growth_rate'] = [0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001] algorithms.generate_graph(G, params=params)
def coarsening_test2(seed=None): #visualizes coarsening: stores the coarsening of the nodes, and then labels the original nodes based on their aggregates in the final level import matplotlib as mpl if seed==None: seed = npr.randint(1E6) print('rnd seed: %d'%seed) npr.seed(seed) random.seed(seed) G = graphutils.load_graph('data/mesh33.gml') #G = graphutils.load_graph('data-engineering/watts_strogatz98_power.elist') c_tree = [] def store_aggregation_chain(G, G_coarse, c_data): store_aggregation_chain.static_c_tree.append(c_data['home_nodes'].copy()) #print c_data['home_nodes'] #print store_aggregation_chain.static_c_tree store_aggregation_chain.static_c_tree = c_tree params = {} params['do_coarsen_tester'] = store_aggregation_chain params['node_edit_rate'] = [0, 0, 0, 0] #change to force coarsening dummy_replica = algorithms.generate_graph(G, params=params) node_colors = {} aggregate_colors = {seed:(npr.rand(), npr.rand(), npr.rand(), 1.) for seed in list(c_tree[-1].values())} for node in G: my_final_agg = node for c_set in c_tree: my_final_agg = c_set[my_final_agg] #this could be faster with union-find structure node_colors[node] = aggregate_colors[my_final_agg] clr = aggregate_colors[my_final_agg] G.node[node]['color'] = '%.3f %.3f %.3f'%(clr[0],clr[1],clr[2]) G.node[node]['label'] = '' all_nodes = G.nodes() color_array = np.ones((len(all_nodes),4)) for i,node in enumerate(all_nodes): color_array[i,:] *= node_colors[node] #pos = nx.fruchterman_reingold_layout(G) #nx.draw_networkx_nodes(G, pos=pos, nodelist=G.nodes(), node_color=color_array, cmap=pylab.hot, node_size=500, with_labels=True, node_shape='s') #nx.draw_networkx_edges(G, pos=pos, alpha=1.0) #nx.draw_networkx_labels(G, pos=pos) #pylab.show() gpath = 'output/coarsening_test_'+timeNow()+'.dot' gpath_fig = gpath+'.pdf' graphutils.write_graph(G=G, path=gpath) print('Writing graph image: %s ..'%gpath_fig) visualizer_cmdl = 'sfdp -Nwidth=0.10 -Nheight=0.10 -Nfixedsize=true -Nstyle=filled -Tpdf %s > %s &'%(gpath,gpath_fig) #visualizer_cmdl = 'sfdp -Nwidth=0.03 -Nheight=0.03 -Nfixedsize=true -Nstyle=solid -Tpdf %s > %s &'%(gpath,gpath_fig) retCode = os.system(visualizer_cmdl) time.sleep(1) subprocess.call(['xdg-open', gpath_fig])
def integrity_test(): import algorithms print 'Integrity testing ...' graphs = {'karate': nx.generators.karate_club_graph(), 'er200_025': nx.erdos_renyi_graph(n=200, p=0.25, seed=17), 'er200_0001': nx.erdos_renyi_graph(n=200, p=0.001, seed=42)} params = {'verbose':True, 'node_edit_rate': [0], 'edge_edit_rate': [0], 'node_growth_rate': [0], 'verbose':False} for name,G in graphs.items(): print name replica = algorithms.generate_graph(original=G, params=params) diff = graphutils.graph_graph_delta(G, replica) assert diff['new_nodes'] == [] assert diff['del_edges'] == [] assert diff['new_nodes'] == [] assert diff['del_edges'] == [] print 'Integrity test: PASSED'
def smoke_test(): import algorithms print 'Smoke testing ...' graphs = {'karate': nx.generators.karate_club_graph(), 'er200_025': nx.erdos_renyi_graph(n=200, p=0.25, seed=42), 'er200_0001': nx.erdos_renyi_graph(n=200, p=0.001, seed=42)} params = {'verbose':False, 'node_edit_rate': [0.1/(1.+i) for i in xrange(100)], 'edge_edit_rate': [0.1/(1.+i) for i in xrange(100)], 'node_growth_rate': [0.1/(1.+i) for i in xrange(100)]} for name,G in graphs.items(): print name #print ' nn=%d,ne=%d'%(G.number_of_nodes(), G.number_of_edges()) replica = algorithms.generate_graph(original=G, params=params) #print ' nn=%d,ne=%d'%(replica.number_of_nodes(), replica.number_of_edges()) assert G.selfloop_edges() == [] assert 0 == os.system(graphutils.MUSKETEER_EXAMPLE_CMD) print 'Smoke test: PASSED' print return
output_path = init_options['output_path'] visualizer = init_options['visualizer'] verbose = init_options['verbose'] write_graph = init_options['write_graph'] if verbose: print 'Loading: %s' % input_path G = graphutils.load_graph(path=input_path, params={ 'graph_type': graph_type, 'verbose': verbose }) if verbose: print 'Generating ...' new_G = algorithms.generate_graph(G, params=params) #optional #print graphutils.graph_graph_delta(G=G, new_G=new_G) #new_G = nx.convert_node_labels_to_integers(new_G, 1, 'default', True) #TODO: too many reports if params.get('stats_report_on_all_levels', False): model_Gs = [new_G.model_graph] Gs = [new_G] current_G = new_G.coarser_graph while current_G.coarser_graph != None: Gs.append(current_G) model_Gs.append(current_G.model_graph) current_G = current_G.coarser_graph model_Gs.reverse()
def coarsening_test(): #visualizes coarsening import matplotlib as mpl def build_block_G(pin=0.1, pout=0.01, block_size=32, num_blocks=4): G = nx.Graph() nn = block_size * num_blocks G.add_nodes_from([i for i in range(nn)]) for nodeA in G: for nodeB in G: if nodeA / block_size == nodeB / block_size: if random.random() < pin: G.add_edge(nodeA, nodeB) else: if random.random() < pout: G.add_edge(nodeA, nodeB) G.remove_edges_from(G.selfloop_edges()) return G G = build_block_G(pin=0.1, pout=0.01) def visualize_coarsening(G, G_coarse, c_data): npr.seed(10) random.seed(10) pos = nx.fruchterman_reingold_layout(G) seeds = list(c_data['aggregates'].keys()) for seed in seeds: trapped_nodes = c_data['aggregates'][seed][:] trapped_nodes.remove(seed) #rnd_color = random.choice(['r', 'b', 'g', 'c', 'm', 'y', 'w']) #[npr.rand(), npr.rand(), npr.rand(), npr.rand()] #rnd_color = mpl.colors.rgb2hex((npr.rand(), npr.rand(), npr.rand())) #rnd_color = random.random() #rnd_color = random.choice(mpl.colors.cnames.keys()) rnd_color = (npr.rand(), npr.rand(), npr.rand(), 1.) color_seed = np.ones((1, 4)) color_rest = np.ones((len(trapped_nodes), 4)) for i, val in enumerate(rnd_color): color_seed[:, i] *= val color_rest[:, i] *= val nx.draw_networkx_nodes(G, pos=pos, nodelist=[seed], node_color=color_seed, cmap=pylab.hot, node_size=500, with_labels=True, node_shape='s') nx.draw_networkx_nodes(G, pos=pos, nodelist=trapped_nodes, node_color=color_rest, cmap=pylab.hot, node_size=200, with_labels=True, node_shape='o') nx.draw_networkx_edges(G, pos=pos, alpha=1.0) nx.draw_networkx_labels(G, pos=pos) pylab.show() params = {} params['do_coarsen_tester'] = visualize_coarsening params['edge_edit_rate'] = [ 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001 ] params['node_edit_rate'] = [ 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001 ] params['node_growth_rate'] = [ 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001 ] algorithms.generate_graph(G, params=params)
def coarsening_test2(seed=None): #visualizes coarsening: stores the coarsening of the nodes, and then labels the original nodes based on their aggregates in the final level import matplotlib as mpl if seed == None: seed = npr.randint(1E6) print('rnd seed: %d' % seed) npr.seed(seed) random.seed(seed) G = graphutils.load_graph('data/mesh33.gml') #G = graphutils.load_graph('data-engineering/watts_strogatz98_power.elist') c_tree = [] def store_aggregation_chain(G, G_coarse, c_data): store_aggregation_chain.static_c_tree.append( c_data['home_nodes'].copy()) #print c_data['home_nodes'] #print store_aggregation_chain.static_c_tree store_aggregation_chain.static_c_tree = c_tree params = {} params['do_coarsen_tester'] = store_aggregation_chain params['node_edit_rate'] = [0, 0, 0, 0] #change to force coarsening dummy_replica = algorithms.generate_graph(G, params=params) node_colors = {} aggregate_colors = { seed: (npr.rand(), npr.rand(), npr.rand(), 1.) for seed in list(c_tree[-1].values()) } for node in G: my_final_agg = node for c_set in c_tree: my_final_agg = c_set[ my_final_agg] #this could be faster with union-find structure node_colors[node] = aggregate_colors[my_final_agg] clr = aggregate_colors[my_final_agg] G.node[node]['color'] = '%.3f %.3f %.3f' % (clr[0], clr[1], clr[2]) G.node[node]['label'] = '' all_nodes = G.nodes() color_array = np.ones((len(all_nodes), 4)) for i, node in enumerate(all_nodes): color_array[i, :] *= node_colors[node] #pos = nx.fruchterman_reingold_layout(G) #nx.draw_networkx_nodes(G, pos=pos, nodelist=G.nodes(), node_color=color_array, cmap=pylab.hot, node_size=500, with_labels=True, node_shape='s') #nx.draw_networkx_edges(G, pos=pos, alpha=1.0) #nx.draw_networkx_labels(G, pos=pos) #pylab.show() gpath = 'output/coarsening_test_' + timeNow() + '.dot' gpath_fig = gpath + '.pdf' graphutils.write_graph(G=G, path=gpath) print('Writing graph image: %s ..' % gpath_fig) visualizer_cmdl = 'sfdp -Nwidth=0.10 -Nheight=0.10 -Nfixedsize=true -Nstyle=filled -Tpdf %s > %s &' % ( gpath, gpath_fig) #visualizer_cmdl = 'sfdp -Nwidth=0.03 -Nheight=0.03 -Nfixedsize=true -Nstyle=solid -Tpdf %s > %s &'%(gpath,gpath_fig) retCode = os.system(visualizer_cmdl) time.sleep(1) subprocess.call(['xdg-open', gpath_fig])
id) WDS_services.has_solution(output_path, id) if __name__ == "__main__": init_options = initialize() input_path = init_options['input_path'] params = init_options['params'] output_path = init_options['output_path'] job_id = init_options['job_id'] if input_path == None: print("No input network given") sys.exit(2) G, network_data = WDS_services.read_inp_file(input_path) #WDS_services.plot_graph(G, network_data) new_G = algorithms.generate_graph(G, params=params, planar=True) nx.write_edgelist(new_G, "Generated_network.edges", data=False) #print (new_G) if output_path == None: t_str = timeNow() if not os.path.exists('output'): os.mkdir('output') if not os.path.isdir('output'): raise ValueError('Cannot write to directory "output"') output_path = 'output/' + os.path.splitext( os.path.basename(input_path))[0] + timeNow() generateAndValidate(job_id, G, new_G, network_data, output_path)
init_options = initialize() input_path = init_options["input_path"] params = init_options["params"] graph_type = init_options["graph_type"] output_path = init_options["output_path"] visualizer = init_options["visualizer"] verbose = init_options["verbose"] write_graph = init_options["write_graph"] if verbose: print "Loading: %s" % input_path G = graphutils.load_graph(path=input_path, params={"graph_type": graph_type, "verbose": verbose}) if verbose: print "Generating ..." new_G = algorithms.generate_graph(G, params=params) # optional # print graphutils.graph_graph_delta(G=G, new_G=new_G) # new_G = nx.convert_node_labels_to_integers(new_G, 1, 'default', True) # TODO: too many reports if params.get("stats_report_on_all_levels", False): model_Gs = [new_G.model_graph] Gs = [new_G] current_G = new_G.coarser_graph while current_G.coarser_graph != None: Gs.append(current_G) model_Gs.append(current_G.model_graph) current_G = current_G.coarser_graph model_Gs.reverse()
def generate(self, debug=False): ##prepare field #fill all field with walls self.field = [self.__char_wall * self.size[0]] * self.size[1] #make empty holes in each 2nd coord from (1,1): (3,1), (1,3), (3,3) and etc. for i in range(1, self.size[0] - 1, 2): for j in range(1, self.size[1] - 1, 2): self.set_cell(self.__char_empty, (i, j)) #generate maze (maybe recursion?.. no) current = (random.randrange(3, self.size[0] - 4) | 1, random.randrange(3, self.size[1] - 4) | 1 ) #self.player_coords stack = [current] while True: #current cell is visited, check nearest if debug: self.draw() time.sleep(0.015) self.set_cell(self.__char_visited, current) unvis = self.__get_unvisited_neighbours(current) #if no unvisited -- remove from stack, go back if len(unvis) == 0: stack = stack[:-1] if len(stack) == 0: break current = stack[-1] #else choose new way randomly else: r = random.randrange(len(unvis)) stack.append(unvis[r]) next_c = stack[-1] #draw way #TODO: more beautiful if current[0] == next_c[0]: for i in range(min(current[1], next_c[1]), max(current[1], next_c[1]) + 1): self.set_cell(self.__char_visited, (current[0], i)) else: for i in range(min(current[0], next_c[0]), max(current[0], next_c[0]) + 1): self.set_cell(self.__char_visited, (i, current[1])) current = next_c #generate rooms if self.conf.rooms(): self.rooms = [] for _ in range(random.randrange(2, 8)): for __ in range(5): #try to place a room 5 times room_size = [(3, 5), (5, 3)][random.randrange(2)] room_pos = ( random.randrange(3, self.size[0] - 3 - room_size[0]) | 1, random.randrange(3, self.size[1] - 3 - room_size[1]) | 1) ok = True for r in self.rooms: #check collision if self.__rooms_overlap(r, Room(room_pos, room_size)): ok = False break if ok: self.__place_room(room_pos, room_size) break ##TODO: generate loops #if self.conf.loops(): # pass #place exit self.exit_coords = ((self.size[0] & (~1)) - 1, (self.size[1] & (~1)) - 1) self.set_cell(self.__char_visited, self.exit_coords[0] - 1, self.exit_coords[1]) self.set_cell(self.__char_visited, self.exit_coords[0], self.exit_coords[1] - 1) if self.conf.rooms(): #self.__place_room( ((self.size[0]-1-3) | 1, (self.size[1]-1-3) | 1), (3,3) ) self.__place_room( (self.exit_coords[0] - 2, self.exit_coords[1] - 2), (3, 3)) self.exit_coords = (self.exit_coords[0] - 1, self.exit_coords[1] - 1) #if self.size[0] & 1 == 1: #TODO: wut?? if field has right side 1 cell wider # self.exit_coords = (self.size[0]-3, self.size[1]-3) #else: # self.exit_coords = (self.size[0]-4, self.size[1]-3) self.set_cell(self.__char_exit, self.exit_coords) #TODO: generate keys if self.conf.keys(): self.__generate_doors() #replace all visited cells with empty for i in range(len(self.field)): self.field[i] = self.field[i].replace(self.__char_visited, self.__char_empty) g = algorithms.generate_graph(self, self.player_coords, self.exit_coords) #TODO: temp! #print(g.verts) e = g.edges.items()