Optical Flow.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optical Flow\n",
    "### Optical flow works on several assumptions:\n",
    "#### 1.The pixel intensities of an object do not change between consecutive frames.\n",
    "#### 2.Neighbouring pixels have similar motion."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lucas-Kanade Optical Flow in OpenCV\n",
    "##### 1.Picking few 'corner' points in 1st frame & track them throught video\n",
    "### Parameters for Lucas Kanade Optical Flow\n",
    "Detect the motion of specific points or the aggregated motion of regions by modifying the winSize argument. This determines the integration window size. Small windows are more sensitive to noise and may miss larger motions. Large windows will “survive” an occlusion.\n",
    "\n",
    "The integration appears smoother with the larger window size.\n",
    "\n",
    "criteria has two here - the max number (10 above) of iterations and epsilon (0.03 above). More iterations means a more exhaustive search, and a smaller epsilon finishes earlier. These are primarily useful in exchanging speed vs accuracy, but mainly stay the same.\n",
    "\n",
    "When maxLevel is 0, it is the same algorithm without using pyramids (ie, calcOpticalFlowLK). Pyramids allow finding optical flow at various resolutions of the image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters for ShiTomasi corner detection (good features to track paper)\n",
    "corner_track_params = dict(maxCorners = 10,\n",
    "                       qualityLevel = 0.3,\n",
    "                       minDistance = 7,\n",
    "                       blockSize = 7 )\n",
    "# Parameters for lucas kanade optical flow\n",
    "lk_params = dict( winSize  = (200,200),\n",
    "                  maxLevel = 2,\n",
    "                  criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10,0.03))\n",
    "\n",
    "# Capture the video\n",
    "cap = cv2.VideoCapture(0)\n",
    "\n",
    "# Grab the very first frame of the stream\n",
    "ret, prev_frame = cap.read()\n",
    "\n",
    "# Grab a grayscale image (We will refer to this as the previous frame)\n",
    "prev_gray = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "# Grabbing the corners\n",
    "prevPts = cv2.goodFeaturesToTrack(prev_gray, mask = None, **corner_track_params)\n",
    "\n",
    "# Create a matching mask of the previous frame for drawing on later\n",
    "mask = np.zeros_like(prev_frame)\n",
    "\n",
    "\n",
    "while True:\n",
    "    \n",
    "    # Grab current frame\n",
    "    ret,frame = cap.read()\n",
    "    \n",
    "    # Grab gray scale\n",
    "    frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n",
    "    \n",
    "    # Calculate the Optical Flow on the Gray Scale Frame\n",
    "    nextPts, status, err = cv2.calcOpticalFlowPyrLK(prev_gray, frame_gray, prevPts, None, **lk_params)\n",
    "    \n",
    "    # Using the returned status array (the status output)\n",
    "    # status output status vector (of unsigned chars); each element of the vector is set to 1 if\n",
    "    # the flow for the corresponding features has been found, otherwise, it is set to 0.\n",
    "    good_new = nextPts[status==1]\n",
    "    good_prev = prevPts[status==1]\n",
    "    '''\n",
    "    good_new [[407. 341.]]\n",
    "    ststus [[1]]\n",
    "    nxtpts [[[407. 341.]]]\n",
    "    good_new [[406.5915 340.9327]]\n",
    "    ststus [[1]]\n",
    "    nxtpts [[[406.5915 340.9327]]]\n",
    "    good_new [[406.5915 340.9327]]\n",
    "    ststus [[1]]\n",
    "    nxtpts [[[406.5915 340.9327]]]\n",
    "    good_new [[405.3383  340.77698]]\n",
    "    ststus [[1]]\n",
    "    '''\n",
    "    \n",
    "    # Use ravel to get points to draw lines and circles\n",
    "    for i,(new,prev) in enumerate(zip(good_new,good_prev)):\n",
    "        \n",
    "        x_new,y_new = new.ravel()\n",
    "        x_prev,y_prev = prev.ravel()\n",
    "        \n",
    "        # Lines will be drawn using the mask created from the first frame\n",
    "        mask = cv2.line(mask, (x_new,y_new),(x_prev,y_prev), (0,255,0), 3)\n",
    "        \n",
    "        # Draw red circles at corner points\n",
    "        frame = cv2.circle(frame,(x_new,y_new),8,(0,0,255),-1)\n",
    "    \n",
    "    # Display the image along with the mask we drew the line on.\n",
    "    img = cv2.add(frame,mask)\n",
    "    cv2.imshow('frame',img)\n",
    "    \n",
    "    k = cv2.waitKey(30) & 0xff\n",
    "    if k == 27:\n",
    "        break\n",
    "   \n",
    "    # Now update the previous frame and previous points\n",
    "    prev_gray = frame_gray.copy()\n",
    "    prevPts = good_new.reshape(-1,1,2)\n",
    "    \n",
    "    \n",
    "cv2.destroyAllWindows()\n",
    "cap.release()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 2.Picking a point 'Manually'  & track them throught video"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "clicked=False\n",
    "\n",
    "\n",
    "lk_params=dict(winSize=(200,200),maxLevel=2,criteria=(cv2.TERM_CRITERIA_EPS|cv2.TERM_CRITERIA_COUNT,10,0.03))\n",
    "\n",
    "def track_pts(event,x,y,flags,params):\n",
    "    global clicked,prev_pts\n",
    "    if event==cv2.EVENT_LBUTTONDOWN:\n",
    "        clicked=True\n",
    "        #(x_prev,y_prev)=(x,y)\n",
    "        \n",
    "        prev_pts=np.array([x,y])\n",
    "        prev_pts=np.float32(prev_pts.reshape((-1,1,2)))\n",
    "        \n",
    "\n",
    "\n",
    "cv2.namedWindow('track')\n",
    "cv2.setMouseCallback('track',track_pts)\n",
    "\n",
    "cap=cv2.VideoCapture(0)\n",
    "t=0\n",
    "\n",
    "while True:\n",
    "    ret,frame=cap.read()\n",
    "    if clicked:\n",
    "        frame_gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)\n",
    "        nxtpts,status,error=cv2.calcOpticalFlowPyrLK(prev_gray,frame_gray,prev_pts,None,**lk_params)\n",
    "        \n",
    "        \n",
    "        good_new=nxtpts[status==1]\n",
    "        #print('good_new',good_new)\n",
    "        #print('ststus',status)\n",
    "        #print('nxtpts',nxtpts)\n",
    "        good_prev=prev_pts[status==1]\n",
    "        \n",
    "        for i,(new,prev) in enumerate(zip(good_new,good_prev)):\n",
    "                x_new,y_new=new.ravel()\n",
    "                x_old,y_old=prev.ravel()\n",
    "                frame=cv2.circle(frame,(x_new,y_new),5,(0,0,255),-1)\n",
    "                mask=cv2.line(mask,(x_old,y_old),(x_new,y_new),(255,0,0),3)\n",
    "                img=cv2.add(frame,mask)\n",
    "\n",
    "                #frame==cv2.line(frame,(x_new,y_new),(x_old,y_old),(0,255,0),3)\n",
    "        cv2.imshow('track',img)\n",
    "        prev_pts=good_new.reshape(-1,1,2)\n",
    "        \n",
    "    else:\n",
    "        frame_gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)\n",
    "        cv2.imshow('track',frame)\n",
    "        \n",
    "    if t==0:\n",
    "        mask=np.zeros_like(frame)\n",
    "        t+=1    \n",
    "    prev_gray=frame_gray.copy()\n",
    "    \n",
    "    \n",
    "    \n",
    "    k=cv2.waitKey(30)&0xFF\n",
    "    if k==27:\n",
    "        break\n",
    "        \n",
    "        \n",
    "cap.release()    \n",
    "cv2.destroyAllWindows()         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dense Optical Flow in OpenCV"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dense Optical Flow in OpenCV\n",
    "\n",
    "calcOpticalFlowFarneback(prev, next, flow, pyr_scale, levels, winsize, iterations, poly_n, poly_sigma, flags) -> flow\n",
    "\n",
    "This function computes a dense optical flow using the Gunnar Farneback's algorithm.\n",
    "\n",
    "Here are the parameters for the function and what they represent:\n",
    "   \n",
    "\n",
    "* prev first 8-bit single-channel input image.\n",
    "* next second input image of the same size and the same type as prev.\n",
    "* flow computed flow image that has the same size as prev and type CV_32FC2.\n",
    "* pyr_scale parameter, specifying the image scale (\\<1) to build pyramids for each image\n",
    "    * pyr_scale=0.5 means a classical pyramid, where each next layer is twice smaller than the previous one.\n",
    "    \n",
    "* levels number of pyramid layers including the initial image; levels=1 means that no extra layers are created and only the original images are used.\n",
    "* winsize averaging window size\n",
    "    * larger values increase the algorithm robustness to image\n",
    "* noise and give more chances for fast motion detection, but yield more blurred motion field.\n",
    "* iterations number of iterations the algorithm does at each pyramid level.\n",
    "* poly_n size of the pixel neighborhood used to find polynomial expansion in each pixel\n",
    "    * larger values mean that the image will be approximated with smoother surfaces, yielding more robust algorithm and more blurred motion field, typically poly_n =5 or 7.\n",
    "* poly_sigma standard deviation of the Gaussian that is used to smooth derivatives used as a basis for the polynomial expansion; for poly_n=5, you can set poly_sigma=1.1, for poly_n=7, a good value would be poly_sigma=1.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "cap=cv2.VideoCapture(0)\n",
    "ret,frame1=cap.read()\n",
    "\n",
    "prev_img=cv2.cvtColor(frame1,cv2.COLOR_BGR2GRAY)\n",
    "hsv_mask=np.zeros_like(frame1)\n",
    "hsv_mask[:,:,1]=255\n",
    "\n",
    "while True:\n",
    "    ret,frame2=cap.read()\n",
    "    nxt_img=cv2.cvtColor(frame2,cv2.COLOR_BGR2GRAY)\n",
    "    \n",
    "    flow=cv2.calcOpticalFlowFarneback(prev_img,nxt_img,None,0.5,3,15,3,5,1.2,0)\n",
    "    \n",
    "    #convet flow into polor co_ordinates\n",
    "    mag,ang=cv2.cartToPolar(flow[:,:,0],flow[:,:,1],angleInDegrees=True)\n",
    "    hsv_mask[:,:,0]=ang/2.0\n",
    "    hsv_mask[:,:,2]=cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)\n",
    "    \n",
    "    bgr = cv2.cvtColor(hsv_mask,cv2.COLOR_HSV2BGR)\n",
    "    cv2.imshow('frame2',bgr)\n",
    "    \n",
    "    k = cv2.waitKey(30) & 0xff\n",
    "    if k == 27:\n",
    "        break\n",
    "    \n",
    "    # Set the Previous image as the next iamge for the loop\n",
    "    prev_img = nxt_img\n",
    "\n",
    "    \n",
    "cap.release()\n",
    "cv2.destroyAllWindows()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}