{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Image Processing SS 16 - Assignment - 01\n",
    "\n",
    "### Deadline is 27.4.2016 at 16:00\n",
    "\n",
    "Please solve the assignments together with a partner.\n",
    "I will run every notebook. Make sure the code runs through, when clicked on `Kernel` -> `Restart & Run All`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Python / Numpy\n",
    "\n",
    "* [Learn Python in 15 minutes](https://learnxinyminutes.com/docs/python/)\n",
    "* [Numpy for Matlab Users](https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html#general-purpose-equivalents)\n",
    "* [Numpy Quickstart](https://docs.scipy.org/doc/numpy-dev/user/quickstart.html)\n",
    "\n",
    "## Libraries\n",
    "\n",
    "We will use the following libraries:\n",
    "\n",
    "* matplotlib\n",
    "* numpy\n",
    "* scipy\n",
    "* skimage\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 0 - Setup Development Enviroment - [1 Point]\n",
    "\n",
    "Find a partner, follow the steps in the [README](https://github.com/) and paste a link to your repository, names and matriculation numbers into the KVV assignment box.\n",
    "You do not need to upload any files to the KVV. I will clone your repository. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# display the plots inside the notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pylab\n",
    "import copy\n",
    "pylab.rcParams['figure.figsize'] = (12, 12)   # This makes the plot bigger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The [skimage](http://scikit-image.org/) library comes with multiple useful test images.  Let's start with an image of an astronaut. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage.data import astronaut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = astronaut()   # Get the image\n",
    "print(img.shape)    # the dimension of the image\n",
    "print(img.dtype)    # the image type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a `(512, 512, 3)` array of unsigned bytes. At `img[x, y]` there are three values for R,G and B."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will always work with floating point arrays between 0 and 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = img / 255."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets display the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(img)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is [Eileen Collins](https://en.wikipedia.org/wiki/Eileen_Collins). She was the first astronaut \n",
    " to fly the Space Shuttle through a complete 360-degree pitch maneuver. What an inspiring woman."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1 - Plot -       [1 Point]\n",
    "\n",
    "Plot the R, G and B channels separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_red = copy.deepcopy(img)\n",
    "img_red[:,:,1] = 0\n",
    "img_red[:,:,2] = 0\n",
    "plt.imshow(img_red)\n",
    "plt.show()\n",
    "\n",
    "img_green = copy.deepcopy(img);\n",
    "img_green[:,:,0] = 0\n",
    "img_green[:,:,2] = 0\n",
    "plt.imshow(img_green)\n",
    "plt.show()\n",
    "\n",
    "img_blue = copy.deepcopy(img);\n",
    "img_blue[:,:,0] = 0\n",
    "img_blue[:,:,1] = 0\n",
    "plt.imshow(img_blue)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2 - RGB to HSV [6 Points]\n",
    "\n",
    "Implement the `rgb_to_hsv` and `hsv_to_rgb` functions. Don't use any color conversion functions from a library.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def rgb_to_hsv(x):\n",
    "    \"\"\"\n",
    "    Converts the numpy array `x` from RGB to the HSV. \n",
    "    \"\"\"\n",
    "    hsv=[]\n",
    "    for line in x:\n",
    "        newLine=[]\n",
    "        for pixel in line:\n",
    "            r= pixel[0]/255\n",
    "            g= pixel[1]/255\n",
    "            b= pixel[2]/255\n",
    "            cMax = np.amax([r,g,b])\n",
    "            cMin = min([r,g,b])\n",
    "            delta = cMax-cMin\n",
    "            v = cMax\n",
    "            h=0\n",
    "            s=0\n",
    "            if v > 0:\n",
    "                s = delta/cMax\n",
    "            if s>0 :\n",
    "                if r == cMax:\n",
    "                    h= ((g-b)/delta)%6\n",
    "                elif g==cMax:\n",
    "                    h= ((b-r)/delta)+2\n",
    "                elif b==cMax:\n",
    "                    h=((r-g)/delta)+4\n",
    "            h=h*60\n",
    "            if h<0:\n",
    "                h=h+360\n",
    "            newLine.append([h,s,v])\n",
    "        hsv.append(newLine)\n",
    "    return hsv\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def hsv_to_rgb(x):\n",
    "    \"\"\"\n",
    "    Converts the numpy array `x` from HSV to the RGB. \n",
    "    \"\"\"\n",
    "    rgb = []\n",
    "    for line in x:\n",
    "        newLine=[]\n",
    "        for pixel in line:\n",
    "            h= pixel[0]\n",
    "            s= pixel[1]\n",
    "            v= pixel[2]\n",
    "            c =  v*s\n",
    "            x=c*(1-abs(((h/60)%2)-1))\n",
    "            m= v-c\n",
    "            tmpPixel= [0,0,0]\n",
    "            if h >= 0 and h <60:\n",
    "                tmpPixel=[c,x,0]\n",
    "            elif h >= 60 and h <120:\n",
    "                 tmpPixel=[x,c,0]\n",
    "            elif h >= 120 and h <180:\n",
    "                 tmpPixel=[0,c,x]\n",
    "            elif h >= 180 and h <240:\n",
    "                 tmpPixel=[0,x,c]\n",
    "            elif h >= 240 and h <300:\n",
    "                 tmpPixel=[x,0,c]\n",
    "            elif h >= 300 and h <360:\n",
    "                 tmpPixel=[c,0,x]\n",
    "            newLine.append([(tmpPixel[0]+m)*255,(tmpPixel[1]+m)*255,(tmpPixel[2]+m)*255])\n",
    "        rgb.append(newLine)\n",
    "    return rgb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot the saturation of the astronaut image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_as_hsv = rgb_to_hsv(img)\n",
    "\n",
    " # your code\\n\",\n",
    "\n",
    "img_saturation=copy.deepcopy(np.array(img_as_hsv))\n",
    "img_saturation[:,:,0]=0\n",
    "img_saturation[:,:,2]=0\n",
    "plt.imshow(img_saturation[:, :, 1], cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Increase the saturation by a factor of 2, convert it back to RGB and plot the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "img_as_hsv = rgb_to_hsv(img)\n",
    "# your code\\n\",\n",
    "img_saturation = []\n",
    "for line in img_as_hsv:\n",
    "    newLine=[]\n",
    "    for pixel in line:\n",
    "        newPixel=[]\n",
    "        newPixel.append(pixel[0])    \n",
    "        newSaturation = pixel[1]*2\n",
    "        if newSaturation >1:\n",
    "            newSaturation=1\n",
    "\n",
    "        newPixel.append(newSaturation)\n",
    "        newPixel.append(pixel[2])\n",
    "        newLine.append(newPixel)\n",
    "    img_saturation.append(newLine)\n",
    "\n",
    "img_as_rgb= hsv_to_rgb(img_saturation)\n",
    "plt.imshow(img_as_rgb)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 3 - Callculation [2 Points]\n",
    "\n",
    "In the figure below you can see the [CIE-XYZ](https://de.wikipedia.org/wiki/CIE-Normvalenzsystem) color space.\n",
    "![](https://upload.wikimedia.org/wikipedia/commons/4/49/CIE-Normfarbtafel.png)\n",
    "\n",
    "What are the approximate x,y,z values for the following Adobe RGB colors:\n",
    "* `(0, 0.5, 0.5)`\n",
    "* `(0.33, 0.33, 0.33)`\n",
    "\n",
    "A sodium-vapor lamp shines with double the intensity of a mercury-vapor lamp\n",
    ". The light from the sodium lamp only contains \n",
    "the spectral line at `589,00nm` and the light from the mercury lamp only the\n",
    "spectral line at `435,83 nm`.\n",
    "\n",
    "What color does a human experience? What are the approximate x,y,z values? \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "T=np.matrix([[2.04159, -0.56501, -0.34473],[-0.96924, 1.87597, 0.04156],[0.01344, -0.11836, 1.01517]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "ARGB1 = np.array([0, 0.5, 0.5])\n",
    "ARGB2 = np.array([0.33, 0.33, 0.33])\n",
    "\n",
    "XYZ1 = (T.I).dot(ARGB1)\n",
    "print(XYZ1)\n",
    "\n",
    "XYZ2 = (T.I).dot(ARGB2)\n",
    "print(XYZ2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# For a sodium-vapor lamp and a mercury-vapor lamp a human does experience a bright red.\n",
    "# The approximate x,y,z values are 0.5, 0.32, 0.18\n",
    "# You can read the values directly from the XYZ-diagram. Connect the two spectral lines with a line.\n",
    "# The resulting color is on this line. \n",
    "# As the two colors mix and the sodium lamp has double intensity, the color that a human experience is nearer to \n",
    "# the sodium lamp.\n",
    "# It is exactly 1/3 of the total line length from the sodium spectral line away. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
