01-working-with-images-part-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with images\n",
    "\n",
    "### importing the necessary modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading an image from file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "img = cv2.imread('images/opencv-logo.png', cv2.IMREAD_GRAYSCALE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second argument is a flag which specifies the way image should be read.\n",
    "\n",
    "* cv2.IMREAD_COLOR : Loads a color image. Any transparency of image will be neglected. It is the default flag.\n",
    "* cv2.IMREAD_GRAYSCALE : Loads image in grayscale mode\n",
    "* cv2.IMREAD_UNCHANGED : Loads image as such including alpha channel\n",
    "\n",
    "### displaying the image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv2.imshow('image',img)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### but what is the image itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " ...\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "print(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "width = 99\n",
      "height = 82\n"
     ]
    }
   ],
   "source": [
    "width, height = img.shape[:2]\n",
    "print(\"width = {}\".format(width))\n",
    "print(\"height = {}\".format(height))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Please note that {img.shape} will hold an array of 3 when the image is in color the third number is the channels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### saving an image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv2.imwrite('test.png',img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Color spaces (modes)\n",
    "\n",
    "OpenCV supports several color spaces\n",
    "* RGB   - Red Green Blue\n",
    "* LAB   - L: Lightness (Intensity), A: ranging from Green to Magenta, B: ranging from Blue to Yellow  \n",
    "* HSV   - Hue (Dominant Wavelength), Saturation(Purity / shades of the color), Value(Intensity)\n",
    "* YCrCb - ...\n",
    "\n",
    "### RGB (OpenCV uses BGR)\n",
    "\n",
    "* comprised of three 8 bit triplet (e.g. (10, 20, 30) \n",
    "* each color holds 256 possiblities\n",
    "\n",
    "QUESTION - How many different colors can be produces from this color scheme ?\n",
    "\n",
    "#### RGB color table\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](images/rgb-color-table.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To read more on the other color spaces take a look at  https://www.learnopencv.com/color-spaces-in-opencv-cpp-python/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to access a single pixel\n",
    "\n",
    "### Standard coordinate system (cartesian)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](images/cartesian_coordinates.png)\n",
    "\n",
    "coordinates are specified in (x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### coordinate system used in images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](images/image_coordinates.png)\n",
    "\n",
    "coordinates are specified in (y, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Drawing on images\n",
    "\n",
    "### First lets create a blank image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "\n",
    "image = np.zeros((512,512,3), np.uint8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "cv2.imshow('image',image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drawing a line\n",
    "\n",
    "Draw a diagonal blue line with thickness of 5 px"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.line(image,(0,0),(511,511),(255,0,0), 1)\n",
    "cv2.imshow('image',image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drawing a rectangle\n",
    "\n",
    "To draw a rectangle, you need top-left corner and bottom-right corner of rectangle. This time we will draw a green rectangle at the top-right corner of image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.rectangle(image,(384,0),(510,128),(0,255,0),3)\n",
    "cv2.imshow('image',image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drawing a circle\n",
    "\n",
    "To draw a circle, you need its center coordinates and radius. We will draw a circle inside the rectangle drawn above.<BR>\n",
    "please note that the last parameter below is the line thickness , when a -1 ig given the rectangle is filled with color."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.circle(image,(447,63), 63, (0,0,255), -1)\n",
    "cv2.imshow('image',image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drawing Ellipse\n",
    "\n",
    "To draw the ellipse, we need to pass several arguments.\n",
    "* The center location (x,y). \n",
    "* Axes lengths (major axis length, minor axis length). \n",
    "* Angle is the angle of rotation of ellipse in anti-clockwise direction. \n",
    "* StartAngle \n",
    "* EndAngle (denotes the starting and ending of ellipse arc measured in clockwise direction from major axis. i.e. giving values 0 and 360 gives the full ellipse. \n",
    "* Color (a tupple of 3 can be given) or a single uint8 (= blue)\n",
    "* Thickness (-1 = fill)\n",
    "\n",
    "For more details, check the documentation of cv2.ellipse(). Below example draws a half ellipse at the center of the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.ellipse(image,(256,256),(100,50),0,0,180,(255,255,255),1)\n",
    "cv2.imshow('image',image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Drawing a polygon\n",
    "\n",
    "To draw a polygon, first you need coordinates of vertices. Make those points into an array of shape ROWSx1x2 where ROWS are number of vertices and it should be of type int32. Here we draw a small polygon of with four vertices in yellow color."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "pts = np.array([[100,10],[200,20],[180,100],[80,50]], np.int32)\n",
    "pts = pts.reshape((-1,1,2))\n",
    "image = cv2.polylines(image,[pts],True,(0,255,255))\n",
    "cv2.imshow('image',image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note:\n",
    "* If third argument (in cv2.polylines(..)) is False, you will get a polylines joining all the points, not a closed shape.\n",
    "* cv2.polylines() can be used to draw multiple lines. Just create a list of all the lines you want to draw and pass it to the function. All lines will be drawn individually. It is more better and faster way to draw a group of lines than calling cv2.line() for each line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding Text to Images:\n",
    "\n",
    "#### To put texts in images, you need specify following things\n",
    "* Text data that you want to write\n",
    "* Position coordinates of where you want put it (i.e. bottom-left corner where data starts).\n",
    "* Font type (Check cv2.putText() docs for supported fonts)\n",
    "* Font Scale (specifies the size of font)\n",
    "* color\n",
    "* thickness, \n",
    "* lineType (lineType = cv2.LINE_AA is recommended)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "font = cv2.FONT_HERSHEY_SIMPLEX\n",
    "cv2.putText(image,'OpenCV',(10,500), font, 4,(255,255,255),2,cv2.LINE_AA)\n",
    "cv2.imshow('image',image)\n",
    "cv2.waitKey(0)\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More on image file formats\n",
    "\n",
    "Discussion on Image file formats can be found at https://mmeysenburg.github.io/image-processing/02-image-basics/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ASSIGNMENT\n",
    "\n",
    "create a simple animation using only the above API you have learned.\n",
    "The animation should last at least 10 seconds."
   ]
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}