Untitled.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "from __future__ import division\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import cv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from IPython.display import HTML\n",
    "\n",
    "def showVideo(filename, width=None):\n",
    "    # from IPython.display import HTML\n",
    "    video = open(filename, \"rb\").read()\n",
    "    video_encoded = video.encode(\"base64\")\n",
    "    if width:\n",
    "        video_tag = '<video width={} controls src=\"data:video/x-m4v;base64,{}\">'.format(width, video_encoded)\n",
    "    else:\n",
    "        video_tag = '<video controls src=\"data:video/x-m4v;base64,{}\">'.format(video_encoded)\n",
    "    return HTML(video_tag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "showVideo('/Users/kevin/Desktop/movie/tumblr_m9gt19YFor1qzd8l1.mp4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-1-8c90e8f3d47b>, line 302)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-8c90e8f3d47b>\"\u001b[0;36m, line \u001b[0;32m302\u001b[0m\n\u001b[0;31m    return\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "\n",
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "import matplotlib\n",
    "if matplotlib.get_backend() == 'module://ipykernel.pylab.backend_inline':\n",
    "    matplotlib.use('nbAgg')\n",
    "\n",
    "# Monkeypatch backend to include \"pause\" button and fire the pause_event.\n",
    "from matplotlib.backends.backend_nbagg import NavigationIPy  # noqa: E402\n",
    "NavigationIPy.toolitems += [('Pause', 'Pause/Resume video',\n",
    "                             'fa fa-pause icon-pause', 'pause')]\n",
    "NavigationIPy.pause = lambda self: self.canvas.callbacks.process('pause_event')\n",
    "\n",
    "import matplotlib.pyplot as plt  # noqa: E402\n",
    "import matplotlib.animation as animation  # noqa: E402\n",
    "import matplotlib.image as image  # noqa: E402\n",
    "\n",
    "\n",
    "class cvloop(animation.TimedAnimation):\n",
    "    \"\"\"Uses a TimedAnimation to efficiently render video sources with blit.\"\"\"\n",
    "\n",
    "    def __init__(self, source=None, function=lambda x: x, side_by_side=False,\n",
    "                 convert_color=cv2.COLOR_BGR2RGB, cmaps=None,\n",
    "                 print_info=False):\n",
    "        \"\"\"Runs a video loop for the specified source and modifies the stream\n",
    "        with the function.\n",
    "\n",
    "        The source can either be an integer for a webcam device, a string to\n",
    "        load a video file or a VideoCapture object. In the last case, the\n",
    "        capture object will not be released by this function.\n",
    "\n",
    "        The function takes in a frame and returns the modified frame. The\n",
    "        default value just passes the value through, it is equivalent to the\n",
    "        identity function.\n",
    "\n",
    "        If side_by_side is True, the input as well as the modified image are\n",
    "        shown side by side, otherwise only the output is shown.\n",
    "\n",
    "        If convert_color can be any value for cv2.cvtColor, e.g.\n",
    "        cv2.COLOR_BGR2RGB.  If it is -1, no color conversion is performed,\n",
    "        otherwise a color conversion using cv2.cvtColor is performed before the\n",
    "        image is passed to the function.\n",
    "\n",
    "        Args:\n",
    "            source:        The video source; ints for webcams/devices, a string\n",
    "                           to load a video file. To fine tune a video source,\n",
    "                           it is possible to pass a VideoCapture object\n",
    "                           directly.\n",
    "                           (Default: 0)\n",
    "            function:      The modification function.\n",
    "                           (Default: identity function `lambda x: x`)\n",
    "            side_by_side:  If True, both images are shown, the original and the\n",
    "                           modified image.\n",
    "                           (Default: False)\n",
    "            convert_color: Converts the image with the given value using\n",
    "                           `cv2.cvtColor`, unless value is -1.\n",
    "                           (Default: `cv2.COLOR_BGR2RGB`)\n",
    "            cmaps:         If None, the plot function makes guesses about what\n",
    "                           color maps to use (if at all). If a single value,\n",
    "                           that color map is used for all plots\n",
    "                           (e.g. cmaps='gray').\n",
    "                           If cmaps is a tuple, the first value is used on the\n",
    "                           original image, the second value for the modified\n",
    "                           image. If cmaps is a tuple, None-entries are ignored\n",
    "                           and result in the normal guessing.\n",
    "            print_info:    If True, prints some info about the resource:\n",
    "                           dimensions, color channels, data type. Skips the\n",
    "                           output of one frame.\n",
    "        \"\"\"\n",
    "        if source is not None:\n",
    "            if isinstance(source, type(cv2.VideoCapture())) \\\n",
    "                    or hasattr(source, 'read'):\n",
    "                self.capture = source\n",
    "            else:\n",
    "                self.capture = cv2.VideoCapture(source)\n",
    "        else:\n",
    "            self.capture = cv2.VideoCapture(0)\n",
    "\n",
    "        self.figure = plt.figure()\n",
    "        self.connect_event_handlers()\n",
    "\n",
    "        self.function = function\n",
    "        self.convert_color = convert_color\n",
    "\n",
    "        self.original = None\n",
    "        self.processed = None\n",
    "\n",
    "        self.frame_offset = 0\n",
    "\n",
    "        try:\n",
    "            self.cmap_original = cmaps if isinstance(cmaps, str) else cmaps[0]\n",
    "        except (IndexError, TypeError):\n",
    "            self.cmap_original = None\n",
    "        try:\n",
    "            self.cmap_processed = cmaps if isinstance(cmaps, str) else cmaps[1]\n",
    "        except (IndexError, TypeError):\n",
    "            self.cmap_processed = None\n",
    "\n",
    "        if side_by_side:\n",
    "            axes_original = self.figure.add_subplot(1, 2, 1)\n",
    "            axes_processed = self.figure.add_subplot(1, 2, 2)\n",
    "        else:\n",
    "            axes_original = None\n",
    "            axes_processed = self.figure.add_subplot(1, 1, 1)\n",
    "\n",
    "        if print_info:\n",
    "            self.print_info(self.capture)\n",
    "\n",
    "        self.size = self.determine_size(self.capture)\n",
    "        self.original = self.__prepare_axes(axes_original, 'Original',\n",
    "                                            self.size, self.cmap_original)\n",
    "        self.processed = self.__prepare_axes(axes_processed, 'Processed',\n",
    "                                             self.size, self.cmap_processed)\n",
    "\n",
    "        self.update_info()\n",
    "\n",
    "        animation.TimedAnimation.__init__(self.figure, interval=50, blit=True)\n",
    "        plt.show()\n",
    "\n",
    "    def connect_event_handlers(self):\n",
    "        \"\"\"Connects event handlers to the figure.\"\"\"\n",
    "        self.figure.canvas.mpl_connect('close_event', self.evt_release)\n",
    "        self.figure.canvas.mpl_connect('pause_event', self.evt_toggle_pause)\n",
    "\n",
    "    def evt_release(self, *args):\n",
    "        \"\"\"Tries to release the capture.\"\"\"\n",
    "        try:\n",
    "            self.capture.release()\n",
    "        except AttributeError:\n",
    "            pass\n",
    "\n",
    "    def evt_toggle_pause(self, *args):\n",
    "        \"\"\"Pauses and resumes the video source.\"\"\"\n",
    "        if self.event_source._timer is None:\n",
    "            self.event_source.start()\n",
    "        else:\n",
    "            self.event_source.stop()\n",
    "\n",
    "    def print_info(self, capture):\n",
    "        \"\"\"Prints information about the unprocessed image.\n",
    "\n",
    "        Reads one frame from the source to determine image colors, dimensions\n",
    "        and data types.\n",
    "\n",
    "        Args:\n",
    "            capture: the source to read from.\n",
    "        \"\"\"\n",
    "        self.frame_offset += 1\n",
    "        ret, frame = capture.read()\n",
    "        if ret:\n",
    "            print('Capture Information')\n",
    "            print('\\tDimensions (HxW): {}x{}'.format(*frame.shape[0:2]))\n",
    "            print('\\tColor channels:   {}'.format(frame.shape[2] if\n",
    "                                                  len(frame.shape) > 2 else 1))\n",
    "            print('\\tColor range:      {}-{}'.format(np.min(frame),\n",
    "                                                     np.max(frame)))\n",
    "            print('\\tdtype:            {}'.format(frame.dtype))\n",
    "        else:\n",
    "            print('No source found.')\n",
    "\n",
    "    def determine_size(self, capture):\n",
    "        \"\"\"Determines the height and width of the image source.\n",
    "\n",
    "        If no dimensions are available, this method defaults to a resolution of\n",
    "        640x480, thus returns (480, 640).\n",
    "        If capture has a get method it is assumed to understand\n",
    "        `cv2.CAP_PROP_FRAME_WIDTH` and `cv2.CAP_PROP_FRAME_HEIGHT` to get the\n",
    "        information. Otherwise it reads one frame from the source to determine\n",
    "        image dimensions.\n",
    "\n",
    "        Args:\n",
    "            capture: the source to read from.\n",
    "\n",
    "        Returns:\n",
    "            A tuple containing integers of height and width (simple casts).\n",
    "        \"\"\"\n",
    "        width = 640\n",
    "        height = 480\n",
    "        if capture and hasattr(capture, 'get'):\n",
    "            width = capture.get(cv2.CAP_PROP_FRAME_WIDTH)\n",
    "            height = capture.get(cv2.CAP_PROP_FRAME_HEIGHT)\n",
    "        else:\n",
    "            self.frame_offset += 1\n",
    "            ret, frame = capture.read()\n",
    "            if ret:\n",
    "                width = frame.shape[1]\n",
    "                height = frame.shape[0]\n",
    "        return (int(height), int(width))\n",
    "\n",
    "    def __prepare_axes(self, axes, title, size, cmap=None):\n",
    "        \"\"\"Prepares an axes object for clean plotting.\n",
    "\n",
    "        Removes x and y axes labels and ticks, sets the aspect ratio to be\n",
    "        equal, uses the size to determine the drawing area and fills the image\n",
    "        with random colors as visual feedback.\n",
    "\n",
    "        Creates an AxesImage to be shown inside the axes object and sets the\n",
    "        needed properties.\n",
    "\n",
    "        Args:\n",
    "            axes:  The axes object to modify.\n",
    "            title: The title.\n",
    "            size:  The size of the expected image.\n",
    "            cmap:  The colormap if a custom color map is needed.\n",
    "                   (Default: None)\n",
    "        Returns:\n",
    "            The AxesImage's handle.\n",
    "        \"\"\"\n",
    "        if axes is None:\n",
    "            return None\n",
    "\n",
    "        # prepare axis itself\n",
    "        axes.set_xlim([0, size[1]])\n",
    "        axes.set_ylim([size[0], 0])\n",
    "        axes.set_aspect('equal')\n",
    "\n",
    "        axes.axis('off')\n",
    "        if isinstance(cmap, str):\n",
    "            title = '{} (cmap: {})'.format(title, cmap)\n",
    "        axes.set_title(title)\n",
    "\n",
    "        # prepare image data\n",
    "        axes_image = image.AxesImage(axes, cmap=cmap)\n",
    "        axes_image.set_data(np.random.random((size[0], size[1], 3)))\n",
    "\n",
    "        axes.add_image(axes_image)\n",
    "        return axes_image\n",
    "\n",
    "    def new_frame_seq(self):\n",
    "        \"\"\"Returns an endless frame counter.\n",
    "\n",
    "        Starts at self.frame_offset, in case some methods had to read frames\n",
    "        beforehand to gather information.\n",
    "\n",
    "        This function is called by TimedAnimation.\n",
    "\n",
    "        Returns:\n",
    "            an endless frame count\n",
    "        \"\"\"\n",
    "        return itertools.count(self.frame_offset)\n",
    "\n",
    "    def _init_draw(self):\n",
    "        \"\"\"Initializes the drawing of the frames by setting the images to\n",
    "        random colors.\n",
    "\n",
    "        This function is called by TimedAnimation.\n",
    "        \"\"\"\n",
    "        if self.original is not None:\n",
    "            self.original.set_data(np.random.random((10, 10, 3)))\n",
    "        self.processed.set_data(np.random.random((10, 10, 3)))\n",
    "\n",
    "    def read_frame(self):\n",
    "        \"\"\"Reads a frame and converts the color if needed.\n",
    "\n",
    "        In case no frame is available, i.e. self.capture.read() returns False\n",
    "        as the first return value, the event_source of the TimedAnimation is\n",
    "        stopped, and if possible the capture source released.\n",
    "\n",
    "        Returns:\n",
    "            None if stopped, otherwise the color converted source image.\n",
    "        \"\"\"\n",
    "        ret, frame = self.capture.read()\n",
    "        if not ret:\n",
    "            self.event_source.stop()\n",
    "            try:\n",
    "                self.capture.release()\n",
    "            except AttributeError:\n",
    "                # has no release method, thus just pass\n",
    "                pass\n",
    "            return None\n",
    "        if self.convert_color != -1 and self.is_color_image(frame):\n",
    "            return cv2.cvtColor(frame, self.convert_color)\n",
    "        return frame\n",
    "\n",
    "    def process_frame(self, frame):\n",
    "        \"\"\"Processes a frame with the user specified function.\n",
    "\n",
    "        Args:\n",
    "            frame: The input frame.\n",
    "        Returns:\n",
    "            The processed frame.\n",
    "        \"\"\"\n",
    "        return self.function(frame)\n",
    "\n",
    "    def _draw_frame(self, frame_no):\n",
    "        \"\"\"Reads, processes and draws the frames.\n",
    "\n",
    "        If needed for color maps, conversions to gray scale are performed. In\n",
    "        case the images are no color images and no custom color maps are\n",
    "        defined, the colormap `gray` is applied.\n",
    "\n",
    "        This function is called by TimedAnimation.\n",
    "\n",
    "        Args:\n",
    "            frame_no: The frame number.\n",
    "        \"\"\"\n",
    "        original = self.read_frame()\n",
    "#         if original is None:\n",
    "#             self.update_info(self.info_string(message='Finished.',\n",
    "#                                               frame=frame_no))\n",
    "        return\n",
    "\n",
    "        if self.original is not None:\n",
    "            processed = self.process_frame(original.copy())\n",
    "\n",
    "            if self.cmap_original is not None:\n",
    "                original = self.to_gray(original)\n",
    "            elif not self.is_color_image(original):\n",
    "                self.original.set_cmap('gray')\n",
    "            self.original.set_data(original)\n",
    "        else:\n",
    "            processed = self.process_frame(original)\n",
    "\n",
    "        if self.cmap_processed is not None:\n",
    "            processed = self.to_gray(processed)\n",
    "        elif not self.is_color_image(processed):\n",
    "            self.processed.set_cmap('gray')\n",
    "        self.processed.set_data(processed)\n",
    "\n",
    "#         self.update_info(self.info_string(frame=frame_no))\n",
    "\n",
    "    def is_color_image(self, frame):\n",
    "        \"\"\"Checks if an image is a color image.\n",
    "\n",
    "        A color image is an image with at least three dimensions and in the\n",
    "        third dimension at least three color channels.\n",
    "\n",
    "        Returns:\n",
    "            True if the image is a color image.\n",
    "        \"\"\"\n",
    "        return len(frame.shape) >= 3 and frame.shape[2] >= 3\n",
    "\n",
    "    def to_gray(self, frame):\n",
    "        \"\"\"If the input is a color image, it is converted to gray scale.\n",
    "\n",
    "        The first color channel is considered as R, the second as G, and\n",
    "        the last as B. The gray scale image is then the weighted sum:\n",
    "\n",
    "            gray = .299 R + .587 G + .114 B\n",
    "\n",
    "        Returns:\n",
    "            Either the converted image (if it was a color image) or the\n",
    "            original.\n",
    "        \"\"\"\n",
    "        if not self.is_color_image(frame):\n",
    "            return frame\n",
    "        return np.dot(frame[..., :3], [.299, .587, .114])\n",
    "\n",
    "#     def update_info(self, custom=None):\n",
    "#         \"\"\"Updates the figure's suptitle.\n",
    "\n",
    "#         Calls self.info_string() unless custom is provided.\n",
    "\n",
    "#         Args:\n",
    "#             custom: Overwrite it with this string, unless None.\n",
    "#         \"\"\"\n",
    "#         self.figure.suptitle(self.info_string() if custom is None else custom)\n",
    "# \n",
    "#     def info_string(self, size=None, message='', frame=-1):\n",
    "#         \"\"\"Returns information about the stream.\n",
    "\n",
    "#         Generates a string containing size, frame number, and info messages.\n",
    "#         Omits unnecessary information (e.g. empty messages and frame -1).\n",
    "\n",
    "#         This method is primarily used to update the suptitle of the plot\n",
    "#         figure.\n",
    "\n",
    "#         Returns:\n",
    "#             An info string.\n",
    "#         \"\"\"\n",
    "#         info = []\n",
    "#         if size is not None:\n",
    "#             info.append('Size: {1}x{0}'.format(*size))\n",
    "#         elif self.size is not None:\n",
    "#             info.append('Size: {1}x{0}'.format(*self.size))\n",
    "#         if frame >= 0:\n",
    "#             info.append('Frame: {}'.format(frame))\n",
    "#         if message != '':\n",
    "#             info.append('{}'.format(message))\n",
    "#         return ' '.join(info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cvloop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}