Example #1
0
def neighbor_bound(G, v, w, radius):
    g1 = nx.ego_graph(G, v, radius=radius, undirected=False)
    g2 = nx.ego_graph(G, w, radius=radius, undirected=False)
    if len(set(g1.edges()) & set(g2.edges())) > 0:
        return True
    else:
        return False
Example #2
0
def node_clique_number(G, nodes=None, cliques=None):
    """ Returns the size of the largest maximal clique containing
    each given node.

    Returns a single or list depending on input nodes.
    Optional list of cliques can be input if already computed.
    """
    if cliques is None:
        if nodes is not None:
            # Use ego_graph to decrease size of graph
            if isinstance(nodes, list):
                d = {}
                for n in nodes:
                    H = nx.ego_graph(G, n)
                    d[n] = max((len(c) for c in find_cliques(H)))
            else:
                H = nx.ego_graph(G, nodes)
                d = max((len(c) for c in find_cliques(H)))
            return d
        # nodes is None--find all cliques
        cliques = list(find_cliques(G))

    if nodes is None:
        nodes = list(G.nodes())   # none, get entire graph

    if not isinstance(nodes, list):   # check for a list
        v = nodes
        # assume it is a single value
        d = max([len(c) for c in cliques if v in c])
    else:
        d = {}
        for v in nodes:
            d[v] = max([len(c) for c in cliques if v in c])
    return d
Example #3
0
def build_activity_graph(activity_uri, activity_id):
    G = nx.DiGraph()
    
    q_activity_to_resource = render_template('activity_to_resource.q', activity_uri = activity_uri)
    
    G = build_graph(G, activity_uri, "activity", "concept", q_activity_to_resource)
    
    q_resource_to_activity = render_template('resource_to_activity.q', activity_uri = activity_uri)
    
    G = build_graph(G, activity_uri, "concept", "activity", q_resource_to_activity)
    
    print activity_uri, activity_id
    
    # origin_node_id = "{}".format(activity_id.lower())
    origin_node_id = activity_id
    
    G.node[origin_node_id]['type'] = 'origin'
    
    names = {}
    for n, nd in G.nodes(data=True):
        if nd['type'] == 'activity' or nd['type'] == 'origin':
            label = nd['label'].replace('Activity','').upper()            
            names[n] = label
        else :
            names[n] = nd['label']
            
    
    
    
    
    nx.set_node_attributes(G,'label', names)
    
    
    
    deg = nx.degree(G)
    nx.set_node_attributes(G,'degree',deg)
    
    
    outG = nx.ego_graph(G,origin_node_id,50)
    inG = nx.ego_graph(G.reverse(),origin_node_id,50)
    
    inG = inG.reverse()
    
    sG = nx.compose(outG,inG)
    
    
            
    
    assign_weights(sG, [])
            
            
    print sG.edges(data=True)
    
    
    
    g_json = json_graph.node_link_data(sG) # node-link format to serialize

    
    return g_json
Example #4
0
 def test_ego_distance(self):
     G=nx.Graph()                                                            
     G.add_edge(0,1,weight=2,distance=1)
     G.add_edge(1,2,weight=2,distance=2)
     G.add_edge(2,3,weight=2,distance=1) 
     assert_equal(sorted(nx.ego_graph(G,0,radius=3).nodes()),[0,1,2,3])
     eg=nx.ego_graph(G,0,radius=3,distance='weight')
     assert_equal(sorted(eg.nodes()),[0,1])
     eg=nx.ego_graph(G,0,radius=3,distance='distance')
     assert_equal(sorted(eg.nodes()),[0,1,2])
Example #5
0
def neighbor_bound(G, v, w, radius):
    """
    test if the node v and the node w are connected within a radius in graph G
    """
    g1 = nx.ego_graph(G, v, radius=radius, undirected=False)
    g2 = nx.ego_graph(G, w, radius=radius, undirected=False)
    if len(set(g1.edges()) & set(g2.edges())) > 0:
        return True
    else:
        return False
Example #6
0
def subgraph(G, node_list, radius=0):

    _graph = nx.ego_graph(G,node_list[0],radius=radius)

    for node in node_list[1:]:

        if G.has_node(node):
            _graph = nx.compose(_graph, nx.ego_graph(G, node, radius=radius))

    return _graph
Example #7
0
 def test_ego(self):
     G=nx.star_graph(3)
     H=nx.ego_graph(G,0)
     assert_true(nx.is_isomorphic(G,H))
     G.add_edge(1,11)
     G.add_edge(2,22)
     G.add_edge(3,33)
     H=nx.ego_graph(G,0)
     assert_true(nx.is_isomorphic(nx.star_graph(3),H))
     G=nx.path_graph(3)
     H=nx.ego_graph(G,0)
     assert_equal(H.edges(), [(0, 1)])
Example #8
0
def extract_ego_graph(G, activity_uri):
    sG = None
    inG = None
    outG = None
    
    app.logger.debug(u"Extracting ego graph (forward) {}".format(activity_uri))
    outG = nx.ego_graph(G,activity_uri,50)
    app.logger.debug(u"Extracting ego graph (backward) {}".format(activity_uri))
    inG = nx.ego_graph(G.reverse(),activity_uri,50)
    app.logger.debug(u"Reversing backward ego graph {}".format(activity_uri))
    inG = inG.reverse()
    app.logger.debug(u"Joining ego graphs {}".format(activity_uri))
    sG = nx.compose(outG,inG)
    
    return sG
def drawGraph(spammers):
    for i in range(1, ver + 1):
        if i in spammers:
            spamTag.append('r')
        else:
            spamTag.append('b')

    nodes = []
    for t in range(1, ver + 1):
        nodes.append(t);
    G = nx.Graph()
    G.add_nodes_from(nodes)
    G.add_edges_from(edges)
    #G=nx.generators.barabasi_albert_graph(len(nodes),len(edges)
    # find node with largest degree
    node_and_degree = G.degree()
    (largest_hub, degree) = sorted(node_and_degree.items(), key=itemgetter(1))[-1]
    # Create ego graph of main hub
    hub_ego = nx.ego_graph(G, largest_hub)
    # Draw graph
    pos = nx.spring_layout(hub_ego)
    nx.draw(hub_ego, pos, node_color=spamTag, node_size=50, with_labels=False)
    # Draw ego as large and red
    nx.draw_networkx_nodes(hub_ego, pos, nodelist=[largest_hub], node_size=300, node_color='r')
    plt.savefig(name+"/"+ name+'_MCLGraph.png')
    plt.show()
Example #10
0
def numCommunitiesEgoCentricNetwork(G, ego):
    ego_net = nx.ego_graph(G,n)
    ego_net.remove_node(ego)
    if len(ego_net.edges()) == 0:
        return len(ego_net.nodes())
    else:
        return findCommunities(ego_net)
def Similarity(G,asin,amazonBooks,maxnumber):
    simitems=[]
    neighbors=(G.neighbors(asin))

#egoNetwork: get_ego_network(coPurchaseGraph, asin, radius = 1)
#threshold = median(weights of edges in egoNetwork)

    ego = networkx.ego_graph(G, asin, radius=1)
    
    mediansimilarity =statistics.median([ego[x][asin]['weight'] for x in neighbors ])   
    similaritydict={}
    threshold = mediansimilarity
#    islandGraph: A graph, initialized to null
    gIslands = networkx.Graph()
    #create islandGraph with the threshold
    for f,t,e in ego.edges(data = True):
        if(e['weight'] > threshold):
            gIslands.add_edge(f,t,e)
    nodelist=gIslands.nodes(data = False)
    for n in nodelist:       
        if(n != asin):
         if(ego[n][asin]['weight'] == 0):
             print("error: edge weight is zero")
             similaritydict[n]=maxnumber
         else:
#    Rank the nodes with the Sales Rank as follows
#   	Rank[node] = salesRank/weight
          similaritydict[n]=(amazonBooks[n]['SalesRank'])/(ego[n][asin]['weight']) 
          #simItems = Sort(Rank)
    sortedsim=(sorted(similaritydict.items(), key = lambda x:x[1])[:100])
    simitems = [x[0] for x in sortedsim]
    return simitems
