",
+ " ",
+ "Exercise",
+ "--------",
+ "",
+ "Consider you have the following data in a text file (The file `data/stations.txt` contains the full dataset):",
+ "",
+ " # Station Lat Long Elev ",
+ " BIRA 26.4840 87.2670 0.0120",
+ " BUNG 27.8771 85.8909 1.1910",
+ " GAIG 26.8380 86.6318 0.1660",
+ " HILE 27.0482 87.3242 2.0880",
+ " ... etc.",
+ " ",
+ " ",
+ "These are the names of seismographic stations in the Himalaya, with their coordinates and elevations in Kilometers.",
+ "",
+ "1. Make a scatter plot of all of these, using both the size and the color to (redundantly) encode elevation. Label each station by its 4-letter code, and add a colorbar on the right that shows the color-elevation map.",
+ " ",
+ "2. If you have the basemap toolkit installed, repeat the same exercise but draw a grid with parallels and meridians, add rivers in cyan and country boundaries in yellow. Also, draw the background using the NASA BlueMarble image of Earth.",
+ "",
+ " ",
+ "**Tips**",
+ " ",
+ "* You can check whether you have Basemap installed with:",
+ " ",
+ " from mpl_toolkits.basemap import Basemap",
+ " ",
+ "* For the basemap part, choose a text label color that provides adequate reading contrast over the image background.",
+ " ",
+ "* Create your Basemap with 'i' resolution, otherwise it will take forever to draw."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Histograms",
+ "----------",
+ "",
+ "Matplotlib has a built-in command for histograms."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "mu, sigma = 100, 15",
+ "x = mu + sigma * np.random.randn(10000)",
+ "",
+ "# the histogram of the data",
+ "n, bins, patches = plt.hist(x, 50, normed=1, facecolor='g', alpha=0.75)",
+ "",
+ "plt.xlabel('Smarts')",
+ "plt.ylabel('Probability')",
+ "plt.title('Histogram of IQ')",
+ "plt.text(60, .025, r'$\\mu=100,\\ \\sigma=15$')",
+ "plt.axis([40, 160, 0, 0.03])",
+ "plt.grid(True)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 21
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Aribitrary text and LaTeX support",
+ "=================================",
+ "",
+ "In matplotlib, text can be added either relative to an individual axis object",
+ "or to the whole figure.",
+ "",
+ "These commands add text to the Axes:",
+ "",
+ "- title() - add a title",
+ "- xlabel() - add an axis label to the x-axis",
+ "- ylabel() - add an axis label to the y-axis",
+ "- text() - add text at an arbitrary location",
+ "- annotate() - add an annotation, with optional arrow",
+ "",
+ "And these act on the whole figure:",
+ "",
+ "- figtext() - add text at an arbitrary location",
+ "- suptitle() - add a title",
+ "",
+ "And any text field can contain LaTeX expressions for mathematics, as long as",
+ "they are enclosed in ``$`` signs.",
+ "",
+ "This example illustrates all of them:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "fig = plt.figure()",
+ "fig.suptitle('bold figure suptitle', fontsize=14, fontweight='bold')",
+ "",
+ "ax = fig.add_subplot(111)",
+ "fig.subplots_adjust(top=0.85)",
+ "ax.set_title('axes title')",
+ "",
+ "ax.set_xlabel('xlabel')",
+ "ax.set_ylabel('ylabel')",
+ "",
+ "ax.text(3, 8, 'boxed italics text in data coords', style='italic',",
+ " bbox={'facecolor':'red', 'alpha':0.5, 'pad':10})",
+ "",
+ "ax.text(2, 6, r'an equation: $E=mc^2$', fontsize=15)",
+ "",
+ "ax.text(3, 2, unicode('unicode: Institut f\\374r Festk\\366rperphysik',",
+ " 'latin-1'))",
+ "",
+ "ax.text(0.95, 0.01, 'colored text in axes coords',",
+ " verticalalignment='bottom', horizontalalignment='right',",
+ " transform=ax.transAxes,",
+ " color='green', fontsize=15)",
+ "",
+ "",
+ "ax.plot([2], [1], 'o')",
+ "ax.annotate('annotate', xy=(2, 1), xytext=(3, 4),",
+ " arrowprops=dict(facecolor='black', shrink=0.05))",
+ "",
+ "ax.axis([0, 10, 0, 10])"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 22
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Axis sharing",
+ "============",
+ "",
+ "The simplest way to share axes is to use the ``subplots`` function. More",
+ "fine-grained control can be obtained by individually adding subplots and adding",
+ "share calls to those, but in most cases the functionality from ``subplots`` is sufficient:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "# Simple data to display in various forms",
+ "x = np.linspace(0, 2*np.pi, 400)",
+ "y = np.sin(x**2)",
+ "",
+ "# Two subplots, the axes array is 1-d",
+ "f, axarr = plt.subplots(2, sharex=True)",
+ "f.suptitle('Sharing X axis')",
+ "axarr[0].plot(x, y)",
+ "axarr[1].scatter(x, y)",
+ "",
+ "# Two subplots, unpack the axes array immediately",
+ "f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)",
+ "f.suptitle('Sharing Y axis')",
+ "ax1.plot(x, y)",
+ "ax2.scatter(x, y)",
+ "",
+ "# Three subplots sharing both x/y axes",
+ "f, (ax1, ax2, ax3) = plt.subplots(3, sharex=True, sharey=True)",
+ "f.suptitle('Sharing both axes')",
+ "ax1.plot(x, y)",
+ "ax2.scatter(x, y)",
+ "ax3.scatter(x, 2*y**2-1,color='r')",
+ "# Fine-tune figure; make subplots close to each other and hide x ticks for",
+ "# all but bottom plot.",
+ "f.subplots_adjust(hspace=0)",
+ "plt.setp([a.get_xticklabels() for a in f.axes[:-1]], visible=False);"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 24
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Basic event handling",
+ "====================",
+ "",
+ "Matplotlib has a builtin, toolkit-independent event model that is fairly rich.",
+ "If you want to develop full-fledged applications with very complex and fast",
+ "interactions, you are likely better off choosing a specific Graphical User",
+ "Interface (GUI) toolkit and using its specific event model. But for many",
+ "scientific uses, what matplotlib offers is more than sufficient, and it has the",
+ "advantage of working identically regardless of the GUI toolkit you choose to",
+ "run matplotlib under.",
+ "",
+ "Here we will cover the bare essentials only, for full details you should",
+ "consult the `event handling section`_ of the matplotlib user guide.",
+ "",
+ ".. _event handling section: http://matplotlib.sourceforge.net/users/event_handling.html",
+ "",
+ "The basic idea of *all* event handling is always the same: the windowing",
+ "environment registers an event (mouse movement, click, keyboard press, etc)",
+ "produced by the user. In advance, you have registered *event handlers*:",
+ "functions you define that are meant to be called when specific types of events",
+ "occur. The registration action is called *connecting* the event handler, and",
+ "is performed by the ``mpl_connect`` method of the figure canvas attribute (the",
+ "canvas is the drawing area of the figure object, the entire raw object where",
+ "events take place).",
+ "",
+ "The windowing system will then pass the event (each event has some relevant",
+ "information that goes with it, such as which key or button was pressed) to your",
+ "function, which can act on it. These functions are referred to as *callbacks*,",
+ "because they are meant to be 'called back' not by you, but by the windowing",
+ "toolkit when the right event goes by.",
+ "",
+ "Here is the simplest possible matplotlib event handler::"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "fig, ax = plt.subplots()",
+ "ax.plot(np.random.rand(10))",
+ "",
+ "def onclick(event):",
+ " print 'button=%d, x=%d, y=%d, xdata=%f, ydata=%f'%(",
+ " event.button, event.x, event.y, event.xdata, event.ydata)",
+ "",
+ "cid = fig.canvas.mpl_connect('button_press_event', onclick)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 25
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "The ``FigureCanvas`` method ``mpl_connect`` returns a connection id which",
+ "is simply an integer. When you want to disconnect the callback, just call::",
+ "",
+ " fig.canvas.mpl_disconnect(cid)",
+ "",
+ "The most commonly used event types are ``KeyEvent`` and ``MouseEvent``, both of",
+ "which have the following attributes:",
+ "",
+ " ``x``",
+ " x position - pixels from left of canvas",
+ "",
+ " ``y``",
+ " y position - pixels from bottom of canvas",
+ "",
+ " ``inaxes``",
+ " the ``matplotlib.axes.Axes`` instance if mouse is over axes",
+ "",
+ " ``xdata``",
+ " x coord of mouse in data coords",
+ "",
+ " ``ydata``",
+ " y coord of mouse in data coords",
+ "",
+ "In addition, ``MouseEvent`` have:",
+ "",
+ " ``button``",
+ " button pressed None, 1, 2, 3, 'up', 'down' (up and down are used for",
+ " scroll events)",
+ "",
+ " ``key``",
+ " the key pressed: None, any character, 'shift', 'win', or 'control'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "
",
+ "",
+ "Exercise",
+ "--------",
+ "",
+ "Extend the scatter plot exercise above with the seismic stations, to print the location (four-letter string) of the station you click on. Use a threshold for distance, and discriminate between a click below threshold (considered to be 'on') vs a miss, in which case you should indicate what the closest station is, its coordinates and the distance to it from the click."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Image display",
+ "=============",
+ "",
+ "The ``imshow`` command can display single or multi-channel images. A simple",
+ "array of random numbers, plotted in grayscale:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "from matplotlib import cm",
+ "plt.imshow(np.random.rand(128, 128), cmap=cm.gray, interpolation='nearest')"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 26
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "A real photograph is a multichannel image, `imshow` interprets it correctly:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "img = plt.imread('data/stained_glass_barcelona.png')",
+ "plt.imshow(img)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 27
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "
",
+ " ",
+ "Exercise",
+ "--------",
+ "",
+ "Write a notebook where you can load an image and then perform the following operations on it:",
+ " ",
+ "1. Create a figure with four plots that show both the full-color image and color channel of the image with the right colormap for that color. Ensure that the axes are linked so zooming in one image zooms the same region in the others.",
+ " ",
+ "2. Compute a luminosity and per-channel histogram and display all four histograms in one figure, giving each a separate plot (hint: a 4x1 plot works best for this). Link the appropriate axes together.",
+ " ",
+ "3. Create a black-and-white (or more precisely, grayscale) version of the image. Compare the results from a naive average of all three channels with that of a model that uses 30% red, 59% green and 11% blue, by displaying all three (full color and both grayscales) side by side with linked axes for zooming.",
+ " ",
+ "Hint: look for the matplotlib image tutorial."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Simple 3d plotting with matplotlib",
+ "==================================",
+ "",
+ "Note that you must execute at least once in your session::"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "from mpl_toolkits.mplot3d import Axes3D"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 28
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "One this has been done, you can create 3d axes with the ``projection='3d'`` keyword to ``add_subplot``::",
+ "",
+ " fig = plt.figure()",
+ " fig.add_subplot(
, projection='3d')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "A simple surface plot:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "from mpl_toolkits.mplot3d.axes3d import Axes3D",
+ "from matplotlib import cm",
+ "",
+ "fig = plt.figure()",
+ "ax = fig.add_subplot(1, 1, 1, projection='3d')",
+ "X = np.arange(-5, 5, 0.25)",
+ "Y = np.arange(-5, 5, 0.25)",
+ "X, Y = np.meshgrid(X, Y)",
+ "R = np.sqrt(X**2 + Y**2)",
+ "Z = np.sin(R)",
+ "surf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet,",
+ " linewidth=0, antialiased=False)",
+ "ax.set_zlim3d(-1.01, 1.01)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 29
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "And a parametric surface specified in cylindrical coordinates:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "matplotlib.rcParams['legend.fontsize'] = 10",
+ "",
+ "fig = plt.figure()",
+ "ax = fig.add_subplot(111, projection='3d')",
+ "theta = np.linspace(-4*np.pi, 4*np.pi, 100)",
+ "z = np.linspace(-2, 2, 100)",
+ "r = z**2 + 1",
+ "x = r*np.sin(theta)",
+ "y = r*np.cos(theta)",
+ "ax.plot(x, y, z, label='parametric curve')",
+ "ax.legend()"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 30
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [],
+ "language": "python",
+ "outputs": []
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/mayavi_quicktour.ipynb b/mayavi_quicktour.ipynb
new file mode 100644
index 0000000..63cbc2b
--- /dev/null
+++ b/mayavi_quicktour.ipynb
@@ -0,0 +1,305 @@
+{
+ "metadata": {
+ "name": "mayavi_quicktour"
+ },
+ "nbformat": 2,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# A few simple Mayavi examples",
+ "",
+ "These are all taken from the excellent [Mayavi documentation](http://github.enthought.com/mayavi/mayavi/auto/examples.html)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "%pylab wx"
+ ],
+ "language": "python",
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "",
+ "Welcome to pylab, a matplotlib-based Python environment [backend: WXAgg].",
+ "For more information, type 'help(pylab)'."
+ ]
+ }
+ ],
+ "prompt_number": 1
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Line plot"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import numpy",
+ "from mayavi.mlab import *",
+ "",
+ "def test_plot3d():",
+ " \"\"\"Generates a pretty set of lines.\"\"\"",
+ " n_mer, n_long = 6, 11",
+ " pi = numpy.pi",
+ " dphi = pi/1000.0",
+ " phi = numpy.arange(0.0, 2*pi + 0.5*dphi, dphi)",
+ " mu = phi*n_mer",
+ " x = numpy.cos(mu)*(1+numpy.cos(n_long*mu/n_mer)*0.5)",
+ " y = numpy.sin(mu)*(1+numpy.cos(n_long*mu/n_mer)*0.5)",
+ " z = numpy.sin(n_long*mu/n_mer)*0.5",
+ "",
+ " l = plot3d(x, y, z, numpy.sin(mu), tube_radius=0.025, colormap='Spectral')",
+ " return l",
+ "",
+ "test_plot3d()"
+ ],
+ "language": "python",
+ "outputs": [
+ {
+ "output_type": "pyout",
+ "prompt_number": 19,
+ "text": [
+ ""
+ ]
+ }
+ ],
+ "prompt_number": 19
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Point plot"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import numpy",
+ "from mayavi.mlab import *",
+ "",
+ "def test_points3d():",
+ " t = numpy.linspace(0, 4*numpy.pi, 20)",
+ " cos = numpy.cos",
+ " sin = numpy.sin",
+ "",
+ " x = sin(2*t)",
+ " y = cos(t)",
+ " z = cos(2*t)",
+ " s = 2+sin(t)",
+ "",
+ " return points3d(x, y, z, s, colormap=\"copper\", scale_factor=.25)",
+ "",
+ "test_points3d()"
+ ],
+ "language": "python",
+ "outputs": [
+ {
+ "output_type": "pyout",
+ "prompt_number": 15,
+ "text": [
+ ""
+ ]
+ }
+ ],
+ "prompt_number": 15
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Simple surfaces"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import numpy",
+ "from mayavi.mlab import *",
+ "",
+ "def test_surf():",
+ " \"\"\"Test surf on regularly spaced co-ordinates like MayaVi.\"\"\"",
+ " def f(x, y):",
+ " sin, cos = numpy.sin, numpy.cos",
+ " return sin(x+y) + sin(2*x - y) + cos(3*x+4*y)",
+ "",
+ " x, y = numpy.mgrid[-7.:7.05:0.1, -5.:5.05:0.05]",
+ " s = surf(x, y, f)",
+ " #cs = contour_surf(x, y, f, contour_z=0)",
+ " return s",
+ "",
+ "test_surf()"
+ ],
+ "language": "python",
+ "outputs": [
+ {
+ "output_type": "pyout",
+ "prompt_number": 17,
+ "text": [
+ ""
+ ]
+ }
+ ],
+ "prompt_number": 17
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Images"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import numpy",
+ "from mayavi.mlab import *",
+ "",
+ "def test_imshow():",
+ " \"\"\" Use imshow to visualize a 2D 10x10 random array.",
+ " \"\"\"",
+ " s = numpy.random.random((10,10))",
+ " return imshow(s, colormap='gist_earth')",
+ "",
+ "test_imshow()"
+ ],
+ "language": "python",
+ "outputs": [
+ {
+ "output_type": "pyout",
+ "prompt_number": 12,
+ "text": [
+ ""
+ ]
+ }
+ ],
+ "prompt_number": 12
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## Flow"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import numpy",
+ "from mayavi.mlab import *",
+ "",
+ "def test_flow():",
+ " x, y, z = numpy.mgrid[0:5, 0:5, 0:5]",
+ " r = numpy.sqrt(x**2 + y**2 + z**4)",
+ " u = y*numpy.sin(r)/r",
+ " v = -x*numpy.sin(r)/r",
+ " w = numpy.zeros_like(z)",
+ " obj = flow(u, v, w)",
+ " return obj",
+ "",
+ "test_flow()"
+ ],
+ "language": "python",
+ "outputs": [
+ {
+ "output_type": "pyout",
+ "prompt_number": 18,
+ "text": [
+ ""
+ ]
+ }
+ ],
+ "prompt_number": 18
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### The Lorenz attractor"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "%loadpy http://github.enthought.com/mayavi/mayavi/_downloads/lorenz.py"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 3
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "\"\"\"",
+ "An example displaying the trajectories for the Lorenz system of",
+ "equations along with the z-nullcline.",
+ "",
+ "The vector field of the Lorenz system flow is integrated to display",
+ "trajectories using mlab's flow function:",
+ ":func:`mayavi.mlab.flow`.",
+ "",
+ "The z-nullcline is plotted by extracting the z component of the vector",
+ "field data source with the ExtractVectorComponent filter, and applying",
+ "an IsoSurface module on this scalar component.",
+ "\"\"\"",
+ "# Author: Prabhu Ramachandran ",
+ "# Copyright (c) 2008-2009, Enthought, Inc.",
+ "# License: BSD Style.",
+ "",
+ "import numpy",
+ "from mayavi import mlab",
+ "",
+ "def lorenz(x, y, z, s=10.,r=28., b=8./3.):",
+ " \"\"\"The Lorenz system.\"\"\"",
+ " u = s*(y-x)",
+ " v = r*x -y - x*z",
+ " w = x*y - b*z",
+ " return u, v, w",
+ "",
+ "# Sample the space in an interesting region.",
+ "x, y, z = numpy.mgrid[-50:50:100j,-50:50:100j,-10:60:70j]",
+ "u, v, w = lorenz(x, y, z)",
+ "fig = mlab.figure(size=(400, 300), bgcolor=(0, 0, 0))",
+ "",
+ "# Plot the flow of trajectories with suitable parameters.",
+ "f = mlab.flow(x, y, z, u, v, w, line_width=3, colormap='Paired')",
+ "f.module_manager.scalar_lut_manager.reverse_lut = True",
+ "f.stream_tracer.integration_direction = 'both'",
+ "f.stream_tracer.maximum_propagation = 200",
+ "# Uncomment the following line if you want to hide the seed:",
+ "#f.seed.widget.enabled = False",
+ "",
+ "# Extract the z-velocity from the vectors and plot the 0 level set",
+ "# hence producing the z-nullcline.",
+ "src = f.mlab_source.m_data",
+ "e = mlab.pipeline.extract_vector_components(src)",
+ "e.component = 'z-component'",
+ "zc = mlab.pipeline.iso_surface(e, opacity=0.5, contours=[0,],",
+ " color=(0.6, 1, 0.2))",
+ "# When using transparency, hiding 'backface' triangles often gives better",
+ "# results",
+ "zc.actor.property.backface_culling = True",
+ "",
+ "# A nice view of the plot.",
+ "mlab.view(140, 120, 113, [0.65, 1.5, 27])",
+ "mlab.show()"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 4
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
diff --git a/understanding_images.ipynb b/understanding_images.ipynb
new file mode 100644
index 0000000..a9470cd
--- /dev/null
+++ b/understanding_images.ipynb
@@ -0,0 +1,262 @@
+{
+ "metadata": {
+ "name": "understanding_images"
+ },
+ "nbformat": 2,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# Understanding the structure of digital images",
+ "",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Start by loading libraries we'll need, and we'll set the default figure size to be a little larger"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "#%pylab inline",
+ "%pylab",
+ "from matplotlib import cm",
+ "#plt.rcParams['figure.figsize'] = (8, 8)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 2
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Define a function to load images"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "def image_load(fname, max_size=1200):",
+ " \"\"\"Load an image, downsampling if needed to keep within requested size.",
+ " \"\"\"",
+ " img = plt.imread(fname)",
+ " shape = np.array(img.shape, dtype=float)",
+ " sample_fac = int(np.ceil((shape/max_size).max()))",
+ " if sample_fac > 1:",
+ " new_img = img[::sample_fac, ::sample_fac, ...]",
+ " print 'Downsampling %sX:'% sample_fac, img.shape, '->', new_img.shape",
+ " return new_img",
+ " else:",
+ " return img"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 3
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Now we define the file we're going to load and read it as an image"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "fname = 'data/stained_glass_barcelona.png'",
+ "#fname = 'data/dessert.png'",
+ "",
+ "img = image_load(fname)",
+ "plt.imshow(img)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 4
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "We can directly display the original file in the notebook"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "from IPython.core.display import Image",
+ "Image(filename=fname)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 5
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Extract each color channel and create a figure with 4 subplots, one for each",
+ "channel, so we can see its structure clearly.",
+ "",
+ "Display the full color figure and the color channels"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "red, green, blue = [ img[:,:,i] for i in range(3) ]",
+ "",
+ "f, axes = plt.subplots(1, 4, sharex=True, sharey=True)",
+ "",
+ "axes[0].imshow(img)",
+ "axes[1].imshow(red, cmap=cm.Reds_r)",
+ "axes[2].imshow(green, cmap=cm.Greens_r)",
+ "axes[3].imshow(blue, cmap=cm.Blues_r)",
+ "",
+ "# Turn off tick labels",
+ "for ax in axes:",
+ " ax.set_xticks([])",
+ " ax.set_yticks([])",
+ " ax.set_aspect('auto')"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 6
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Make a new figure and display luminosity and per-channel histograms"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "PNG images sometimes have a 4th transparency channel, sometimes not. To",
+ "be safe, we generate a luminosity array consisting of only the first 3",
+ "channels."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "lumi = img[:,:,:3].mean(axis=2)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 7
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Now, display a histogram for each channel. Note that jpeg images come",
+ "back as integer images with a luminosity range of 0..255 while pngs are",
+ "read as floating point images in the 0..1 range. So we adjust the",
+ "histogram range accordingly:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "hrange = (0.0, 1.0) if lumi.max()<=1.0 else (0.0, 255.0)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 8
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Display the luminosity and per-channel histograms:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "f2, axes2 = plt.subplots(4, 1, sharex=True)",
+ "",
+ "axes2[0].hist(lumi.flatten(), 256, range=hrange, facecolor='k', edgecolor='k')",
+ "axes2[1].hist(red.flatten(), 256, range=hrange, facecolor='r', edgecolor='r')",
+ "axes2[2].hist(green.flatten(), 256, range=hrange, facecolor='g', edgecolor='g')",
+ "axes2[3].hist(blue.flatten(), 256, range=hrange, facecolor='b', edgecolor='b');",
+ "f2.subplots_adjust(hspace=0);",
+ "",
+ "# We want the x tick labels to be invisible on all but the bottom figure",
+ "for ax in axes2[:-1]:",
+ " for label in ax.get_xticklabels():",
+ " label.set_visible(False)",
+ "",
+ "# Don't show the last y label in plots 2-4:",
+ "for ax in axes2[1:]:",
+ " ax.get_yticklabels()[-1].set_visible(False)"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 9
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "imshow(lumi, cmap=cm.Greys_r);"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 10
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "Let's do a slightly different encoding of the color channels: 30% red, 59% green, 11% blue"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [
+ "lumi2 = .3*red + .59*green + 0.11*blue",
+ "",
+ "fig, axes = plt.subplots(1, 3, figsize=(12, 8), sharex=True, sharey=True)",
+ "",
+ "axes[0].imshow(img); axes[0].set_title('Color')",
+ "axes[1].imshow(lumi, cmap=cm.Greys_r); axes[1].set_title('Naive gray')",
+ "axes[2].imshow(lumi2, cmap=cm.Greys_r); axes[2].set_title('Better gray')",
+ "",
+ "for ax in axes:",
+ " ax.set_xticks([])",
+ " ax.set_yticks([])",
+ " ax.set_aspect('auto')"
+ ],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 11
+ },
+ {
+ "cell_type": "code",
+ "collapsed": true,
+ "input": [],
+ "language": "python",
+ "outputs": [],
+ "prompt_number": 10
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file