miscellaneous_networkx_graph_network_examples.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>Miscellaneous Examples of Networkx Graph Visualizations</h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "G = nx.random_geometric_graph(200, 0.125)\n",
    "# position is stored as node attribute data for random_geometric_graph\n",
    "pos = nx.get_node_attributes(G, 'pos')\n",
    "\n",
    "# find node near center (0.5,0.5)\n",
    "dmin = 1\n",
    "ncenter = 0\n",
    "for n in pos:\n",
    "    x, y = pos[n]\n",
    "    d = (x - 0.5)**2 + (y - 0.5)**2\n",
    "    if d < dmin:\n",
    "        ncenter = n\n",
    "        dmin = d\n",
    "\n",
    "# color by path length from node near center\n",
    "p = dict(nx.single_source_shortest_path_length(G, ncenter))\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "nx.draw_networkx_edges(G, pos, nodelist=[ncenter], alpha=0.4)\n",
    "nx.draw_networkx_nodes(G, pos, nodelist=list(p.keys()),\n",
    "                       node_size=40,\n",
    "                       node_color=list(p.values()),\n",
    "                       cmap=plt.cm.Reds_r)\n",
    "\n",
    "plt.xlim(-0.05, 1.05)\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "# G = nx.random_geometric_graph(200, 0.125)\n",
    "# position is stored as node attribute data for random_geometric_graph\n",
    "pos = nx.get_node_attributes(G, 'pos')\n",
    "\n",
    "# find node near center (0.5,0.5)\n",
    "dmin = 1\n",
    "ncenter = 0\n",
    "for n in pos:\n",
    "    x, y = pos[n]\n",
    "    d = (x - 0.5)**2 + (y - 0.5)**2\n",
    "    if d < dmin:\n",
    "        ncenter = n\n",
    "        dmin = d\n",
    "\n",
    "# color by path length from node near center\n",
    "p = dict(nx.single_source_shortest_path_length(G, ncenter))\n",
    "\n",
    "plt.figure(figsize=(8, 8))\n",
    "nx.draw_networkx_edges(G, pos, nodelist=[ncenter], alpha=0.4)\n",
    "nx.draw_networkx_nodes(G, pos, nodelist=list(p.keys()),\n",
    "                       node_size=40,\n",
    "                       node_color=list(p.values()),\n",
    "                       cmap=plt.cm.Reds_r)\n",
    "\n",
    "plt.xlim(-0.05, 1.05)\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Author: Aric Hagberg (hagberg@lanl.gov)\n",
    "\n",
    "#    Copyright (C) 2004-2018 by\n",
    "#    Aric Hagberg <hagberg@lanl.gov>\n",
    "#    Dan Schult <dschult@colgate.edu>\n",
    "#    Pieter Swart <swart@lanl.gov>\n",
    "#    All rights reserved.\n",
    "#    BSD license.\n",
    "\n",
    "import sys\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "G = nx.grid_2d_graph(5, 5)  # 5x5 grid\n",
    "try:  # Python 2.6+\n",
    "    nx.write_adjlist(G, sys.stdout)  # write adjacency list to screen\n",
    "except TypeError:  # Python 3.x\n",
    "    nx.write_adjlist(G, sys.stdout.buffer)  # write adjacency list to screen\n",
    "# write edgelist to grid.edgelist\n",
    "nx.write_edgelist(G, path=\"grid.edgelist\", delimiter=\":\")\n",
    "# read edgelist from grid.edgelist\n",
    "H = nx.read_edgelist(path=\"grid.edgelist\", delimiter=\":\")\n",
    "\n",
    "nx.draw(H)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Author: Aric Hagberg (hagberg@lanl.gov)\n",
    "\n",
    "#    Copyright (C) 2007-2018 by\n",
    "#    Aric Hagberg <hagberg@lanl.gov>\n",
    "#    Dan Schult <dschult@colgate.edu>\n",
    "#    Pieter Swart <swart@lanl.gov>\n",
    "#    All rights reserved.\n",
    "#    BSD license.\n",
    "\n",
    "try:  # Python 3.x\n",
    "    import urllib.request as urllib\n",
    "except ImportError:  # Python 2.x\n",
    "    import urllib\n",
    "import io\n",
    "import zipfile\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "url = \"http://www-personal.umich.edu/~mejn/netdata/football.zip\"\n",
    "\n",
    "sock = urllib.urlopen(url)  # open URL\n",
    "s = io.BytesIO(sock.read())  # read into BytesIO \"file\"\n",
    "sock.close()\n",
    "\n",
    "zf = zipfile.ZipFile(s)  # zipfile object\n",
    "txt = zf.read('football.txt').decode()  # read info file\n",
    "gml = zf.read('football.gml').decode()  # read gml data\n",
    "# throw away bogus first line with # from mejn files\n",
    "gml = gml.split('\\n')[1:]\n",
    "G = nx.parse_gml(gml)  # parse gml data\n",
    "\n",
    "print(txt)\n",
    "# print degree for each team - number of games\n",
    "for n, d in G.degree():\n",
    "    print('%s %d' % (n, d))\n",
    "\n",
    "options = {\n",
    "    'node_color': 'black',\n",
    "    'node_size': 50,\n",
    "    'line_color': 'grey',\n",
    "    'linewidths': 0,\n",
    "    'width': 0.1,\n",
    "}\n",
    "nx.draw(G, **options)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#    Copyright (C) 2004-2018 by\n",
    "#    Aric Hagberg <hagberg@lanl.gov>\n",
    "#    Dan Schult <dschult@colgate.edu>\n",
    "#    Pieter Swart <swart@lanl.gov>\n",
    "#    All rights reserved.\n",
    "#    BSD license.\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from networkx import nx\n",
    "\n",
    "G = nx.lollipop_graph(4, 6)\n",
    "\n",
    "pathlengths = []\n",
    "\n",
    "print(\"source vertex {target:length, }\")\n",
    "for v in G.nodes():\n",
    "    spl = dict(nx.single_source_shortest_path_length(G, v))\n",
    "    print('{} {} '.format(v, spl))\n",
    "    for p in spl:\n",
    "        pathlengths.append(spl[p])\n",
    "\n",
    "print('')\n",
    "print(\"average shortest path length %s\" % (sum(pathlengths) / len(pathlengths)))\n",
    "\n",
    "# histogram of path lengths\n",
    "dist = {}\n",
    "for p in pathlengths:\n",
    "    if p in dist:\n",
    "        dist[p] += 1\n",
    "    else:\n",
    "        dist[p] = 1\n",
    "\n",
    "print('')\n",
    "print(\"length #paths\")\n",
    "verts = dist.keys()\n",
    "for d in sorted(verts):\n",
    "    print('%s %d' % (d, dist[d]))\n",
    "\n",
    "print(\"radius: %d\" % nx.radius(G))\n",
    "print(\"diameter: %d\" % nx.diameter(G))\n",
    "print(\"eccentricity: %s\" % nx.eccentricity(G))\n",
    "print(\"center: %s\" % nx.center(G))\n",
    "print(\"periphery: %s\" % nx.periphery(G))\n",
    "print(\"density: %s\" % nx.density(G))\n",
    "\n",
    "nx.draw(G, with_labels=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "G = nx.path_graph(8)\n",
    "nx.draw(G)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Author: Aric Hagberg (hagberg@lanl.gov)\n",
    "\n",
    "#    Copyright (C) 2004-2018 by\n",
    "#    Aric Hagberg <hagberg@lanl.gov>\n",
    "#    Dan Schult <dschult@colgate.edu>\n",
    "#    Pieter Swart <swart@lanl.gov>\n",
    "#    All rights reserved.\n",
    "#    BSD license.\n",
    "\n",
    "import re\n",
    "import sys\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import networkx as nx\n",
    "\n",
    "\n",
    "def miles_graph():\n",
    "    \"\"\" Return the cites example graph in miles_dat.txt\n",
    "        from the Stanford GraphBase.\n",
    "    \"\"\"\n",
    "    # open file miles_dat.txt.gz (or miles_dat.txt)\n",
    "    import gzip\n",
    "    fh = gzip.open('D:/Jeff/jeffsale/public_html/get_tweets/NetworkX_fork-master/examples/graph/knuth_miles.txt.gz', 'r')\n",
    "\n",
    "    G = nx.Graph()\n",
    "    G.position = {}\n",
    "    G.population = {}\n",
    "\n",
    "    cities = []\n",
    "    for line in fh.readlines():\n",
    "        line = line.decode()\n",
    "        if line.startswith(\"*\"):  # skip comments\n",
    "            continue\n",
    "\n",
    "        numfind = re.compile(\"^\\d+\")\n",
    "\n",
    "        if numfind.match(line):  # this line is distances\n",
    "            dist = line.split()\n",
    "            for d in dist:\n",
    "                G.add_edge(city, cities[i], weight=int(d))\n",
    "                i = i + 1\n",
    "        else:  # this line is a city, position, population\n",
    "            i = 1\n",
    "            (city, coordpop) = line.split(\"[\")\n",
    "            cities.insert(0, city)\n",
    "            (coord, pop) = coordpop.split(\"]\")\n",
    "            (y, x) = coord.split(\",\")\n",
    "\n",
    "            G.add_node(city)\n",
    "            # assign position - flip x axis for matplotlib, shift origin\n",
    "            G.position[city] = (-int(x) + 7500, int(y) - 3000)\n",
    "            G.population[city] = float(pop) / 1000.0\n",
    "    return G\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "\n",
    "    G = miles_graph()\n",
    "\n",
    "    print(\"Loaded miles_dat.txt containing 128 cities.\")\n",
    "    print(\"digraph has %d nodes with %d edges\"\n",
    "          % (nx.number_of_nodes(G), nx.number_of_edges(G)))\n",
    "\n",
    "    # make new graph of cites, edge if less then 300 miles between them\n",
    "    H = nx.Graph()\n",
    "    for v in G:\n",
    "        H.add_node(v)\n",
    "    for (u, v, d) in G.edges(data=True):\n",
    "        if d['weight'] < 300:\n",
    "            H.add_edge(u, v)\n",
    "\n",
    "    # draw with matplotlib/pylab\n",
    "    plt.figure(figsize=(8, 8))\n",
    "    # with nodes colored by degree sized by population\n",
    "    node_color = [float(H.degree(v)) for v in H]\n",
    "    nx.draw(H, G.position,\n",
    "            node_size=[G.population[v] for v in H],\n",
    "            node_color=node_color,\n",
    "            with_labels=False)\n",
    "\n",
    "    # scale the axes equally\n",
    "    plt.xlim(-5000, 500)\n",
    "    plt.ylim(-2000, 3500)\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}