Example #12
0
def get_weighted_ego_graph(graph, character, hops=1):
    # Graph and Position
    ego = nx.ego_graph(graph, character, hops)
    pos = nx.spring_layout(ego)
    plt.figure(figsize=(12,12))
    plt.axis('off')

    # Coloration and Configuration
    ego.node[character]["TYPE"] = "center"
    valmap = { "hero": 0.0, "center": 1.0 }
    types  = nx.get_node_attributes(ego, "TYPE")
    values = [valmap.get(types[node], 0.25) for node in ego.nodes()]

    char_edges = ego.edges(data=True, nbunch=[character,])
    nonchar_edges = ego.edges(nbunch=[n for n in ego.nodes() if n != character])
    elarge=[(u,v) for (u,v,d) in char_edges if d['weight'] >=0.12]
    esmall=[(u,v) for (u,v,d) in char_edges if d['weight'] < 0.12]
    print set([d['weight'] for (u,v,d) in char_edges])

    # Draw
    nx.draw_networkx_nodes(ego, pos,
                           node_size=200,
                           node_color=values,
                           cmap=plt.cm.Paired, with_labels=False)

    nx.draw_networkx_edges(ego,pos,edgelist=elarge,
                        width=1.5, edge_color='b')
    nx.draw_networkx_edges(ego,pos,edgelist=esmall,
                        width=1,alpha=0.5,edge_color='b',style='dashed')
    nx.draw_networkx_edges(ego,pos,edgelist=nonchar_edges,
                        width=0.5,alpha=0.2,style='dashed')

    plt.show()
Example #13
0
def get_ego_graph(graph, character):
    """
    Expecting a graph_from_gdf
    """

    # Graph and Position
    ego = nx.ego_graph(graph, character, 3)
    pos = nx.spring_layout(ego)
    plt.figure(figsize=(12,12))
    plt.axis('off')

    # Coloration and Configuration
    ego.node[character]["TYPE"] = "center"
    valmap = { "comic": 0.25, "hero": 0.54, "center": 0.87 }
    types  = nx.get_node_attributes(ego, "TYPE")
    values = [valmap.get(types[node], 0.25) for node in ego.nodes()]

    # Draw
    nx.draw_networkx_edges(ego, pos, alpha=0.4)
    nx.draw_networkx_nodes(ego, pos,
                           node_size=80,
                           node_color=values,
                           cmap=plt.cm.hot, with_labels=False)

    #plt.show()
    plt.savefig("figure/longbow_ego_2hop.png")
Example #14
0
 def test_ego(self):
     G = nx.star_graph(3)
     H = nx.ego_graph(G, 0)
     assert_true(nx.is_isomorphic(G, H))
     G.add_edge(1, 11)
     G.add_edge(2, 22)
     G.add_edge(3, 33)
     H = nx.ego_graph(G, 0)
     assert_true(nx.is_isomorphic(nx.star_graph(3), H))
     G = nx.path_graph(3)
     H = nx.ego_graph(G, 0)
     assert_edges_equal(H.edges(), [(0, 1)])
     H = nx.ego_graph(G, 0, undirected=True)
     assert_edges_equal(H.edges(), [(0, 1)])
     H = nx.ego_graph(G, 0, center=False)
     assert_edges_equal(H.edges(), [])
    def ego_graph(self, radius=1, types=None, min_degree=None):
        '''Generate an undirected ego graph around the current entity.

        :param radius: radius or degree of the ego graph; defaults to 1
        :param types: node types to be included in the graph (e.g., restrict
            to people and organizations only)
        :param min_degree: optionally filter nodes in the generated ego graph
            by minimum degree
        '''
        network = network_data()
        undirected_net = network.to_undirected()

        # filter network *before* generating ego graph
        # so we don't get disconnected nodes
        if types is not None:
            for n in undirected_net.nodes():
                if 'type' not in undirected_net.node[n] or \
                   undirected_net.node[n]['type'] not in types:
                    undirected_net.remove_node(n)

        # converted multidigraph to undirected
        # to make it possible to find all neighbors,
        # not just outbound connections
        # (should be a way to get this from a digraph...)

        eg = nx.ego_graph(undirected_net, self.nx_node_id,
                            radius=radius)
        if min_degree is not None:
            return filter_graph(eg, min_degree=min_degree)
        return eg
Example #16
0
    def get_triadic_recommendations(self, commid, userid, k):
        """ Given a graph give neighbor of neighbor recommendations 
        """
        # get the ego network of the user 2 step
        G = self.community_data[commid]['graph']
        EG = nx.ego_graph(G, userid, 2)
        
        
        nbrs = []
        for n in EG.neighbors(userid):
            if n != userid:
                for non in G.neighbors(n):
                    if non != userid and non in self.tsusers:
                        nbrs.append(n)


        #print "neighbors of neighbors on", nbrs
        # get neighbors and neighbors of neighbors
        # that is not you
        # neighbors = set(EG.neighbors) - set([userid])
        #nons = set(neighbors_of_neighbors)-set([userid])

        # for 
        reccos = []
        for n in nbrs:
            reason = "neighbor who likes a townsquare member"
            reccos.append((n, reason))
        
        if len(reccos) >= k:
            return reccos[0:k]
        return reccos
Example #17
0
    def execute(self):
        """
        Execute Demon algorithm

        """

        for n in self.g.nodes():
            self.g.node[n]['communities'] = [n]

        all_communities = {}

        for ego in tqdm.tqdm(nx.nodes(self.g), ncols=35, bar_format='Exec: {l_bar}{bar}'):

            ego_minus_ego = nx.ego_graph(self.g, ego, 1, False)
            community_to_nodes = self.__overlapping_label_propagation(ego_minus_ego, ego)

            # merging phase
            for c in community_to_nodes.keys():
                if len(community_to_nodes[c]) > self.min_community_size:
                    actual_community = community_to_nodes[c]
                    all_communities = self.__merge_communities(all_communities, actual_community)

        # write output on file
        if self.file_output:
            with open(self.file_output, "w") as out_file_com:
                for idc, c in enumerate(all_communities.keys()):
                    out_file_com.write("%d\t%s\n" % (idc, str(sorted(c))))

        return list(all_communities.keys())
Example #18
0
 def get_center_ego(graph):
     bt = nx.betweenness_centrality(graph)
     print(bt)
     for (node, betweenness) in sorted(bt.items(), key=lambda x: x[1], reverse=True):
         nodes = nx.ego_graph(graph, node).nodes()
         print(nodes)
         return nodes
def get_ego_graph(g, name, radius=2):
    """
    retuns ego graph to given radius for given node
    
    this is useful for getting similar artists to a given artist that someboy
    really likes
    """
    return net.ego_graph(g, name, radius)
Example #20
0
def ego(keyid):
    logging.info('Getting ego network for {}'.format(keyid))
    ego = nx.ego_graph(G, keyid, undirected=True, radius=2)
    logging.info('Computing layout')
    layout = nx.spring_layout(ego)
    data = json_graph.node_link_data(ego)
    data['layout'] = [x.tolist() for x in layout.values()]
    return Response(json.dumps(data), mimetype='application/json')
Example #21
0
def visualize_node(graph, node):
    if type(graph) is not nx.Graph:
        graph = create_network(graph)
    hub_ego = nx.ego_graph(graph, node)
    pos = nx.spring_layout(hub_ego)
    nx.draw(hub_ego, pos, node_color='b', node_size=900)
    nx.draw_networkx_nodes(hub_ego, pos, nodelist=[node], node_size=600, node_color='r')
    plt.show()
def largest_hub_in_graph(G):
    # find node with largest degree
    node_and_degree = G.degree()
    (largest_hub, degree) = sorted(node_and_degree.items(), key=itemgetter(1))[-1]
    # Create ego graph of main hub
    hub_ego = nx.ego_graph(G, largest_hub)
    hub_degree = nx.degree(G, largest_hub)
    print "largest hub ID: " + str(largest_hub) + "\t" + "largest hub degree: " + str(hub_degree)
def get_ones_net(sn,core_name):
    try:
        ones_net=networkx.ego_graph(sn,core_name)
        print '%s的交往圈有%d人,社交网络为:'%(core_name,len(ones_net))
        for node in ones_net.nodes():
            print node
    except Exception as err:
        print err
 def __init__(self, view, controller, use_ego_betw=False, **kwargs):
     super(CacheLessForMore, self).__init__(view, controller)
     topology = view.topology()
     if use_ego_betw:
         self.betw = dict((v, nx.betweenness_centrality(nx.ego_graph(topology, v))[v])
                          for v in topology.nodes_iter())
     else:
         self.betw = nx.betweenness_centrality(topology)
 def ego_plot(self, radius, name):
     inter_graph = nx.ego_graph(self.graph_without_self, name, radius = radius)
     colors = self._color_distance_self(inter_graph, radius, name)
     figsize(20, 20)
     nx.draw(inter_graph, node_color = [plt.cm.RdBu(color) for color in colors], alpha = 0.5, edge_color='lightgrey', font_size=10) 
     self._add_legend_self(radius, colors, name)
     title(name + ' ego graph', size = 20, weight = 'bold')
     return plt.show()
