{
 "metadata": {
  "name": "",
  "signature": "sha256:fbbaf755166ee8e7ebdd63d35c9afb2492ac0e276f7a7556fca9f9d55cb6eacc"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 1"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 1: Try to compute the BMI of each subject, as well as the average BMI across subjects\n",
      "# BMI = weight/(length/100)**2\n",
      "\n",
      "subj_length = [180.0,165.0,190.0,172.0,156.0]\n",
      "subj_weight = [75.0,60.0,83.0,85.0,62.0]\n",
      "subj_bmi = []"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!-- \n",
      "n = len(subj_length)\n",
      "summed = 0.\n",
      "for subj in range(n):\n",
      "    subj_bmi.append(subj_weight[subj]/(subj_length[subj]/100)**2)\n",
      "    summed = summed + subj_bmi[subj]\n",
      "print subj_bmi\n",
      "print summed/n \n",
      "-->"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 2"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 2: Try to complete the program now!\n",
      "# Hint: np.mean() computes the mean of an ndarray\n",
      "# Note that unlike MATLAB, Python does not need the '.' before elementwise operators\n",
      "\n",
      "import numpy as np\n",
      "subj_length = np.array([180.0,165.0,190.0,172.0,156.0])\n",
      "subj_weight = np.array([75.0,60.0,83.0,85.0,62.0])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!--\n",
      "subj_bmi = subj_weight/(subj_length/100)**2 \n",
      "mean_bmi = np.mean(subj_bmi)\n",
      "print subj_bmi\n",
      "print mean_bmi\n",
      "-->"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 3"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 3: Create a 2x3 array containing the column-wise and the row-wise means of the original matrix\n",
      "# Do not use a for-loop, and also do not use the np.mean() function for now.\n",
      "\n",
      "arr = np.array([[1,2,3],[4,5,6],[7,8,9]], dtype='float')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!--\n",
      "res = np.array([(arr[:,0]+arr[:,1]+arr[:,2])/3,(arr[0,:]+arr[1,:]+arr[2,:])/3])\n",
      "print res\n",
      "print res.shape\n",
      "-->"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 4"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 4: Create your own meshgrid3d function\n",
      "# Like np.meshgrid(), it should take two vectors and replicate them; one into columns, the other into rows\n",
      "# Unlike np.meshgrid(), it should return them as a single 3D array rather than 2D arrays\n",
      "# ...do not use the np.meshgrid() function"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!--\n",
      "def meshgrid3d(xvec, yvec):\n",
      "    xlayer = np.tile(xvec,(len(yvec),1))\n",
      "    ylayer = np.tile(yvec,(len(xvec),1)).T\n",
      "    return np.dstack((xlayer,ylayer))\n",
      "\n",
      "xvec = np.arange(10)\n",
      "yvec = np.arange(5)\n",
      "xy = meshgrid3d(xvec, yvec)\n",
      "print xy\n",
      "print xy[:,:,0] # = first output of np.meshgrid()\n",
      "print xy[:,:,1] # = second output of np.meshgrid()\n",
      "-->"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 5"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 5: Make a better version of Exercise 3 with what you've just learned\n",
      "arr = np.array([[1,2,3],[4,5,6],[7,8,9]], dtype='float')\n",
      "\n",
      "# What we had:\n",
      "print np.array([(arr[:,0]+arr[:,1]+arr[:,2])/3,(arr[0,:]+arr[1,:]+arr[2,:])/3])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!--\n",
      "# Now the new version:\n",
      "print np.vstack((np.mean(arr,1), np.mean(arr,0)))\n",
      "-->"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 6"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 6: Create a Gabor patch of 100 by 100 pixels\n",
      "\n",
      "import numpy as np\n",
      "import matplotlib.pyplot as plt"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!--\n",
      "# Create x and y coordinates\n",
      "vals = np.linspace(-np.pi, np.pi, 100)\n",
      "x,y = np.meshgrid(vals, vals)\n",
      "\n",
      "# Make grating, gaussian, gabor\n",
      "grating = np.sin(x*10)\n",
      "gaussian = np.exp(-((x**2)+(y**2))/2)\n",
      "gabor = grating*gaussian\n",
      "\n",
      "# Visualize your result\n",
      "# (we will discuss how this works later)\n",
      "plt.figure(figsize=(15,5))\n",
      "plt.subplot(131)\n",
      "plt.imshow(grating, cmap='gray')\n",
      "plt.subplot(132)\n",
      "plt.imshow(gaussian, cmap='gray')\n",
      "plt.subplot(133)\n",
      "plt.imshow(gabor, cmap='gray')\n",
      "plt.show()\n",
      "-->"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 7"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 7: Vectorize the above program\n",
      "# You get these lines for free...\n",
      "\n",
      "import numpy as np\n",
      "throws = np.random.randint(1,7,(5000,2000))\n",
      "one = (throws==1)\n",
      "two = (throws==2)\n",
      "three = (throws==3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!--\n",
      "# Find out where all the 111 and 123 sequences occur\n",
      "find111 = one[:,:-2] & one[:,1:-1] & one[:,2:]\n",
      "find123 = one[:,:-2] & two[:,1:-1] & three[:,2:]\n",
      "\n",
      "# Then at what index they /first/ occur in each sequence\n",
      "first111 = np.argmax(find111, axis=1)\n",
      "first123 = np.argmax(find123, axis=1)\n",
      "\n",
      "# Compute the average first occurence location for both situations\n",
      "avg111 = np.mean(first111)\n",
      "avg123 = np.mean(first123)\n",
      "\n",
      "# Print the result\n",
      "print avg111, avg123\n",
      "-->"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 8"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 8: Visualize the difference between the PIL conversion to grayscale, and a simple average of RGB\n",
      "# Display pixels where the average is LESS luminant in red, and where it is MORE luminant in shades green\n",
      "# The luminance of these colors should correspond to the size of the difference\n",
      "# Extra: Maximize the overall contrast in your image\n",
      "# Extra2: Save as three PNG files, of different sizes (large, medium, small)\n",
      "\n",
      "import numpy as np\n",
      "from PIL import Image\n",
      "im = Image.open('python.jpg')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!--\n",
      "# Do both grayscale conversions\n",
      "im_avg = np.array(im)\n",
      "im_avg = np.mean(im_avg,2)\n",
      "im_pil = im.convert('L')\n",
      "im_pil = np.array(im_pil)\n",
      "\n",
      "# Compute the difference per pixel\n",
      "imd = im_avg-im_pil\n",
      "\n",
      "# Assign different colors according to the direction of difference\n",
      "outp = np.zeros((im_avg.shape)+(3,))\n",
      "outp[:,:,0][imd<0] = -imd[imd<0]\n",
      "outp[:,:,1][imd>0] = imd[imd>0]\n",
      "\n",
      "# Maximize contrast\n",
      "outp = outp * (255./np.max(outp))\n",
      "\n",
      "# Conversion back to a PIL image\n",
      "outp = outp.astype('uint8')\n",
      "outp_pil = Image.fromarray(outp, mode='RGB')\n",
      "\n",
      "# Save with three different sizes\n",
      "sz = np.array(outp_pil.size)\n",
      "sz_name = ['large','medium','small']\n",
      "for n,fct in enumerate([1,2,4]):\n",
      "    outp_rsz = outp_pil.resize(sz/fct)\n",
      "    outp_rsz.save('python_'+sz_name[n]+'.png')\n",
      "-->"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 9"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 9: Plot y=sin(x) and y=sin(x^2) in two separate subplots, one above the other\n",
      "# Let x range from 0 to 2*pi\n",
      "\n",
      "import numpy as np\n",
      "import matplotlib.pyplot as plt\n",
      "import matplotlib.patches"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!--\n",
      "# X-axis values\n",
      "x = np.linspace(0,2*np.pi,1000)\n",
      "\n",
      "# Figure and Axes creation\n",
      "fig = plt.figure(figsize=(10,5))\n",
      "ax0 = fig.add_subplot(211)\n",
      "ax1 = fig.add_subplot(212)\n",
      "\n",
      "# Make the plots\n",
      "ax0.plot(x,np.sin(x),'r-', linewidth=2)\n",
      "ax1.plot(x,np.sin(x**2),'b-', linewidth=2)\n",
      "\n",
      "# Finetune the plots\n",
      "ax0.set_xlim([0,2*np.pi])\n",
      "ax0.set_xticks([])\n",
      "ax1.set_xlim([0,2*np.pi])\n",
      "\n",
      "# Show the figure\n",
      "fig.show()\n",
      "-->"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Exercise 10"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# EXERCISE 10: Add regression lines\n",
      "\n",
      "import numpy as np\n",
      "from PIL import Image\n",
      "import matplotlib.pyplot as plt\n",
      "import matplotlib.lines as lines\n",
      "\n",
      "# Open image, convert to an array\n",
      "im = Image.open('python.jpg')\n",
      "im = im.resize((400,300))\n",
      "arr = np.array(im, dtype='float')\n",
      "\n",
      "# Split the RGB layers and flatten them\n",
      "R,G,B = np.dsplit(arr,3)\n",
      "R = R.flatten()\n",
      "G = G.flatten()\n",
      "B = B.flatten()\n",
      "\n",
      "# Do the plotting\n",
      "plt.figure(figsize=(5,5))\n",
      "plt.plot(R, B, marker='x', linestyle='None', color=(0,0,0.6))\n",
      "plt.plot(R, G, marker='.', linestyle='None', color=(0,0.35,0))\n",
      "\n",
      "# Tweak the plot\n",
      "plt.axis([0,255,0,255])\n",
      "plt.xlabel('Red value')\n",
      "plt.ylabel('Green/Blue value')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Solution\n",
      "<!--\n",
      "# Do the linear regressions\n",
      "regRB = np.polyfit(R,B,1)\n",
      "regRG = np.polyfit(R,G,1)\n",
      "\n",
      "# Create the line objects\n",
      "xaxv = np.arange(255.)\n",
      "lRB = lines.Line2D(xaxv,regRB[1]+xaxv*regRB[0], color='k')\n",
      "lRG = lines.Line2D(xaxv,regRG[1]+xaxv*regRG[0], color='k')\n",
      "\n",
      "# Fetch the current Axes, and attach the lines to it\n",
      "ax = plt.gca()\n",
      "ax.add_artist(lRB)\n",
      "ax.add_artist(lRG)\n",
      "\n",
      "# Show the result\n",
      "plt.show()\n",
      "-->"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}