viz/IntroMatplotlib.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![NASA](http://www.nasa.gov/sites/all/themes/custom/nasatwo/images/nasa-logo.svg)\n",
    "\n",
    "<center>\n",
    "<h1><font size=\"+3\">GSFC Python Bootcamp</font></h1>\n",
    "</center>\n",
    "\n",
    "---\n",
    "\n",
    "<CENTER>\n",
    "<H1 style=\"color:red\">\n",
    "Introduction to Matplotlib\n",
    "</H1>\n",
    "</CENTER>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference Documents"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<OL>\n",
    "<LI> <A HREF=\"http://people.duke.edu/~ccc14/pcfb/numerics.html\">NumPy and Matplotlib (Practical Cumputing for Biologists)</A>\n",
    "<LI> <A HREF=\"http://scipy-lectures.github.io/intro/matplotlib/matplotlib.html\">Matplotlib: Plotting</A>\n",
    "<LI> <A HREF=\"http://www.labri.fr/perso/nrougier/teaching/matplotlib/\">Matplotlib Tutorial</A>\n",
    "<LI> <A HREF=\"http://matplotlib.sourceforge.net/gallery.html\">Image Gallery</A>\n",
    "<LI> <A HREF=\"http://videolectures.net/mloss08_hunter_mat\">Video Presentation</A>\n",
    "</OL>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Matplotlib?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<UL>\n",
    "<LI> Library for making 2D plots of arrays in Python\n",
    "<LI> Makes heavy use of Numpy and other extension code to provide good performance\n",
    "<LI> Can be used to create plots with few commands\n",
    "</UL>\n",
    "<P>\n",
    "With Matplotlib, we can generate plots, histograms, power spectra, bar charts, \n",
    "   error charts, scatter plots, etc., with just a few lines of code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Syntax for Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "x = [...]       # define the points on the x-axis\n",
    "y = [...]       # define the points on the y-axis\n",
    "\n",
    "plt.plot(x,y)\n",
    "plt.show()      # display the plot on the screen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [2, 3, 5, 7, 11]\n",
    "y = [4, 9, 5, 9, 1]\n",
    "plt.plot(x, y, '-', color='b', label='simple')\n",
    "plt.xlabel('x')\n",
    "plt.legend(loc='center')\n",
    "plt.title('Simple Plot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Useful Syntax"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "plot(x,y)\n",
    "xlabel('string')         # label the x-axis\n",
    "ylabel('string')         # label the y-axis\n",
    "title('string')          # write the title of the plot\n",
    "grid(true/false)         # adds grid boxes\n",
    "savefig('fileName.type') # type can be png, ps, pdf, etc\n",
    "show()                   # display the graph on the screen\n",
    "xlim(xmin,xmax)          # set/get the xlimits\n",
    "ylim(ymin,ymax)          # set/get the ylimits\n",
    "hold(True/False)         # to overlay figures on the same graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Cosine Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0.0, 1.0+0.01, 0.01)\n",
    "s = np.cos(2*2*np.pi*t)\n",
    "plt.plot(t, s)\n",
    "\n",
    "plt.xlabel('time (s)')\n",
    "plt.ylabel('voltage (mV)')\n",
    "plt.title('About as simple as it gets, folks')\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Ticks - Changing Colors and Line Widths - Setting Limits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.linspace(-np.pi, np.pi, 256,endpoint=True)\n",
    "C = np.cos(X)\n",
    "S = np.sin(X)\n",
    "\n",
    "# Plot cosine using blue color with a continuous line of width 1 (pixels)\n",
    "plt.plot(X, C, color=\"blue\", linewidth=1.0, linestyle=\"-\")\n",
    "\n",
    "# Plot sine using green color with a continuous line of width 1 (pixels)\n",
    "plt.plot(X, S, color=\"green\", linewidth=1.0, linestyle=\"-\")\n",
    "\n",
    "# Set x limits\n",
    "plt.xlim(-4.0,4.0)\n",
    "\n",
    "# Set x ticks\n",
    "plt.xticks(np.linspace(-4,4,5,endpoint=True))\n",
    "\n",
    "# Set y limits\n",
    "plt.ylim(-1.05,1.05)\n",
    "\n",
    "# Set y ticks\n",
    "plt.yticks(np.linspace(-1,1,5,endpoint=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Moving Spines\n",
    "\n",
    "- Spines are the lines connecting the axis tick marks and noting the boundaries of the data area\n",
    "- They can be placed at arbitrary positions, especially on the border of the axis.\n",
    "- There are four of them: top, bottom, left and right\n",
    "- We want to have them in the middle of the plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.linspace(-np.pi, np.pi, 256,endpoint=True)\n",
    "\n",
    "C = np.cos(X)\n",
    "S = np.sin(X)\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "# Plot cosine using blue color with a continuous line of width 1 (pixels)\n",
    "ax.plot(X, C, color=\"blue\", linewidth=1.0, linestyle=\"-\")\n",
    "\n",
    "# Plot sine using green color with a continuous line of width 1 (pixels)\n",
    "ax.plot(X, S, color=\"green\", linewidth=1.0, linestyle=\"-\")\n",
    "\n",
    "# Set x limits\n",
    "ax.set_xlim(-4.0,4.0)\n",
    "\n",
    "# Set x ticks\n",
    "ax.set_xticks(np.linspace(-4,4,9,endpoint=True))\n",
    "\n",
    "# Set y limits\n",
    "ax.set_ylim(-1.05,1.05)\n",
    "\n",
    "# Set y ticks\n",
    "ax.set_yticks(np.linspace(-1,1,5,endpoint=True))\n",
    "\n",
    "# Move left y-axis and bottom x-axis to centre, passing through (0,0)\n",
    "ax.spines['left'].set_position('center')     # we want the left spline to be centered\n",
    "ax.spines['bottom'].set_position('center')   # we want the bottom spline to be centered\n",
    "\n",
    "# Eliminate upper and right axes\n",
    "ax.spines['right'].set_color('none')\n",
    "ax.spines['top'].set_color('none')\n",
    "\n",
    "# Show ticks on the left and lower axes only\n",
    "ax.xaxis.set_ticks_position('bottom')\n",
    "ax.yaxis.set_ticks_position('left')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multiple Figures on the Same Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(t):\n",
    "    return np.exp(-t) * np.cos(2*np.pi*t)\n",
    "\n",
    "t1 = np.arange(0.0, 5.0, 0.1)\n",
    "t2 = np.arange(0.0, 5.0, 0.02)\n",
    "\n",
    "plt.figure(1)\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')\n",
    "\n",
    "plt.subplot(2,1,1)\n",
    "plt.plot(t2, np.cos(2*np.pi*t2), 'r--')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add Legend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0, 2*np.pi, 300)\n",
    "y = np.sin(x)\n",
    "y2 = np.sin(x**2)\n",
    "plt.plot(x, y, label=r'$\\sin(x)$')\n",
    "plt.plot(x, y2, label=r'$\\sin(x^2)$')\n",
    "plt.title('Some functions')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.xlim(0,9)\n",
    "plt.grid()\n",
    "plt.legend(loc='upper right')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Annotating Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ax = plt.subplot(111)\n",
    "t = np.arange(0.0, 5.0, 0.01)\n",
    "s = np.cos(2*np.pi*t)\n",
    "line, = plt.plot(t, s, lw=2)\n",
    "\n",
    "plt.annotate('local max', xy=(2, 1), \\\n",
    "        xytext=(3, 1.5), \\\n",
    "        arrowprops=dict(facecolor='black', \\\n",
    "        shrink=0.05), )\n",
    "\n",
    "plt.ylim(-2,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot with Fill"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0.0, 1.01, 0.01)\n",
    "s = np.sin(2*2*np.pi*t)\n",
    "\n",
    "plt.fill(t, s*np.exp(-5*t), 'r')\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histogram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu, sigma = 100, 15\n",
    "x = mu + sigma * np.random.randn(10000)\n",
    "\n",
    "# the histogram of the data\n",
    "n, bins, patches = plt.hist(x, 50, normed=1, \\\n",
    "                       facecolor='g', alpha=0.75)\n",
    "\n",
    "plt.xlabel('Smarts')\n",
    "plt.ylabel('Probability')\n",
    "plt.title('Histogram of IQ')\n",
    "plt.text(60, .025, r'$\\mu=100,\\ \\sigma=\\frac{1}{\\sqrt{15}}$')\n",
    "plt.axis([40, 160, 0, 0.03])\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Log Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.subplots_adjust(hspace=0.4)\n",
    "t = np.arange(0.01, 20.0, 0.01)\n",
    "\n",
    "# log y axis\n",
    "plt.subplot(221)\n",
    "plt.semilogy(t, np.exp(-t/5.0))\n",
    "plt.title('semilogy')\n",
    "plt.grid(True)\n",
    "\n",
    "# log x axis\n",
    "plt.subplot(222)\n",
    "plt.semilogx(t, np.sin(2*np.pi*t))\n",
    "plt.title('semilogx')\n",
    "plt.grid(True)\n",
    "\n",
    "# log x and y axis\n",
    "plt.subplot(223)\n",
    "plt.loglog(t, 20*np.exp(-t/10.0), basex=2)\n",
    "plt.grid(True)\n",
    "plt.title('loglog base 4 on x')\n",
    "\n",
    "# with errorbars: clip non-positive values\n",
    "ax = plt.subplot(224)\n",
    "ax.set_xscale(\"log\", nonposx='clip')\n",
    "ax.set_yscale(\"log\", nonposy='clip')\n",
    "\n",
    "x = 10.0**np.linspace(0.0, 2.0, 20)\n",
    "y = x**2.0\n",
    "plt.errorbar(x, y, xerr=0.1*x, yerr=5.0+0.75*y)\n",
    "ax.set_ylim(ymin=0.1)\n",
    "ax.set_title('Errorbars go negative')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pie Chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# make a square figure and axes\n",
    "fig = plt.figure(1, figsize=(6,6))\n",
    "ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])\n",
    "labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'\n",
    "fracs = [15,30,45, 10]\n",
    "explode=(0, 0.1, 0, 0)\n",
    "ax.pie(fracs, explode=explode, labels=labels, autopct='%1.1f%%', shadow=True)\n",
    "ax.set_title('Raining Hogs and Dogs', bbox={'facecolor':'0.9', 'pad':15})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contour Plot and Colorbar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pylab import *\n",
    "delta = 0.01\n",
    "x = arange(-3.0, 3.0, delta)\n",
    "y = arange(-3.0, 3.0, delta)\n",
    "X,Y = meshgrid(x, y)\n",
    "Z1 = bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)\n",
    "Z2 = bivariate_normal(X, Y, 1.5, 0.5, 1, 1)\n",
    "Z = Z2 - Z1 # difference of Gaussians\n",
    "\n",
    "cmap = cm.get_cmap('jet', 10)    # 10 discrete colors\n",
    "\n",
    "im = imshow(Z, cmap=cmap, interpolation='bilinear')\n",
    "axis('off')\n",
    "colorbar()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scatter Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import random\n",
    "\n",
    "random.seed(0)\n",
    "mu_1 = random.randn(2)\n",
    "sigma_1 = random.randn()\n",
    "x_1 = (random.randn(1000)*sigma_1)+mu_1[0]\n",
    "y_1 = (random.randn(1000)*sigma_1)+mu_1[1]\n",
    "\n",
    "mu_2 = random.randn(2)\n",
    "sigma_2 = random.randn()\n",
    "x_2 = (random.randn(1000)*sigma_2)+mu_2[0]\n",
    "y_2 = (random.randn(1000)*sigma_2)+mu_2[1]\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(1,1,1)\n",
    "ax.scatter(x_1,y_1,color='r',edgecolor='k',alpha=0.25)\n",
    "ax.scatter(x_2,y_2,color='b',edgecolor='k',alpha=0.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulating Images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "img.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot the r, g, b channels of the image.\n",
    "img = plt.imread('dessert.png')\n",
    "plt.imshow(img)\n",
    "fig, ax = plt.subplots(1,4, figsize=(10,6))\n",
    "ax[0].imshow(img[:,:,0], cmap=cm.Reds_r)\n",
    "ax[1].imshow(img[:,:,1], cmap=cm.Blues_r)\n",
    "ax[2].imshow(img[:,:,2], cmap=cm.Greens_r)\n",
    "ax[3].imshow(img);\n",
    "for a in ax:\n",
    "    a.set_xticklabels([])\n",
    "    a.set_yticklabels([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the above cosine/sine plots to produce something like:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](fig_annotate.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}