def DrawRec(secondlist,G,asin):
    ego = networkx.ego_graph(G, asin, radius=1)
    pos=networkx.spring_layout(ego)
    matplotlib.pyplot.figure(figsize=(15,15))
    networkx.draw_networkx_nodes(ego,pos,node_color='g',node_size=600,alpha=0.8)
    networkx.draw_networkx_nodes(ego,pos,nodelist=[asin],node_color='r',node_size=600)
    networkx.draw_networkx_edges(ego,pos)
    networkx.draw_networkx_nodes(ego,pos,nodelist=secondlist,node_color='b',node_size=600)
Example #27
0
def effective_size(G,n):
    # This treats directed graphs as undirected
    # Could be modified to handle directed graphs differently
    # Ignores weights 
    ndeg=float(G.degree(n)) # number of neighbors (alters)
    E=nx.ego_graph(G,n,center=False,undirected=True) 
    deg=E.degree() # degree of neighbors not including n
    # degree of n - average deg of nbrs
    return ndeg-sum(deg.values())/(ndeg-1.0) 
Example #28
0
def ego():
    '''
    This node is deceptively connected because it's from the index
    (page 750 of volume2.pdf).
    '''
    g_9_56_090 = nx.ego_graph(g, '9.56.090')
    nx.draw_spring(g_9_56_090)
    plt.savefig("9.56.090.png")
    print nodes['9.56.090']
Example #29
0
def citeseer_ego():
    _, _, G = data.Graph_load(dataset='citeseer')
    G = max(nx.connected_component_subgraphs(G), key=len)
    G = nx.convert_node_labels_to_integers(G)
    graphs = []
    for i in range(G.number_of_nodes()):
        G_ego = nx.ego_graph(G, i, radius=3)
        if G_ego.number_of_nodes() >= 50 and (G_ego.number_of_nodes() <= 400):
            graphs.append(G_ego)
    return graphs
def create_egonet_features(g):
    egoNetList = []
    for n in nx.nodes_iter(g):
        resultObj = Result()
        resultObj.egoNetGraph = nx.ego_graph(g, n, radius=1, center=True, undirected=False, distance=None)
        resultObj.egoNetDegree = nx.number_of_nodes(resultObj.egoNetGraph)
        resultObj.nofEdges = nx.number_of_edges(resultObj.egoNetGraph)
        egoNetList.append(resultObj)
 #       print resultObj
    return egoNetList
Example #31
0
def get_community(G: nx.Graph,
                  n,
                  hops: int,
                  max,
                  maxCore: bool,
                  visited={},
                  more_metrics=True):
    e = nx.ego_graph(G, n['id'], hops)

    # filter here before k-core
    #
    # here we filter out the nodes that doesn't
    # meet the domination requirements
    # currently we select nodes that have dom > 0
    # but this can change to a pruning function
    community = [
        x for x, y in e.nodes(data=True)
        if (y['dom'] > 0 and y['id'] not in visited)
    ]
    community = G.subgraph(community)

    k_core = nx.k_core(community)
    max_k_core = min(k_core.degree(), key=lambda x: x[1])[1]

    if maxCore:
        res = k_core
    else:
        res = community

    # mark nodes as visited
    # res = [x for x,y in res.nodes(data=True) if y['id'] not in visited  ]
    # mod = nx_comm.modularity(G, community)
    data1 = json_graph.node_link_data(res, {"link": "edges"})

    data1['stats'] = get_graph_stats(res, max['dom'], max_k_core, more_metrics)
    data1['stats']['init'] = n['id']

    return (data1, res)
Example #32
0
def getMaxInOutEdges(G):
    nodes = G.nodes()
    max_in = 1
    max_out = 1
    max_ego = 1
    max_ego_out = 1
    for node_id in nodes:
        max_in = max(max_in, G.degree(node_id))
        max_out = max(max_out, G.out_degree(node_id))

        ego_net = nx.ego_graph(G, node_id)
        ego_edges = ego_net.number_of_edges()
        max_ego = max(max_ego, ego_edges)

        nbrs = nx.neighbors(G, node_id)
        nbrs_total_edges = 0
        for nbr in nbrs:
            nbrs_total_edges += G.out_degree(nbr)
            nbrs_total_edges += G.degree(nbr)

            max_ego_out = max(max_ego_out, nbrs_total_edges - ego_edges)

    return max_in, max_out, max_ego, max_ego_out
Example #33
0
def scan_statistic(mygs, i):
    """
    Computes scan statistic-i on a set of graphs

    Required Parameters:
        mygs:
            - Dictionary of graphs
        i:
            - which scan statistic to compute
    """
    ss = OrderedDict()
    for key in mygs.keys():
        g = mygs[key]
        tmp = np.array(())
        for n in g.nodes():
            sg = nx.ego_graph(g, n, radius=i)
            tmp = np.append(
                tmp,
                np.sum([
                    sg.get_edge_data(e[0], e[1])['weight'] for e in sg.edges()
                ]))
        ss[key] = tmp
    return ss
Example #34
0
def hopSortDemon(G,epsilon):
    visitedSequece = computeCentrilityandSort(G)
    # 存储节点是否该访问的标志
    visiteFlag = {}
    for n in G.nodes():
        visiteFlag[n] = False  # 所有节点初始化
    '找邻居社团,构建超图构成的子图H'
    allCommunities={}
    for ego in visitedSequece:
        if (visiteFlag[ego] == False):
            ego_minus_ego = nx.ego_graph(G, ego, 1, center=False)  ##不包含ego节点,1跳邻居
            '访问标志'
            for n in ego_minus_ego:
                visiteFlag[n] = True
            visiteFlag[ego] = True

            '重叠LPA'
            community_to_nodes=overlappingLPA(ego_minus_ego,ego)

            '合并'
            for id1,com1 in community_to_nodes.items():
                allCommunities=absoluteMerge(allCommunities,id1,com1,epsilon)
    return allCommunities
Example #35
0
def ego_networks(g, level=1):
    """
    Ego-networks returns overlapping communities centered at each nodes within a given radius.

    :param g: a networkx/igraph object
    :param level: extrac communities with all neighbors of distance<=level from a node. Deafault 1
    :return: NodeClustering object


    :Example:

    >>> from cdlib import algorithms
    >>> import networkx as nx
    >>> G = nx.karate_club_graph()
    >>> coms = algorithms.ego_networks(G)
    """

    g = convert_graph_formats(g, nx.Graph)

    coms = []
    for n in g.nodes():
        coms.append(list(nx.ego_graph(g, n, radius=level).nodes()))
    return NodeClustering(coms, g, "Ego Network", method_parameters={"level": 1}, overlap=True)
Example #36
0
    def initialize_item_distribution(self, initial_item_distribution=None):
        temp_dict = {}
        if self.item_distribution == 'uniform':
            items_per_node = self.num_items / self.num_nodes
            for i in self.G.nodes():
                temp_dict[i] = items_per_node

        elif self.item_distribution == 'direct':
            out_degs = self.G.out_degree()
            total = np.sum(out_degs.values())
            for i in self.G.nodes():
                temp_dict[i] = self.num_items * out_degs[i] / total

        elif self.item_distribution == 'inverse':
            out_degs = self.G.out_degree()
            for i in out_degs:
                out_degs[i] = (self.num_nodes - 1 -
                               out_degs[i]) / (self.num_nodes - 1)
            total = np.sum(out_degs.values())
            for i in self.G.nodes():
                temp_dict[i] = self.num_items * out_degs[i] / total
        elif self.item_distribution == 'ego':
            random_node = np.random.choice(self.G.nodes())
            ego_graph = nx.ego_graph(self.G, random_node,
                                     self.ego_graph_radius)
            for i in self.G.nodes():
                if i in ego_graph.nodes():
                    temp_dict[i] = 0.7 * self.num_items / len(
                        ego_graph.nodes())
                else:
                    temp_dict[i] = 0.3 * self.num_items / (
                        self.num_nodes - len(ego_graph.nodes()))
        else:  # custom
            assert initial_item_distribution is not None, "Initial item distribution not provided"
            temp_dict = initial_item_distribution

        return temp_dict
def create_sausage_buffer_gdf(G_proj, orig_point, buffer=buffer_local, length=distance, intersection_tolerance = 15):
    """
    Create sausage buffer geodataframe for a sample point
    
    Parameters
    ----------
    G_proj : graphml
        OSM street network graphml
    orig_point : int
        the current node to start from
    buffer : float
        distance to buffer 

    length : float
        distance to search 

    intersection_tolerance: float
        nodes within this distance (in graph’s geometry’s units) will be dissolved into a single intersection

    Returns
    -------
    subgraph geodataframe
    """

    # locate closest node on network to 
    orig_node = ox.get_nearest_node(G_proj, orig_point, return_dist=True)
    subgraph_proj = nx.ego_graph(G_proj, orig_node[0], radius=length, distance='length')
    subgraph_gdf = ox.graph_to_gdfs(subgraph_proj, nodes=False, edges=True, fill_edge_geometry=True)
    # create buffer polygon geometry to dataframe
    if len(subgraph_gdf) > 0:
        subgraph_gdf['geometry'] = subgraph_gdf.geometry.buffer(buffer) 
        #link original node id reference
        subgraph_gdf['node_id'] = orig_node[0]
    else:
        subgraph_gdf['geometry'] = 0
        subgraph_gdf['node_id'] = 0
    return(subgraph_gdf) #output is smaple point subgraph with buffer polygon geometry and original node id reference
Example #38
0
def local_efficiency(G):
    """Returns the average local efficiency of the graph.

    The *efficiency* of a pair of nodes in a graph is the multiplicative
    inverse of the shortest path distance between the nodes. The *local
    efficiency* of a node in the graph is the average global efficiency of the
    subgraph induced by the neighbors of the node. The *average local
    efficiency* is the average of the local efficiencies of each node [1]_.

    Parameters
    ----------
    G : :class:`networkx.Graph`
        An undirected graph for which to compute the average local efficiency.

    Returns
    -------
    float
        The average local efficiency of the graph.

    Notes
    -----
    Edge weights are ignored when computing the shortest path distances.

    See also
    --------
    global_efficiency

    References
    ----------
    .. [1] Latora, Vito, and Massimo Marchiori.
           "Efficient behavior of small-world networks."
           *Physical Review Letters* 87.19 (2001): 198701.
           <http://dx.doi.org/10.1103/PhysRevLett.87.198701>

    """
    # TODO This summation can be trivially parallelized.
    return sum(global_efficiency(nx.ego_graph(G, v)) for v in G) / len(G)
Example #39
0
def get_component_border_neighborhood_set(networkx_graph,
                                          component,
                                          k,
                                          ego_graph_dict=None):
    '''
    Returns a set containing the nodes in the k-hop border of the specified component

    component: 1D tensor of node IDs in the component (with possible padding)
    k: number of hops around the component that is included in the border set
    ego_graph_dict: dictionary mapping from node id to precomputed ego_graph for the node
    '''

    # First, remove any padding that exists in the component
    if type(component) is torch.Tensor:
        component_inds_non_neg = (component !=
                                  config.PAD_VALUE).nonzero().view(-1)
        component_set = {int(n) for n in component[component_inds_non_neg]}
    else:
        component_set = set(component)

    # calculate the ego graph for each node in the connected component & take the union of all nodes
    neighborhood = set()
    for node in component_set:
        if ego_graph_dict == None:  # if it hasn't already been computed, calculate the ego graph (i.e. induced subgraph of neighbors centered at node with specified radius)
            ego_g = nx.ego_graph(networkx_graph, node, radius=k).nodes()
        else:
            ego_g = ego_graph_dict[
                node -
                1]  #NOTE: nodes in dict were indexed with 0, while our nodes are indexed starting at 1

        neighborhood = neighborhood.union(set(ego_g))

    # remove from the unioned ego sets all nodes that are actually in the component
    # this will leave only the nodes that are in the k-hop border, but not in the subgraph component
    border_nodes = neighborhood.difference(component_set)

    return border_nodes
Example #40
0
    def get(self):

        # get args:
        # action = request.args.get('action', 0, type=str)
        focal_node_id_list = request.args.get('focal_node_id_list', '', type=str).split(',')
        hops = request.args.get('hops', 0, type=int)
        # node_list = request.args.get('node_list', '', type=str)

        # if node_list != '': 
        #     node_list = json.loads(node_list)

        # used to keep track of all nodes and their x,y coords of all nodes currently on display   
        # curr_node_pos_dict = request.args.get('curr_node_positions', '', type=str)
        # if curr_node_pos_dict != '':
        #     curr_node_pos_dict = json.loads(curr_node_pos_dict)
        #     curr_node_list = list(curr_node_pos_dict.keys())

        # used to retain current scaling and view position to pass back to client-side (to maintain view)
        # current_scale = request.args.get('curr_scale')
        # current_viewPos = request.args.get('curr_viewPos')


        print('ACTION: HOPS INDUCTION')

        all_graph_data = Graph.get_graph()

        node_list = []
        print(focal_node_id_list)
        for node in focal_node_id_list:
            print('node', node)
            node_list = node_list + list(nx.ego_graph(all_graph_data, node, radius=hops, center=True, undirected=True, distance=None).nodes)

        G = all_graph_data.subgraph(node_list)

        response = graph_to_json(G, focal_node_id_list = focal_node_id_list)

        return response
Example #41
0
    def execute(self):
        """
        Execute Demon algorithm

        """

        for n in self.g.nodes():
            self.g.node[n]['communities'] = [n]

        all_communities = {}

        for ego in tqdm.tqdm(nx.nodes(self.g),
                             ncols=35,
                             bar_format='Exec: {l_bar}{bar}'):

            ego_minus_ego = nx.ego_graph(self.g, ego, 1, False)
            community_to_nodes = self.__overlapping_label_propagation(
                ego_minus_ego, ego)

            # merging phase
            for c in community_to_nodes.keys():
                if len(community_to_nodes[c]) > self.min_community_size:
                    actual_community = community_to_nodes[c]
                    all_communities = self.__merge_communities(
                        all_communities, actual_community)

        if self.file_output is not False:
            out_file_com = open(
                "%s/demon_%s_communities.txt" % (self.base, self.epsilon), "w")
            idc = 0
            for c in all_communities.keys():
                out_file_com.write("%d\t%s\n" % (idc, str(sorted(c))))
                idc += 1
            out_file_com.flush()
            out_file_com.close()
        else:
            return all_communities
Example #42
0
    async def _construct_isochrones(self) -> None:
        """
        TODO: Add docstring
        """
        (ys, xs) = list(zip(*self._facilities))
        nodes = osmnx.get_nearest_nodes(self._graph, xs, ys)

        # Projects the graph to UTM
        self._graph = osmnx.project_graph(self._graph)

        # Adds an edge attribute for time in minutes required to traverse each
        # edge
        meters_per_minute = TRAVEL_SPEED * 1000 / 60  # km/hour to m/minute
        for (u, v, k, data) in self._graph.edges(data=True, keys=True):
            data['time'] = data['length'] / meters_per_minute

        # Makes the isochrone polygons for isochrone map
        self._isochrones = []
        for found_node in nodes:
            subgraph = networkx.ego_graph(self._graph,
                                          found_node,
                                          radius=self._trip_time,
                                          distance='time')
            node_points = [
                Point((data['x'], data['y']))
                for (node, data) in subgraph.nodes(data=True)
            ]
            bounding_poly = geopandas.GeoSeries(
                node_points).unary_union.convex_hull

            self._isochrones.append(bounding_poly)

        self._clean_isochrones_state()
        # Causes the `isochrones_constructed` event
        await self.isochrones_constructed()
        # Saves data of isochrones
        await self._save_isochrones()
Example #43
0
def divide_local_neighbourhood(mesh, radius):
    """Divide the mesh into locally connected patches of a given size.

    All nodes will be assigned to a patches but patches will be overlapping.


    Parameters
    ----------
    mesh :      trimesh.Trimesh
    radius :    float

    Returns
    -------
    list of sets

    """
    assert isinstance(mesh, tm.Trimesh)
    assert isinstance(radius, numbers.Number)

    # Generate a graph for mesh
    G = mesh.vertex_adjacency_graph
    # Use Eucledian distance for edge weights
    edges = np.array(G.edges)
    e1 = mesh.vertices[edges[:, 0]]
    e2 = mesh.vertices[edges[:, 1]]
    dist = np.sqrt(np.sum((e1 - e2)**2, axis=1))
    nx.set_edge_attributes(G, dict(zip(G.edges, dist)), name='weight')

    not_seen = set(G.nodes)
    patches = []
    while not_seen:
        center = not_seen.pop()
        sg = nx.ego_graph(G, center, distance='weight', radius=radius)
        nodes = set(sg.nodes)
        patches.append(nodes)
        not_seen -= nodes
Example #44
0
def draw_ego_hub(G: Graph, output_name: str) -> None:
    """
    Draws the ego hub.

    Args:
        G (Graph): the input graph
        output_name (string): the output file name
    """
    # From https://networkx.github.io/documentation/latest/auto_examples/drawing/plot_ego_graph.html?highlight=hub
    node_and_degree = G.degree()
    (largest_hub, degree) = sorted(node_and_degree, key=itemgetter(1))[-1]
    # Create ego graph of main hub
    hub_ego = nx.ego_graph(G, largest_hub)
    # Draw graph
    pos = nx.spring_layout(hub_ego)
    nx.draw(hub_ego, pos, node_color='b', node_size=300, with_labels=True)
    # Draw ego as large and red
    nx.draw_networkx_nodes(hub_ego,
                           pos,
                           nodelist=[largest_hub],
                           node_size=300,
                           node_color='r')
    plt.savefig("images/" + output_name + "ego_hub.png")
    plt.close()
Example #45
0
 def __call__(self, G, r):
     from pygrank.algorithms.pagerank import PageRank
     G = G.to_directed()
     ranks = PageRank().rank(G, {r: 1})
     ranks = {v: ranks[v] / G.degree(v) for v in G}
     max_grap = 0
     threshold = 0
     prev_rank = None
     for v, rank in sorted(ranks.items(),
                           key=lambda item: item[1],
                           reverse=True):
         if prev_rank is not None:
             gap = (prev_rank - rank)
             print(gap)
             if gap > max_grap:
                 max_grap = gap
                 threshold = rank
         prev_rank = rank
     T = nx.DiGraph()
     T.add_node(r)
     for u, v in G.edges():
         if ranks[u] <= threshold and ranks[v] <= threshold:
             T.add_edge(u, v)
     return nx.ego_graph(T, r, radius=1000000)
Example #46
0
def create(args):

    if args.graph_type == 'citeseer':

        _, _, G = graph_load(args.graph_type)
        G = max(nx.connected_component_subgraphs(G), key=len)
        G = nx.convert_node_labels_to_integers(G)
        graphs = []
        for i in range(G.number_of_nodes()):
            # number of egos = number of nodes
            # person knowing other person
            G_ego = nx.ego_graph(G, i, radius=3)
            if G_ego.number_of_nodes() >= 50 and (G_ego.number_of_nodes() <=
                                                  400):
                graphs.append(G_ego)

        args.max_prev_node = 250

    elif args.graph_type == 'barabasi':
        graphs = []
        for i in range(100, 200):
            for j in range(4, 5):
                for k in range(5):
                    graphs.append(nx.barabasi_albert_graph(i, j))

        args.max_prev_node = 130

    elif args.graph_type == 'barabasi_small':
        graphs = []
        for i in range(4, 21):
            for j in range(3, 4):
                for k in range(10):
                    graphs.append(nx.barabasi_albert_graph(i, j))
        args.max_prev_node = 20

    return graphs
Example #47
0
def ego_nets(graph, radius=3, **kwargs):
    # color center
    egos = []
    n = graph.num_nodes
    # A proper deepsnap.G should have nodes indexed from 0 to n-1
    for i in range(n):
        egos.append(nx.ego_graph(graph.G, i, radius=radius))
    # relabel egos: keep center node ID, relabel other node IDs
    G = graph.G.__class__()
    id_bias = n
    for i in range(len(egos)):
        G.add_node(i, **egos[i].nodes(data=True)[i])
    for i in range(len(egos)):
        keys = list(egos[i].nodes)
        keys.remove(i)
        id_cur = egos[i].number_of_nodes() - 1
        vals = range(id_bias, id_bias + id_cur)
        id_bias += id_cur
        mapping = dict(zip(keys, vals))
        ego = nx.relabel_nodes(egos[i], mapping, copy=True)
        G.add_nodes_from(ego.nodes(data=True))
        G.add_edges_from(ego.edges(data=True))
    graph.G = G
    graph.node_id_index = torch.arange(len(egos))
Example #48
0
def cds_length(
    graph,
    radius=5,
    mode="sum",
    name="cds_len",
    degree="degree",
    length="mm_len",
    distance=None,
    verbose=True,
):
    """
    Calculates length of cul-de-sacs for subgraph around each node if radius is set,
    or for whole graph, if ``radius=None``.

    Subgraph is generated around each node within set radius. If ``distance=None``,
    radius will define topological distance, otherwise it uses values in distance
    attribute.


    Parameters
    ----------
    graph : networkx.Graph
        Graph representing street network.
        Ideally generated from GeoDataFrame using :func:`momepy.gdf_to_nx`
    radius : int
        Include all neighbors of distance <= radius from n
    mode : str (default 'sum')
        if ``'sum'``, calculate total length, if ``'mean'`` calculate mean length
    name : str, optional
        calculated attribute name
    degree : str
        name of attribute of node degree (:py:func:`momepy.node_degree`)
    length : str, optional
        name of attribute of segment length (geographical)
    distance : str, optional
        Use specified edge data key as distance.
        For example, setting ``distance=’weight’`` will use the edge ``weight`` to
        measure the distance from the node n.
    verbose : bool (default True)
        if True, shows progress bars in loops and indication of steps


    Returns
    -------
    Graph
        networkx.Graph if radius is set
    float
        length of cul-de-sacs for graph if ``radius=None``

    Examples
    --------
    >>> network_graph = mm.cds_length(network_graph, radius=9, mode='mean')
    """
    # node degree needed beforehand
    netx = graph.copy()

    for u, v, k in netx.edges(keys=True):
        if netx.nodes[u][degree] == 1 or netx.nodes[v][degree] == 1:
            netx[u][v][k]["cdsbool"] = True
        else:
            netx[u][v][k]["cdsbool"] = False

    if radius:
        for n in tqdm(netx, total=len(netx), disable=not verbose):
            sub = nx.ego_graph(
                netx, n, radius=radius,
                distance=distance)  # define subgraph of steps=radius
            netx.nodes[n][name] = _cds_length(
                sub, mode=mode,
                length=length)  # save value calculated for subgraph to node

        return netx

    return _cds_length(netx, mode=mode, length=length)
Example #49
0
=========
Ego Graph
=========

Example using the NetworkX ego_graph() function to return the main egonet of
the largest hub in a Barabási-Albert network.
"""
# Author:  Drew Conway ([email protected])

from operator import itemgetter

import matplotlib.pyplot as plt
import networkx as nx

if __name__ == '__main__':
    # Create a BA model graph
    n = 1000
    m = 2
    G = networkx.generators.barabasi_albert_graph(n, m)
    # find node with largest degree
    node_and_degree = G.degree()
    (largest_hub, degree) = sorted(node_and_degree, key=itemgetter(1))[-1]
    # Create ego graph of main hub
    hub_ego = nx.ego_graph(G, largest_hub)
    # Draw graph
    pos = nx.spring_layout(hub_ego)
    nx.draw(hub_ego, pos, node_color='b', node_size=50, with_labels=False)
    # Draw ego as large and red
    nx.draw_networkx_nodes(hub_ego, pos, nodelist=[largest_hub], node_size=300, node_color='r')
    plt.show()
Example #50
0
def feature_extraction(G):
    """Node feature extraction.

    Parameters
    ----------

    G (nx.Graph): a networkx graph.

    Returns
    -------

    node_features (float): the Nx7 matrix of node features."""

    # necessary data structures
    node_features = np.zeros(shape=(G.number_of_nodes(), 7))
    node_list = sorted(G.nodes())
    node_degree_dict = dict(G.degree())
    node_clustering_dict = dict(nx.clustering(G))
    egonets = {n: nx.ego_graph(G, n) for n in node_list}

    # node degrees
    degs = [node_degree_dict[n] for n in node_list]

    # clustering coefficient
    clusts = [node_clustering_dict[n] for n in node_list]

    # average degree of neighborhood
    neighbor_degs = [
        np.mean([node_degree_dict[m] for m in egonets[n].nodes if m != n])
        if node_degree_dict[n] > 0
        else 0
        for n in node_list
    ]

    # average clustering coefficient of neighborhood
    neighbor_clusts = [
        np.mean([node_clustering_dict[m] for m in egonets[n].nodes if m != n])
        if node_degree_dict[n] > 0
        else 0
        for n in node_list
    ]

    # number of edges in the neighborhood
    neighbor_edges = [
        egonets[n].number_of_edges() if node_degree_dict[n] > 0 else 0
        for n in node_list
    ]

    # number of outgoing edges from the neighborhood
    # the sum of neighborhood degrees = 2*(internal edges) + external edges
    # node_features[:,5] = node_features[:,0] * node_features[:,2] - 2*node_features[:,4]
    neighbor_outgoing_edges = [
        len(
            [
                edge
                for edge in set.union(*[set(G.edges(j)) for j in egonets[i].nodes])
                if not egonets[i].has_edge(*edge)
            ]
        )
        for i in node_list
    ]

    # number of neighbors of neighbors (not in neighborhood)
    neighbors_of_neighbors = [
        len(
            set([p for m in G.neighbors(n) for p in G.neighbors(m)])
            - set(G.neighbors(n))
            - set([n])
        )
        if node_degree_dict[n] > 0
        else 0
        for n in node_list
    ]

    # assembling the features
    node_features[:, 0] = degs
    node_features[:, 1] = clusts
    node_features[:, 2] = neighbor_degs
    node_features[:, 3] = neighbor_clusts
    node_features[:, 4] = neighbor_edges
    node_features[:, 5] = neighbor_outgoing_edges
    node_features[:, 6] = neighbors_of_neighbors

    return np.nan_to_num(node_features)
Example #51
0
def straightness_centrality(
    graph,
    weight="mm_len",
    normalized=True,
    name="straightness",
    radius=None,
    distance=None,
    verbose=True,
):
    """
    Calculates the straightness centrality for nodes.

    .. math::
        C_{S}(i)=\\frac{1}{n-1} \\sum_{j \\in V, j \\neq i} \\frac{d_{i j}^{E u}}
        {d_{i j}}

    where :math:`\\mathrm{d}^{\\mathrm{E} \\mathrm{u}}_{\\mathrm{ij}}` is the
    Euclidean distance between nodes `i` and `j` along a straight line.

    Adapted from :cite:`porta2006`.

    Parameters
    ----------
    graph : networkx.Graph
        Graph representing street network.
        Ideally generated from GeoDataFrame using :func:`momepy.gdf_to_nx`
    weight : str (default 'mm_len')
        attribute holding length of edge
    normalized : bool
        normalize to number of nodes-1 in connected part (for local straightness
        is recommended to set to normalized False)
    name : str, optional
        calculated attribute name
    radius: int
        Include all neighbors of distance <= radius from n
    distance : str, optional
        Use specified edge data key as distance.
        For example, setting ``distance=’weight’`` will use the edge ``weight`` to
        measure the distance from the node n during ego_graph generation.
    verbose : bool (default True)
        if True, shows progress bars in loops and indication of steps

    Returns
    -------
    Graph
        networkx.Graph

    Examples
    --------
    >>> network_graph = mm.straightness_centrality(network_graph)
    """
    netx = graph.copy()

    if radius:
        for n in tqdm(netx, total=len(netx), disable=not verbose):
            sub = nx.ego_graph(
                netx, n, radius=radius,
                distance=distance)  # define subgraph of steps=radius
            netx.nodes[n][name] = _straightness_centrality(
                sub, weight=weight, normalized=normalized)[n]
    else:
        vals = _straightness_centrality(netx,
                                        weight=weight,
                                        normalized=normalized)
        nx.set_node_attributes(netx, vals, name)

    return netx
Example #52
0
def betweenness_centrality(graph,
                           name="betweenness",
                           mode="nodes",
                           weight="mm_len",
                           endpoints=True,
                           radius=None,
                           distance=None,
                           normalized=False,
                           verbose=True,
                           **kwargs):
    """
    Calculates the shortest-path betweenness centrality for nodes.

    Wrapper around ``networkx.betweenness_centrality`` or
    ``networkx.edge_betweenness_centrality``.

    Betweenness centrality of a node `v` is the sum of the
    fraction of all-pairs shortest paths that pass through `v`

    .. math::

       c_B(v) =\\sum_{s,t \\in V} \\frac{\\sigma(s, t|v)}{\\sigma(s, t)}

    where `V` is the set of nodes, :math:`\\sigma(s, t)` is the number of
    shortest :math:`(s, t)`-paths,  and :math:`\\sigma(s, t|v)` is the number of
    those paths  passing through some  node `v` other than `s, t`.
    If `s = t`, :math:`\\sigma(s, t) = 1`, and if `v` in `{s, t}``,
    :math:`\\sigma(s, t|v) = 0`.

    Betweenness centrality of an edge `e` is the sum of the
    fraction of all-pairs shortest paths that pass through `e`

    .. math::

       c_B(e) =\\sum_{s,t \\in V} \\frac{\\sigma(s, t|e)}{\\sigma(s, t)}

    where `V` is the set of nodes, :math:`\\sigma(s, t)` is the number of
    shortest :math:`(s, t)`-paths, and :math:`\\sigma(s, t|e)` is the number of
    those paths passing through edge `e`.

    Adapted from :cite:`porta2006`.

    Parameters
    ----------
    graph : networkx.Graph
        Graph representing street network.
        Ideally generated from GeoDataFrame using :func:`momepy.gdf_to_nx`
    name : str, optional
        calculated attribute name
    mode : str, default 'nodes'
        mode of betweenness calculation. 'node' for node-based, 'edges' for edge-based
    weight : str (default 'mm_len')
        attribute holding the weight of edge (e.g. length, angle)
    radius: int
        Include all neighbors of distance <= radius from n
    distance : str, optional
        Use specified edge data key as distance.
        For example, setting ``distance=’weight’`` will use the edge ``weight`` to
        measure the distance from the node n during ego_graph generation.
    normalized : bool, optional
        If True the betweenness values are normalized by `2/((n-1)(n-2))`,
        where n is the number of nodes in subgraph.
    verbose : bool (default True)
        if True, shows progress bars in loops and indication of steps
    **kwargs
        kwargs for ``networkx.betweenness_centrality`` or
        ``networkx.edge_betweenness_centrality``

    Returns
    -------
    Graph
        networkx.Graph

    Examples
    --------
    >>> network_graph = mm.betweenness_centrality(network_graph)

    Notes
    -----
    In case of angular betweenness, implementation is based on "Tasos Implementation".
    """
    netx = graph.copy()

    # has to be Graph not MultiGraph as MG is not supported by networkx2.4
    G = nx.Graph()
    for u, v, k, data in netx.edges(data=True, keys=True):
        if G.has_edge(u, v):
            if G[u][v][weight] > netx[u][v][k][weight]:
                nx.set_edge_attributes(G, {(u, v): data})
        else:
            G.add_edge(u, v, **data)

    if radius:
        for n in tqdm(G, total=len(G), disable=not verbose):
            sub = nx.ego_graph(
                G, n, radius=radius,
                distance=distance)  # define subgraph of steps=radius
            netx.nodes[n][name] = nx.betweenness_centrality(
                sub, weight=weight, normalized=normalized, **kwargs)[n]

    elif mode == "nodes":
        vals = nx.betweenness_centrality(G,
                                         weight=weight,
                                         endpoints=endpoints,
                                         **kwargs)
        nx.set_node_attributes(netx, vals, name)
    elif mode == "edges":
        vals = nx.edge_betweenness_centrality(G, weight=weight, **kwargs)
        for u, v, k in netx.edges(keys=True):
            try:
                val = vals[u, v]
            except KeyError:
                val = vals[v, u]
            netx[u][v][k][name] = val
    else:
        raise ValueError(
            "Mode {} is not supported. Use 'nodes' or 'edges'.".format(mode))

    return netx
Example #53
0
def closeness_centrality(graph,
                         name="closeness",
                         weight="mm_len",
                         radius=None,
                         distance=None,
                         verbose=True,
                         **kwargs):
    """
    Calculates the closeness centrality for nodes.

    Wrapper around ``networkx.closeness_centrality``.

    Closeness centrality of a node `u` is the reciprocal of the
    average shortest path distance to `u` over all `n-1` nodes within reachable nodes.

    .. math::

        C(u) = \\frac{n - 1}{\\sum_{v=1}^{n-1} d(v, u)},

    where :math:`d(v, u)` is the shortest-path distance between :math:`v` and :math:`u`,
    and :math:`n` is the number of nodes that can reach :math:`u`.


    Parameters
    ----------
    graph : networkx.Graph
        Graph representing street network.
        Ideally generated from GeoDataFrame using :func:`momepy.gdf_to_nx`
    name : str, optional
        calculated attribute name
    weight : str (default 'mm_len')
        attribute holding the weight of edge (e.g. length, angle)
    radius: int
        Include all neighbors of distance <= radius from n
    distance : str, optional
        Use specified edge data key as distance.
        For example, setting ``distance=’weight’`` will use the edge ``weight`` to
        measure the distance from the node n during ego_graph generation.
    verbose : bool (default True)
        if True, shows progress bars in loops and indication of steps
    **kwargs
        kwargs for ``networkx.closeness_centrality``

    Returns
    -------
    Graph
        networkx.Graph

    Examples
    --------
    >>> network_graph = mm.closeness_centrality(network_graph)
    """
    netx = graph.copy()

    if radius:
        lengraph = len(netx)
        for n in tqdm(netx, total=len(netx), disable=not verbose):
            sub = nx.ego_graph(
                netx, n, radius=radius,
                distance=distance)  # define subgraph of steps=radius
            netx.nodes[n][name] = _closeness_centrality(sub,
                                                        n,
                                                        length=weight,
                                                        len_graph=lengraph)
    else:
        vals = nx.closeness_centrality(netx, distance=weight, **kwargs)
        nx.set_node_attributes(netx, vals, name)

    return netx
Example #54
0
def meshedness(graph,
               radius=5,
               name="meshedness",
               distance=None,
               verbose=True):
    """
    Calculates meshedness for subgraph around each node if radius is set, or for
    whole graph, if ``radius=None``.

    Subgraph is generated around each node within set radius. If ``distance=None``,
    radius will define topological distance, otherwise it uses values in distance
    attribute.

    .. math::
        \\alpha=\\frac{e-v+1}{2 v-5}

    where :math:`e` is the number of edges in subgraph and :math:`v` is the number of
    nodes in subgraph.

    Adapted from :cite:`feliciotti2018`.


    Parameters
    ----------
    graph : networkx.Graph
        Graph representing street network.
        Ideally generated from GeoDataFrame using :func:`momepy.gdf_to_nx`
    radius: int, optional
        Include all neighbors of distance <= radius from n
    name : str, optional
        calculated attribute name
    distance : str, optional
        Use specified edge data key as distance.
        For example, setting ``distance=’weight’`` will use the edge ``weight`` to
        measure the distance from the node n.
    verbose : bool (default True)
        if True, shows progress bars in loops and indication of steps

    Returns
    -------
    Graph
        networkx.Graph if radius is set
    float
        meshedness for graph if ``radius=None``

    Examples
    --------
    >>> network_graph = mm.meshedness(network_graph, radius=800, distance='edge_length')
    """
    netx = graph.copy()

    if radius:
        for n in tqdm(netx, total=len(netx), disable=not verbose):
            sub = nx.ego_graph(
                netx, n, radius=radius,
                distance=distance)  # define subgraph of steps=radius
            netx.nodes[n][name] = _meshedness(
                sub)  # save value calulated for subgraph to node

        return netx

    return _meshedness(netx)
Example #55
0
def proportion(
    graph,
    radius=5,
    three=None,
    four=None,
    dead=None,
    degree="degree",
    distance=None,
    verbose=True,
):
    """
    Calculates the proportion of intersection types for subgraph around each node if
    radius is set, or for whole graph, if ``radius=None``.

    Subgraph is generated around each node within set radius. If ``distance=None``,
    radius will define topological distance, otherwise it uses values in ``distance``
    attribute.

    Parameters
    ----------
    graph : networkx.Graph
        Graph representing street network.
        Ideally generated from GeoDataFrame using :func:`momepy.gdf_to_nx`
    radius: int
        Include all neighbors of distance <= radius from n
    three : str, optional
        attribute name for 3-way intersections proportion
    four : str, optional
        attribute name for 4-way intersections proportion
    dead : str, optional
        attribute name for deadends proportion
    degree : str
        name of attribute of node degree (:py:func:`momepy.node_degree`)
    distance : str, optional
        Use specified edge data key as distance.
        For example, setting ``distance=’weight’`` will use the edge ``weight`` to
        measure the distance from the node n.
    verbose : bool (default True)
        if True, shows progress bars in loops and indication of steps

    Returns
    -------
    Graph
        networkx.Graph if radius is set
    dict
        dict with proportions for graph if ``radius=None``

    Examples
    --------
    >>> network_graph = mm.proportion(network_graph, three='threeway', four='fourway', dead='deadends')  # noqa
    """
    if not three and not four and not dead:
        raise ValueError(
            "Nothing to calculate. Define names for at least one proportion to be "
            "calculated.")
    netx = graph.copy()

    if radius:
        for n in tqdm(netx, total=len(netx), disable=not verbose):
            sub = nx.ego_graph(
                netx, n, radius=radius,
                distance=distance)  # define subgraph of steps=radius
            counts = _proportion(sub, degree=degree)
            if three:
                netx.nodes[n][three] = counts[3] / len(sub)
            if four:
                netx.nodes[n][four] = counts[4] / len(sub)
            if dead:
                netx.nodes[n][dead] = counts[1] / len(sub)
        return netx

    # add example to docs explaining keys
    counts = _proportion(netx, degree=degree)
    result = {}
    if three:
        result[three] = counts[3] / len(netx)
    if four:
        result[four] = counts[4] / len(netx)
    if dead:
        result[dead] = counts[1] / len(netx)

    return result
Example #56
0
def subgraph(
    graph,
    radius=5,
    distance=None,
    meshedness=True,
    cds_length=True,
    mode="sum",
    degree="degree",
    length="mm_len",
    mean_node_degree=True,
    proportion={
        3: True,
        4: True,
        0: True
    },
    cyclomatic=True,
    edge_node_ratio=True,
    gamma=True,
    local_closeness=True,
    closeness_weight=None,
    verbose=True,
):
    """
    Calculates all subgraph-based characters.

    Generating subgraph might be a time consuming activity. If we want to use the same
    subgraph for more characters, ``subgraph`` allows this by generating subgraph and
    then analysing it using selected options.


    Parameters
    ----------
    graph : networkx.Graph
        Graph representing street network.
        Ideally generated from GeoDataFrame using :func:`momepy.gdf_to_nx`
    radius: int
        radius defining the extent of subgraph
    distance : str, optional
        Use specified edge data key as distance.
        For example, setting ``distance=’weight’`` will use the edge ``weight`` to
        measure the distance from the node n.
    meshedness : bool, default True
        Calculate meshedness (True/False)
    cds_length : bool, default True
        Calculate cul-de-sac length (True/False)
    mode : str (defualt 'sum')
        if ``'sum'``, calculate total cds_length, if ``'mean'`` calculate mean
        cds_length
    degree : str
        name of attribute of node degree (:py:func:`momepy.node_degree`)
    length : str, default `mm_len`
        name of attribute of segment length (geographical)
    mean_node_degree : bool, default True
        Calculate mean node degree (True/False)
    proportion : dict, default {3: True, 4: True, 0: True}
        Calculate proportion {3: True/False, 4: True/False, 0: True/False}
    cyclomatic : bool, default True
        Calculate cyclomatic complexity (True/False)
    edge_node_ratio : bool, default True
        Calculate edge node ratio (True/False)
    gamma : bool, default True
        Calculate gamma index (True/False)
    local_closeness : bool, default True
        Calculate local closeness centrality (True/False)
    closeness_weight : str, optional
      Use the specified edge attribute as the edge distance in shortest
      path calculations in closeness centrality algorithm
    verbose : bool (default True)
        if True, shows progress bars in loops and indication of steps


    Returns
    -------
    Graph
        networkx.Graph

    Examples
    --------
    >>> network_graph = mm.subgraph(network_graph)
    """

    netx = graph.copy()

    for n in tqdm(netx, total=len(netx), disable=not verbose):
        sub = nx.ego_graph(
            netx, n, radius=radius,
            distance=distance)  # define subgraph of steps=radius

        if meshedness:
            netx.nodes[n]["meshedness"] = _meshedness(sub)

        if cds_length:
            for u, v, k in netx.edges(keys=True):
                if netx.nodes[u][degree] == 1 or netx.nodes[v][degree] == 1:
                    netx[u][v][k]["cdsbool"] = True
                else:
                    netx[u][v][k]["cdsbool"] = False

            netx.nodes[n]["cds_length"] = _cds_length(sub,
                                                      mode=mode,
                                                      length=length)

        if mean_node_degree:
            netx.nodes[n]["mean_node_degree"] = _mean_node_degree(
                sub, degree=degree)

        if proportion:
            counts = _proportion(sub, degree=degree)
            if proportion[3]:
                netx.nodes[n]["proportion_3"] = counts[3] / len(sub)
            if proportion[4]:
                netx.nodes[n]["proportion_4"] = counts[4] / len(sub)
            if proportion[0]:
                netx.nodes[n]["proportion_0"] = counts[1] / len(sub)

        if cyclomatic:
            netx.nodes[n]["cyclomatic"] = _cyclomatic(sub)

        if edge_node_ratio:
            netx.nodes[n]["edge_node_ratio"] = _edge_node_ratio(sub)

        if gamma:
            netx.nodes[n]["gamma"] = _gamma(sub)

        if local_closeness:
            lengraph = len(netx)
            netx.nodes[n]["local_closeness"] = _closeness_centrality(
                sub, n, length=closeness_weight, len_graph=lengraph)

    return netx
Example #57
0
def calc_sp_pop_intect_density_multi(G_proj, hexes, distance, rows, node,
                                     index):
    """
    Calculate population and intersection density for each sample point

    This function is for multiprocessing. A subnetwork will be created for
    each sample point as a neighborhood and then intersect the hexes with pop
    and intersection data. Population and intersection density for each sample
    point are caculated by averaging the intersected hexes density data

    Parameters
    ----------
    G_proj: networkx multidigraph
    hexes: GeoDataFrame
        hexagon layers containing pop and intersection info
    distance: int
        distance to search around the place geometry, in meters
    rows: int
        the number of rows to loop
    node: list
        the list of osmid of nodes
    index: int
        loop number

    Returns
    -------
    list
    """
    if index % 100 == 0:
        print("{0} / {1}".format(index, rows))

    # create subgraph of neighbors centered at a node within a given radius.
    subgraph_proj = nx.ego_graph(G_proj,
                                 node,
                                 radius=distance,
                                 distance="length")

    # convert subgraph into edge GeoDataFrame
    try:
        subgraph_gdf = ox.graph_to_gdfs(subgraph_proj,
                                        nodes=False,
                                        edges=True,
                                        fill_edge_geometry=True)

        # intersect GeoDataFrame with hexes
        if len(subgraph_gdf) > 0:
            intersections = gpd.sjoin(hexes,
                                      subgraph_gdf,
                                      how="inner",
                                      op="intersects")

            # drop all rows where 'index_right' is nan
            intersections = intersections[
                intersections["index_right"].notnull()]
            # remove rows where 'index' is duplicate
            intersections = intersections.drop_duplicates(subset=["index"])
            # return list of nodes with osmid, pop and intersection density
            return [
                node,
                float(intersections["pop_per_sqkm"].mean()),
                float(intersections["intersections_per_sqkm"].mean()),
            ]
        else:
            return [node]

    except ValueError as e:
        return [node]
Example #58
0
    k_neighbors = DG.neighbors(k)  #k 的所有邻居
    k_neighbors.append(k)
    j_and_k = set(j_neighbors) & set(k_neighbors)  # 交集
    j_or_k = set(j_neighbors) | set(k_neighbors)  #并集
    S = float(len(j_and_k)) / len(j_or_k)
    print '两条边的相似度为', S


G = nx.Graph()
G.add_edges_from([(1, 2), (1, 3), (1, 4), (2, 3), (4, 5), (2, 4), (5, 8),
                  (2, 8), (8, 9), (9, 10), (9, 11)])  #图
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True)
plt.show()
print '输入节点的值,并显示节点对应的ego网络图'
l = input()
if l in G.nodes():
    node_ego = nx.ego_graph(G, l)  #自我中心节点
    DG = nx.Graph(node_ego)  #节点l的ego网络图
    nx.draw(DG, pos, with_labels=True)
    plt.show()
while True:
    print '请输入两条边的三个节点'
    i = input()
    j = input()
    k = input()
    if (i, j) and (i, k) in DG.edges():
        similarity(i, j, k)
        break
    else:
        print '请重新输入边'
print ("--------------------------------------------------------------")
purchasedAsin = '0805047905'

# Let's first get some metadata associated with this book
print ("ASIN = ", purchasedAsin) 
print ("Title = ", amazonBooks[purchasedAsin]['Title'])
print ("SalesRank = ", amazonBooks[purchasedAsin]['SalesRank'])
print ("TotalReviews = ", amazonBooks[purchasedAsin]['TotalReviews'])
print ("AvgRating = ", amazonBooks[purchasedAsin]['AvgRating'])
print ("DegreeCentrality = ", amazonBooks[purchasedAsin]['DegreeCentrality'])
print ("ClusteringCoeff = ", amazonBooks[purchasedAsin]['ClusteringCoeff'])

# (1) 
#     Get the depth-1 ego network of purchasedAsin from copurchaseGraph,
#     and assign the resulting graph to purchasedAsinEgoGraph.
purchasedAsinEgoGraph = networkx.ego_graph(copurchaseGraph,purchasedAsin,radius=1)

# (2)
#     Use the island method on purchasedAsinEgoGraph to only retain edges with 
#     threshold >= 0.5, and assign resulting graph to purchasedAsinEgoTrimGraph

threshold = 0.5
purchasedAsinEgoTrimGraph = networkx.Graph()

# get the weight
weightNodeDict={}

for fnode, tnode, edge in purchasedAsinEgoGraph.edges(data=True):
    if edge['weight'] >= threshold:
        purchasedAsinEgoTrimGraph.add_edge(fnode,tnode,edge=edge['weight'])
        if (fnode==purchasedAsin):
Example #60
0
def effective_size(G, nodes=None, weight=None):
    r"""Returns the effective size of all nodes in the graph ``G``.

    The *effective size* of a node's ego network is based on the concept
    of redundancy. A person's ego network has redundancy to the extent
    that her contacts are connected to each other as well. The
    nonredundant part of a person's relationships it's the effective
    size of her ego network [1]_.  Formally, the effective size of a
    node `u`, denoted `e(u)`, is defined by

    .. math::

       e(u) = \sum_{v \in N(u) \setminus \{u\}}
       \left(1 - \sum_{w \in N(v)} p_{uw} m_{vw}\right)

    where `N(u)` is the set of neighbors of `u` and :math:`p_{uw}` is the
    normalized mutual weight of the (directed or undirected) edges
    joining `u` and `v`, for each vertex `u` and `v` [1]_. And :math:`m_{vw}`
    is the mutual weight of `v` and `w` divided by `v` highest mutual
    weight with any of its neighbors. The *mutual weight* of `u` and `v`
    is the sum of the weights of edges joining them (edge weights are
    assumed to be one if the graph is unweighted).

    For the case of unweighted and undirected graphs, Borgatti proposed
    a simplified formula to compute effective size [2]_ 

    .. math::

       e(u) = n - \frac{2t}{n}

    where `t` is the number of ties in the ego network (not including
    ties to ego) and `n` is the number of nodes (excluding ego).

    Parameters
    ----------
    G : NetworkX graph
        The graph containing ``v``. Directed graphs are treated like
        undirected graphs when computing neighbors of ``v``.

    nodes : container, optional
        Container of nodes in the graph ``G``.

    weight : None or string, optional
      If None, all edge weights are considered equal.
      Otherwise holds the name of the edge attribute used as weight.

    Returns
    -------
    dict
        Dictionary with nodes as keys and the constraint on the node as values.

    Notes
    -----
    Burt also defined the related concept of *efficency* of a node's ego
    network, which is its effective size divided by the degree of that
    node [1]_. So you can easily compute efficencty:

    >>> G = nx.DiGraph()
    >>> G.add_edges_from([(0, 1), (0, 2), (1, 0), (2, 1)])
    >>> esize = nx.effective_size(G)
    >>> efficency = {n: v / G.degree(n) for n, v in esize.items()}

    See also
    --------
    constraint

    References
    ----------
    .. [1] Burt, Ronald S.
           *Structural Holes: The Social Structure of Competition.*
           Cambridge: Harvard University Press, 1995.

    .. [2] Borgatti, S.
           "Structural Holes: Unpacking Burt's Redundancy Measures"
           CONNECTIONS 20(1):35-38.
           http://www.analytictech.com/connections/v20(1)/holes.htm

    """
    def redundancy(G, u, v, weight=None):
        nmw = normalized_mutual_weight
        r = sum(
            nmw(G, u, w, weight=weight) * nmw(G, v, w, norm=max, weight=weight)
            for w in set(nx.all_neighbors(G, u)))
        return 1 - r

    effective_size = {}
    if nodes is None:
        nodes = G
    # Use Borgatti's simplified formula for unweighted and undirected graphs
    if not G.is_directed() and weight is None:
        for v in G:
            # Effective size is not defined for isolated nodes
            if len(G[v]) == 0:
                effective_size[v] = float('nan')
                continue
            E = nx.ego_graph(G, v, center=False, undirected=True)
            effective_size[v] = len(E) - (2 * E.size()) / len(E)
    else:
        for v in G:
            # Effective size is not defined for isolated nodes
            if len(G[v]) == 0:
                effective_size[v] = float('nan')
                continue
            effective_size[v] = sum(
                redundancy(G, v, u, weight)
                for u in set(nx.all_neighbors(G, v)))
    return effective_size