Step2 - Uploading and reading video files on Mongodb.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "import matplotlib\n",
    "from matplotlib import pylab, mlab, pyplot\n",
    "np = numpy\n",
    "plt = pyplot\n",
    "from matplotlib.pyplot import *\n",
    "import os\n",
    "import glob\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=FutureWarning)\n",
    "\n",
    "from IPython.display import display\n",
    "from IPython.core.pylabtools import figsize, getfigs\n",
    "\n",
    "from pylab import *\n",
    "from numpy import *\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "from ipywidgets.widgets import interact, interactive, fixed\n",
    "from ipywidgets import widgets\n",
    "from scipy import fftpack\n",
    "from IPython.display import display\n",
    "from PIL import Image\n",
    "import pims\n",
    "import scipy.optimize as optimization\n",
    "import pandas as pd\n",
    "import pymongo\n",
    "import gridfs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example video upload to MongoDB gridfs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# connect to the database\n",
    "conn=pymongo.MongoClient()\n",
    "grid_fs = gridfs.GridFS(conn.microrheology)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The database is initally empty so we upload "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#the example data file is a video of brownian motion of 400nm tracers in water acquired with a phantom camera (.cin) \n",
    "#the video and additional metadata can be stored in the same mongodb gridfs object\n",
    "\n",
    "\n",
    "filename_orig='400nm_100dil_water_01umpix_100fps_short.cin' #filename in the filesystem\n",
    "interval=0.01 #time between frames in seconds        \n",
    "filename_indb=filename_orig # filename in the database\n",
    "\n",
    "operator='Marco'\n",
    "calibration=0.1 #mu per pixel\n",
    "tracer_radius=2E-4 #tracer radius in meter\n",
    "temperature=25 #Celsius\n",
    "\n",
    "info={'interval':interval,\n",
    "      'filename' : filename_orig,\n",
    "      'muperpix':0.1,\n",
    "      'tracer_radius': tracer_radius,\n",
    "      'temperature': 25,\n",
    "      'operator':'Marco'\n",
    "     }\n",
    "\n",
    "#Opening and Storing the .cin file to the Database and appending the info dictionary to it\n",
    "with open('400nm_100dil_water_01umpix_100fps_short.cin','rb') as file:\n",
    "    grid_fs.put(file,filename=filename_indb,info=info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['400nm_100dil_water_01umpix_100fps_short.cin']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#List files present in the database\n",
    "grid_fs.list()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "video=grid_fs.get_last_version('400nm_100dil_water_01umpix_100fps_short.cin')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'interval': 0.01,\n",
       " 'filename': '400nm_100dil_water_01umpix_100fps_short.cin',\n",
       " 'muperpix': 0.1,\n",
       " 'tracer_radius': 0.0002,\n",
       " 'temperature': 25,\n",
       " 'operator': 'Marco'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "video.info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in case you want to delete the file from the DB\n",
    "# remember if you upload multiple files with the same filename it will handle them as multiple versions\n",
    "# grid_fs.delete(grid_fs.get_last_version('400nm_100dil_water_01umpix_100fps_short.cin')._id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Example query video and access frame by frame from MongoDB gridfs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The video object returned by pymongo is a gridfs.grid_file.GridOut and is a filelike object so with a small modification to the cine function can be passed instead of the filename\n",
    "\n",
    "    def __init__(self, filename, process_func=None,\n",
    "                 dtype=None, as_grey=False):\n",
    "\n",
    "        if type(video)==gridfs.grid_file.GridOut:\n",
    "            self.f=filename\n",
    "        else:\n",
    "            self.f = open(filename, 'rb')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "###############################################################################\n",
    "\n",
    "# Reader for CINE files produced by Vision Research Phantom Software\n",
    "# Author: Dustin Kleckner\n",
    "# dkleckner@uchicago.edu\n",
    "\n",
    "# Modified by Marco Caggioni (marco.caggioni@gmail.com)\n",
    "# Modified by Thomas A Caswell (tcaswell@uchicago.edu)\n",
    "# Added to PIMS by Thomas A Caswell (tcaswell@gmail.com)\n",
    "###############################################################################\n",
    "from __future__ import (absolute_import, division, print_function,\n",
    "                        unicode_literals)\n",
    "\n",
    "import six\n",
    "\n",
    "from pims.frame import Frame\n",
    "from pims.base_frames import FramesSequence\n",
    "import time\n",
    "import struct\n",
    "import numpy as np\n",
    "from numpy import array, frombuffer\n",
    "from threading import Lock\n",
    "import datetime\n",
    "import hashlib\n",
    "\n",
    "__all__ = ('Cine', )\n",
    "\n",
    "\n",
    "FRACTION_MASK = (2**32-1)\n",
    "MAX_INT = 2**32\n",
    "\n",
    "BYTE = 'B'\n",
    "WORD = 'H'\n",
    "INT16 = 'h'\n",
    "SHORT = 'h'\n",
    "BOOL = 'i'\n",
    "DWORD = 'I'\n",
    "UINT = 'I'\n",
    "LONG = 'l'\n",
    "INT = 'l'\n",
    "FLOAT = 'f'\n",
    "DOUBLE = 'd'\n",
    "TIME64 = 'Q'\n",
    "RECT = '4i'\n",
    "WBGAIN = '2f'\n",
    "IMFILTER = '28i'\n",
    "\n",
    "CFA_NONE = 0\n",
    "CFA_VRI = 1\n",
    "CFA_VRIV6 = 2\n",
    "CFA_BAYER = 3\n",
    "CFA_BAYERFLIP = 4\n",
    "\n",
    "TAGGED_FIELDS = {\n",
    "    1000: ('ang_dig_sigs', ''),\n",
    "    1001: ('image_time_total', TIME64),\n",
    "    1002: ('image_time_only', TIME64),\n",
    "    1003: ('exposure_only', DWORD),\n",
    "    1004: ('range_data', ''),\n",
    "    1005: ('binsig', ''),\n",
    "    1006: ('anasig', ''),\n",
    "    # 1007 exists in my files, but is not in documentation I can find\n",
    "    1007: ('undocumented', '')}\n",
    "\n",
    "HEADER_FIELDS = [\n",
    "    ('type', '2s'),\n",
    "    ('header_size', WORD),\n",
    "    ('compression', WORD),\n",
    "    ('version', WORD),\n",
    "    ('first_movie_image', LONG),\n",
    "    ('total_image_count', DWORD),\n",
    "    ('first_image_no', LONG),\n",
    "    ('image_count', DWORD),\n",
    "    ('off_image_header', DWORD),\n",
    "    ('off_setup', DWORD),\n",
    "    ('off_image_offsets', DWORD),\n",
    "    ('trigger_time', TIME64),\n",
    "]\n",
    "\n",
    "BITMAP_INFO_FIELDS = [\n",
    "    ('bi_size', DWORD),\n",
    "    ('bi_width', LONG),\n",
    "    ('bi_height', LONG),\n",
    "    ('bi_planes', WORD),\n",
    "    ('bi_bit_count', WORD),\n",
    "    ('bi_compression', DWORD),\n",
    "    ('bi_image_size', DWORD),\n",
    "    ('bi_x_pels_per_meter', LONG),\n",
    "    ('bi_y_pels_per_meter', LONG),\n",
    "    ('bi_clr_used', DWORD),\n",
    "    ('bi_clr_important', DWORD),\n",
    "]\n",
    "\n",
    "SETUP_FIELDS = [\n",
    "    ('frame_rate_16', WORD),\n",
    "    ('shutter_16', WORD),\n",
    "    ('post_trigger_16', WORD),\n",
    "    ('frame_delay_16', WORD),\n",
    "    ('aspect_ratio', WORD),\n",
    "    ('contrast_16', WORD),\n",
    "    ('bright_16', WORD),\n",
    "    ('rotate_16', BYTE),\n",
    "    ('time_annotation', BYTE),\n",
    "    ('trig_cine', BYTE),\n",
    "    ('trig_frame', BYTE),\n",
    "    ('shutter_on', BYTE),\n",
    "    # Guessed at length... because it isn't documented!  This seems to work.\n",
    "    ('description_old', '121s'),\n",
    "    ('mark', '2s'),\n",
    "    ('length', WORD),\n",
    "    ('binning', WORD),\n",
    "    ('sig_option', WORD),\n",
    "    ('bin_channels', SHORT),\n",
    "    ('samples_per_image', BYTE)] + \\\n",
    "    [('bin_name%d' % i, '11s') for i in range(8)] + [\n",
    "        ('ana_option', WORD),\n",
    "        ('ana_channels', SHORT),\n",
    "        ('res_6', BYTE),\n",
    "        ('ana_board', BYTE)] + \\\n",
    "    [('ch_option%d' % i, SHORT) for i in range(8)] + \\\n",
    "    [('ana_gain%d' % i, FLOAT) for i in range(8)] + \\\n",
    "    [('ana_unit%d' % i, '6s') for i in range(8)] + \\\n",
    "    [('ana_name%d' % i, '11s') for i in range(8)] + [\n",
    "    ('i_first_image', LONG),\n",
    "    ('dw_image_count', DWORD),\n",
    "    ('n_q_factor', SHORT),\n",
    "    ('w_cine_file_type', WORD)] + \\\n",
    "    [('sz_cine_path%d' % i, '65s') for i in range(4)] + [\n",
    "    ('b_mains_freq', WORD),\n",
    "    ('b_time_code', BYTE),\n",
    "    ('b_priority', BYTE),\n",
    "    ('w_leap_sec_dy', DOUBLE),\n",
    "    ('d_delay_tc', DOUBLE),\n",
    "    ('d_delay_pps', DOUBLE),\n",
    "    ('gen_bits', WORD),\n",
    "    ('res_1', INT16),  # Manual says INT, but this is clearly wrong!\n",
    "    ('res_2', INT16),\n",
    "    ('res_3', INT16),\n",
    "    ('im_width', WORD),\n",
    "    ('im_height', WORD),\n",
    "    ('edr_shutter_16', WORD),\n",
    "    ('serial', UINT),\n",
    "    ('saturation', INT),\n",
    "    ('res_5', BYTE),\n",
    "    ('auto_exposure', UINT),\n",
    "    ('b_flip_h', BOOL),\n",
    "    ('b_flip_v', BOOL),\n",
    "    ('grid', UINT),\n",
    "    ('frame_rate', UINT),\n",
    "    ('shutter', UINT),\n",
    "    ('edr_shutter', UINT),\n",
    "    ('post_trigger', UINT),\n",
    "    ('frame_delay', UINT),\n",
    "    ('b_enable_color', BOOL),\n",
    "    ('camera_version', UINT),\n",
    "    ('firmware_version', UINT),\n",
    "    ('software_version', UINT),\n",
    "    ('recording_time_zone', INT),\n",
    "    ('cfa', UINT),\n",
    "    ('bright', INT),\n",
    "    ('contrast', INT),\n",
    "    ('gamma', INT),\n",
    "    ('reserved1', UINT),\n",
    "    ('auto_exp_level', UINT),\n",
    "    ('auto_exp_speed', UINT),\n",
    "    ('auto_exp_rect', RECT),\n",
    "    ('wb_gain', '8f'),\n",
    "    ('rotate', INT),\n",
    "    ('wb_view', WBGAIN),\n",
    "    ('real_bpp', UINT),\n",
    "    ('conv_8_min', UINT),\n",
    "    ('conv_8_max', UINT),\n",
    "    ('filter_code', INT),\n",
    "    ('filter_param', INT),\n",
    "    ('uf', IMFILTER),\n",
    "    ('black_cal_sver', UINT),\n",
    "    ('white_cal_sver', UINT),\n",
    "    ('gray_cal_sver', UINT),\n",
    "    ('b_stamp_time', BOOL),\n",
    "    ('sound_dest', UINT),\n",
    "    ('frp_steps', UINT),\n",
    "    ] + [('frp_img_nr%d' % i, INT) for i in range(16)] + \\\n",
    "        [('frp_rate%d' % i, UINT) for i in range(16)] + \\\n",
    "        [('frp_exp%d' % i, UINT) for i in range(16)] + [\n",
    "    ('mc_cnt', INT),\n",
    "    ] + [('mc_percent%d' % i, FLOAT) for i in range(64)] + [\n",
    "    ('ci_calib', UINT),\n",
    "    ('calib_width', UINT),\n",
    "    ('calib_height', UINT),\n",
    "    ('calib_rate', UINT),\n",
    "    ('calib_exp', UINT),\n",
    "    ('calib_edr', UINT),\n",
    "    ('calib_temp', UINT),\n",
    "    ] + [('header_serial%d' % i, UINT) for i in range(4)] + [\n",
    "    ('range_code', UINT),\n",
    "    ('range_size', UINT),\n",
    "    ('decimation', UINT),\n",
    "    ('master_serial', UINT),\n",
    "    ('sensor', UINT),\n",
    "    ('shutter_ns', UINT),\n",
    "    ('edr_shutter_ns', UINT),\n",
    "    ('frame_delay_ns', UINT),\n",
    "    ('im_pos_xacq', UINT),\n",
    "    ('im_pos_yacq', UINT),\n",
    "    ('im_width_acq', UINT),\n",
    "    ('im_height_acq', UINT),\n",
    "    ('description', '4096s')\n",
    "]\n",
    "\n",
    "\n",
    "class Cine(FramesSequence):\n",
    "    \"\"\"Read cine files\n",
    "\n",
    "    Read cine files, the out put from Vision Research high-speed phantom\n",
    "    cameras.  Support uncompressed monochrome and color files.\n",
    "\n",
    "    Nominally thread-safe, but this assertion is not tested.\n",
    "\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    filename : string\n",
    "        Path to cine file.\n",
    "    process_func : function, optional\n",
    "        callable with signalture `proc_img = process_func(img)`,\n",
    "        which will be applied to the data from each frame\n",
    "    dtype : numpy datatype, optional\n",
    "        Image arrays will be converted to this datatype.\n",
    "    as_grey : boolean, optional\n",
    "        Convert color images to greyscale. False by default.\n",
    "        May not be used in conjection with process_func.\n",
    "    \"\"\"\n",
    "    @classmethod\n",
    "    def class_exts(cls):\n",
    "        return {'cine'} | super(Cine,\n",
    "                                cls).class_exts()\n",
    "\n",
    "    def __init__(self, filename, process_func=None,\n",
    "                 dtype=None, as_grey=False):\n",
    "        \n",
    "        if type(video)==gridfs.grid_file.GridOut:\n",
    "            self.f=filename\n",
    "        else:\n",
    "            self.f = open(filename, 'rb')\n",
    "        \n",
    "        self._filename = filename\n",
    "\n",
    "        self.header_dict = self.read_header(HEADER_FIELDS)\n",
    "        self.bitmapinfo_dict = self.read_header(BITMAP_INFO_FIELDS,\n",
    "                                                self.off_image_header)\n",
    "        self.setup_fields_dict = self.read_header(SETUP_FIELDS, self.off_setup)\n",
    "        self.image_locations = self.unpack('%dQ' % self.image_count,\n",
    "                                           self.off_image_offsets)\n",
    "        if type(self.image_locations) not in (list, tuple):\n",
    "            self.image_locations = [self.image_locations]\n",
    "\n",
    "        self._width = self.bitmapinfo_dict['bi_width']\n",
    "        self._height = self.bitmapinfo_dict['bi_height']\n",
    "        self._pixel_count = self._width * self._height\n",
    "\n",
    "        # Allows Cine object to be accessed from multiple threads!\n",
    "        self.file_lock = Lock()\n",
    "\n",
    "        self._hash = None\n",
    "\n",
    "        # validate gray/process func\n",
    "        self._validate_process_func(process_func)\n",
    "        self._as_grey(as_grey, process_func)\n",
    "\n",
    "        self._im_sz = (self._width, self._height)\n",
    "\n",
    "        # sort out the data type by reading the meta-data\n",
    "        if self.bitmapinfo_dict['bi_bit_count'] in (8, 24):\n",
    "            self._data_type = 'u1'\n",
    "        else:\n",
    "            self._data_type = 'u2'\n",
    "\n",
    "        # sort out what type to return data as\n",
    "        if dtype is None:\n",
    "            self._dtype = np.dtype(self._data_type)\n",
    "        else:\n",
    "            self._dtype = dtype\n",
    "        self.tagged_blocks = self.read_tagged_blocks()\n",
    "        self.frame_time_stamps = self.tagged_blocks['image_time_only']\n",
    "        self.all_exposures = self.tagged_blocks['exposure_only']\n",
    "        self.stack_meta_data = dict()\n",
    "        self.stack_meta_data.update(self.bitmapinfo_dict)\n",
    "        self.stack_meta_data.update({k: self.setup_fields_dict[k]\n",
    "                                     for k in set(('trig_frame',\n",
    "                                                   'gamma',\n",
    "                                                   'frame_rate',\n",
    "                                                   'shutter_ns'\n",
    "                                                   )\n",
    "                                                   )\n",
    "                                                   })\n",
    "        self.stack_meta_data.update({k: self.header_dict[k]\n",
    "                                     for k in set(('first_image_no',\n",
    "                                                   'image_count',\n",
    "                                                   'total_image_count',\n",
    "                                                   'first_movie_image'\n",
    "                                                   )\n",
    "                                                   )\n",
    "                                                   })\n",
    "        self.stack_meta_data['trigger_time'] = self.trigger_time\n",
    "\n",
    "    @property\n",
    "    def filename(self):\n",
    "        return self._filename\n",
    "\n",
    "    @property\n",
    "    def frame_rate(self):\n",
    "        return self.setup_fields_dict['frame_rate']\n",
    "\n",
    "    # use properties for things that should not be changeable\n",
    "    @property\n",
    "    def cfa(self):\n",
    "        return self.setup_fields_dict['cfa']\n",
    "\n",
    "    @property\n",
    "    def compression(self):\n",
    "        return self.header_dict['compression']\n",
    "\n",
    "    @property\n",
    "    def pixel_type(self):\n",
    "        return self._dtype\n",
    "\n",
    "    @property\n",
    "    def off_set(self):\n",
    "        return self.header_dict['offset']\n",
    "\n",
    "    @property\n",
    "    def setup_length(self):\n",
    "        return self.setup_fields_dict['length']\n",
    "\n",
    "    @property\n",
    "    def off_image_offsets(self):\n",
    "        return self.header_dict['off_image_offsets']\n",
    "\n",
    "    @property\n",
    "    def off_image_header(self):\n",
    "        return self.header_dict['off_image_header']\n",
    "\n",
    "    @property\n",
    "    def off_setup(self):\n",
    "        return self.header_dict['off_setup']\n",
    "\n",
    "    @property\n",
    "    def image_count(self):\n",
    "        return self.header_dict['image_count']\n",
    "\n",
    "    @property\n",
    "    def frame_shape(self):\n",
    "        return self._im_sz\n",
    "\n",
    "    def get_frame(self, j):\n",
    "        md = dict()\n",
    "        md['exposure'] = self.all_exposures[j]\n",
    "        ts, sec_frac = self.frame_time_stamps[j]\n",
    "        md['frame_time'] = {'datetime': ts,\n",
    "                            'second_fraction': sec_frac}\n",
    "        return Frame(self.process_func(self._get_frame(j)),\n",
    "                     frame_no=j, metadata=md)\n",
    "\n",
    "    def unpack(self, fs, offset=None):\n",
    "        if offset is not None:\n",
    "            self.f.seek(offset)\n",
    "        s = struct.Struct('<' + fs)\n",
    "        vals = s.unpack(self.f.read(s.size))\n",
    "        if len(vals) == 1:\n",
    "            return vals[0]\n",
    "        else:\n",
    "            return vals\n",
    "\n",
    "    def read_tagged_blocks(self):\n",
    "        '''\n",
    "        Reads the tagged block meta-data from the header\n",
    "        '''\n",
    "        tmp_dict = dict()\n",
    "        if not self.off_setup + self.setup_length < self.off_image_offsets:\n",
    "            return\n",
    "        next_tag_exists = True\n",
    "        next_tag_offset = 0\n",
    "        while next_tag_exists:\n",
    "            block_size, next_tag_exists = self._read_tag_block(next_tag_offset,\n",
    "                                                               tmp_dict)\n",
    "            next_tag_offset += block_size\n",
    "        return tmp_dict\n",
    "\n",
    "    def _read_tag_block(self, off_set, accum_dict):\n",
    "        '''\n",
    "        Internal helper-function for reading the tagged blocks.\n",
    "        '''\n",
    "        with FileLocker(self.file_lock):\n",
    "            self.f.seek(self.off_setup + self.setup_length + off_set)\n",
    "            block_size = self.unpack(DWORD)\n",
    "            b_type = self.unpack(WORD)\n",
    "            more_tags = self.unpack(WORD)\n",
    "\n",
    "            if b_type == 1004:\n",
    "                # docs say to ignore range data it seems to be a poison flag,\n",
    "                # if see this, give up tag parsing\n",
    "                return block_size, 0\n",
    "\n",
    "            try:\n",
    "                d_name, d_type = TAGGED_FIELDS[b_type]\n",
    "\n",
    "            except KeyError:\n",
    "                return block_size, more_tags\n",
    "\n",
    "            if d_type == '':\n",
    "                # print \"can't deal with  <\" + d_name + \"> tagged data\"\n",
    "                return block_size, more_tags\n",
    "\n",
    "            s_tmp = struct.Struct('<' + d_type)\n",
    "            if (block_size-8) % s_tmp.size != 0:\n",
    "                #            print 'something is wrong with your data types'\n",
    "                return block_size, more_tags\n",
    "\n",
    "            d_count = (block_size-8)//(s_tmp.size)\n",
    "\n",
    "            data = self.unpack('%d' % d_count + d_type)\n",
    "            if not isinstance(data, tuple):\n",
    "                # fix up data due to design choice in self.unpack\n",
    "                data = (data, )\n",
    "\n",
    "            # parse time\n",
    "            if b_type == 1002 or b_type == 1001:\n",
    "                data = [(datetime.datetime.fromtimestamp(d >> 32),\n",
    "                         (FRACTION_MASK & d)/MAX_INT) for d in data]\n",
    "            # convert exposure to seconds\n",
    "            if b_type == 1003:\n",
    "                data = [d/(MAX_INT) for d in data]\n",
    "\n",
    "            accum_dict[d_name] = data\n",
    "\n",
    "        return block_size, more_tags\n",
    "\n",
    "    def read_header(self, fields, offset=0):\n",
    "        self.f.seek(offset)\n",
    "        tmp = dict()\n",
    "        for name, format in fields:\n",
    "            val = self.unpack(format)\n",
    "            tmp[name] = val\n",
    "\n",
    "        return tmp\n",
    "\n",
    "    def _get_frame(self, number):\n",
    "        with FileLocker(self.file_lock):\n",
    "            # get basic information about the frame we want\n",
    "            image_start = self.image_locations[number]\n",
    "            annotation_size = self.unpack(DWORD, image_start)\n",
    "            # this is not used, but is needed to advance the point in the file\n",
    "            annotation = self.unpack('%db' % (annotation_size - 8))\n",
    "            image_size = self.unpack(DWORD)\n",
    "\n",
    "            cfa = self.cfa\n",
    "            compression = self.compression\n",
    "\n",
    "            # sort out data type looking at the cached version\n",
    "            data_type = self._data_type\n",
    "\n",
    "            # actual bit per pixel\n",
    "            actual_bits = image_size * 8 // (self._pixel_count)\n",
    "\n",
    "            # so this seem wrong as 10 or 12 bits won't fit in 'u1'\n",
    "            # but I (TAC) may not understand and don't have a packed file\n",
    "            # (which the docs seem to imply don't exist) to test on so\n",
    "            # I am leaving it.  good luck.\n",
    "            if actual_bits in (10, 12):\n",
    "                data_type = 'u1'\n",
    "\n",
    "            # move the file to the right point in the file\n",
    "            self.f.seek(image_start + annotation_size)\n",
    "\n",
    "            # suck the data out of the file and shove into linear\n",
    "            # numpy array\n",
    "            frame = frombuffer(self.f.read(image_size), data_type)\n",
    "\n",
    "            # if mono-camera\n",
    "            if cfa == CFA_NONE:\n",
    "                if compression != 0:\n",
    "                    raise ValueError(\"Can not deal with compressed files\\n\" +\n",
    "                                     \"compression level: \" +\n",
    "                                     \"{}\".format(compression))\n",
    "                # we are working with a monochrome camera\n",
    "                # un-pack packed data\n",
    "                if (actual_bits == 10):\n",
    "                    frame = _ten2sixteen(frame)\n",
    "                elif (actual_bits == 12):\n",
    "                    frame = _twelve2sixteen(frame)\n",
    "                elif (actual_bits % 8):\n",
    "                    raise ValueError('Data should be byte aligned, ' +\n",
    "                         'or 10 or 12 bit packed (appears to be' +\n",
    "                        ' %dbits/pixel?!)' % actual_bits)\n",
    "\n",
    "                # re-shape to an array\n",
    "                # flip the rows\n",
    "                # and the cast to proper type\n",
    "                frame = frame.reshape(self._height,\n",
    "                                      self._width)[::-1].astype(self._dtype)\n",
    "\n",
    "                if actual_bits in (10, 12):\n",
    "                    frame = frame[::-1, :]\n",
    "                    # Don't know why it works this way, but it does...\n",
    "            # else, some sort of color layout\n",
    "            else:\n",
    "                if compression == 0:\n",
    "                    # and re-order so color is RGB (naively saves as BGR)\n",
    "                    frame = frame.reshape(self._height,\n",
    "                                          self._width,\n",
    "                                          3)[::-1, :, ::-1].astype(self._dtype)\n",
    "                elif compression == 2:\n",
    "                    raise ValueError(\"Can not process un-interpolated movies\")\n",
    "                else:\n",
    "                    raise ValueError(\"Should never hit this, \" +\n",
    "                                     \"you have an un-documented file\\n\" +\n",
    "                                     \"compression level: \" +\n",
    "                                     \"{}\".format(compression))\n",
    "\n",
    "        return frame\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.image_count\n",
    "\n",
    "    len = __len__\n",
    "\n",
    "    def get_time(self, i):\n",
    "        '''Returm the time of frame i in seconds.'''\n",
    "        return float(i) / self.frame_rate\n",
    "\n",
    "    def get_fps(self):\n",
    "        return self.frame_rate\n",
    "\n",
    "    def close(self):\n",
    "        self.f.close()\n",
    "\n",
    "    def __unicode__(self):\n",
    "        return self.filename\n",
    "\n",
    "    def __str__(self):\n",
    "        return unicode(self).encode('utf-8')\n",
    "\n",
    "    def __repr__(self):\n",
    "        # May be overwritten by subclasses\n",
    "        return \"\"\"<Frames>\n",
    "Source: {filename}\n",
    "Length: {count} frames\n",
    "Frame Shape: {w} x {h}\n",
    "Pixel Datatype: {dtype}\"\"\".format(w=self.frame_shape[0],\n",
    "                                  h=self.frame_shape[1],\n",
    "                                  count=len(self),\n",
    "                                  filename=self.filename,\n",
    "                                  dtype=self.pixel_type)\n",
    "\n",
    "    @property\n",
    "    def trigger_time(self):\n",
    "        '''Returns the time of the trigger, tuple of (datatime_object,\n",
    "        fraction_in_ns)'''\n",
    "        trigger_time = self.header_dict['trigger_time']\n",
    "        ts, sf = (datetime.datetime.fromtimestamp(trigger_time >> 32),\n",
    "                   float(FRACTION_MASK & trigger_time)/(MAX_INT))\n",
    "\n",
    "        return {'datetime': ts, 'second_fraction': sf}\n",
    "\n",
    "    @property\n",
    "    def hash(self):\n",
    "        if self._hash is None:\n",
    "            self._hash_fun()\n",
    "        return self._hash\n",
    "\n",
    "    def __hash__(self):\n",
    "        return int(self.hash, base=16)\n",
    "\n",
    "    def _hash_fun(self):\n",
    "        \"\"\"\n",
    "        generates the md5 hash of the header of the file.  Here the\n",
    "        header is defined as everything before the first image starts.\n",
    "\n",
    "        This includes all of the meta-data (including the plethora of\n",
    "        time stamps) so this will be unique.\n",
    "        \"\"\"\n",
    "        # get the file lock (so we don't screw up any other reads)\n",
    "        with FileLocker(self.file_lock):\n",
    "\n",
    "            self.f.seek(0)\n",
    "            max_loc = self.image_locations[0]\n",
    "            md5 = hashlib.md5()\n",
    "\n",
    "            chunk_size = 128*md5.block_size\n",
    "            chunk_count = (max_loc//chunk_size) + 1\n",
    "\n",
    "            for j in range(chunk_count):\n",
    "                md5.update(self.f.read(128*md5.block_size))\n",
    "\n",
    "            self._hash = md5.hexdigest()\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return self.hash == other.hash\n",
    "\n",
    "    def __ne__(self, other):\n",
    "        return not self == other\n",
    "\n",
    "\n",
    "class FileLocker(object):\n",
    "    \"\"\"\n",
    "    A context manager to lock and un-lock a the cine file\n",
    "\n",
    "    See http://docs.python.org/2/library/contextlib.html\n",
    "    http://docs.python.org/2/library/stdtypes.html#typecontextmanager\n",
    "    http://docs.python.org/2/reference/datamodel.html#context-managers\n",
    "    \"\"\"\n",
    "    def __init__(self, lock):\n",
    "        self.lock = lock\n",
    "\n",
    "    def __enter__(self):\n",
    "        self.lock.acquire()\n",
    "\n",
    "    def __exit__(self, exc_type, exc_val, exc_tb):\n",
    "        self.lock.release()\n",
    "        return False\n",
    "\n",
    "\n",
    "# Should be divisible by 3, 4 and 5!  This seems to be near-optimal.\n",
    "CHUNK_SIZE = 6 * 10 ** 5\n",
    "\n",
    "\n",
    "def _ten2sixteen(a):\n",
    "    \"\"\"\n",
    "    Convert array of 10bit uints to array of 16bit uints\n",
    "    \"\"\"\n",
    "    b = np.zeros(a.size//5*4, dtype='u2')\n",
    "\n",
    "    for j in range(0, len(a), CHUNK_SIZE):\n",
    "        (a0, a1, a2, a3, a4) = [a[j+i:j+CHUNK_SIZE:5].astype('u2')\n",
    "                                for i in range(5)]\n",
    "\n",
    "        k = j//5 * 4\n",
    "        k2 = k + CHUNK_SIZE//5 * 4\n",
    "\n",
    "        b[k+0:k2:4] = ((a0 & 0b11111111) << 2) + ((a1 & 0b11000000) >> 6)\n",
    "        b[k+1:k2:4] = ((a1 & 0b00111111) << 4) + ((a2 & 0b11110000) >> 4)\n",
    "        b[k+2:k2:4] = ((a2 & 0b00001111) << 6) + ((a3 & 0b11111100) >> 2)\n",
    "        b[k+3:k2:4] = ((a3 & 0b00000011) << 8) + ((a4 & 0b11111111) >> 0)\n",
    "\n",
    "    return b\n",
    "\n",
    "\n",
    "def _sixteen2ten(b):\n",
    "    \"\"\"\n",
    "    Convert array of 16bit uints to array of 10bit uints\n",
    "    \"\"\"\n",
    "    a = np.zeros(b.size//4*5, dtype='u1')\n",
    "\n",
    "    for j in range(0, len(a), CHUNK_SIZE):\n",
    "        (b0, b1, b2, b3) = [b[j+i:j+CHUNK_SIZE:4] for i in range(4)]\n",
    "\n",
    "        k = j//4 * 5\n",
    "        k2 = k + CHUNK_SIZE//4 * 5\n",
    "\n",
    "        a[k+0:k2:5] =                              ((b0 & 0b1111111100) >> 2)\n",
    "        a[k+1:k2:5] = ((b0 & 0b0000000011) << 6) + ((b1 & 0b1111110000) >> 4)\n",
    "        a[k+2:k2:5] = ((b1 & 0b0000001111) << 4) + ((b2 & 0b1111000000) >> 6)\n",
    "        a[k+3:k2:5] = ((b2 & 0b0000111111) << 2) + ((b3 & 0b1100000000) >> 8)\n",
    "        a[k+4:k2:5] = ((b3 & 0b0011111111) << 0)\n",
    "\n",
    "    return a\n",
    "\n",
    "\n",
    "def _twelve2sixteen(a):\n",
    "    \"\"\"\n",
    "    Convert array of 12bit uints to array of 16bit uints\n",
    "    \"\"\"\n",
    "    b = np.zeros(a.size//3*2, dtype='u2')\n",
    "\n",
    "    for j in range(0, len(a), CHUNK_SIZE):\n",
    "        (a0, a1, a2) = [a[j+i:j+CHUNK_SIZE:3].astype('u2') for i in range(3)]\n",
    "\n",
    "        k = j//3 * 2\n",
    "        k2 = k + CHUNK_SIZE//3 * 2\n",
    "\n",
    "        b[k+0:k2:2] = ((a0 & 0xFF) << 4) + ((a1 & 0xF0) >> 4)\n",
    "        b[k+1:k2:2] = ((a1 & 0x0F) << 8) + ((a2 & 0xFF) >> 0)\n",
    "\n",
    "    return b\n",
    "\n",
    "\n",
    "def _sixteen2twelve(b):\n",
    "    \"\"\"\n",
    "    Convert array of 16bit uints to array of 12bit uints\n",
    "    \"\"\"\n",
    "    a = np.zeros(b.size//2*3, dtype='u1')\n",
    "\n",
    "    for j in range(0, len(a), CHUNK_SIZE):\n",
    "        (b0, b1) = [b[j+i:j+CHUNK_SIZE:2] for i in range(2)]\n",
    "\n",
    "        k = j//2 * 3\n",
    "        k2 = k + CHUNK_SIZE//2 * 3\n",
    "\n",
    "        a[k+0:k2:3] =                       ((b0 & 0xFF0) >> 4)\n",
    "        a[k+1:k2:3] = ((b0 & 0x00F) << 4) + ((b1 & 0xF00) >> 8)\n",
    "        a[k+2:k2:3] = ((b1 & 0x0FF) << 0)\n",
    "\n",
    "    return a\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use pims to connect to the file-like object from the database\n",
    "# we did slyghtly modify Cine.py to accept a GridOut cursor instead of filename string\n",
    "\n",
    "pims_video=Cine(video)\n",
    "\n",
    "#Also store the info dictionary from the video object as an attribute of the pims object \n",
    "pims_video.info=video.info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" style=\"width: 512\" />"
      ],
      "text/plain": [
       "Frame([[119, 118, 116, ..., 127, 125, 125],\n",
       "       [108, 109, 113, ..., 119, 115, 117],\n",
       "       [114, 116, 118, ..., 121, 122, 121],\n",
       "       ..., \n",
       "       [129, 128, 127, ..., 125, 126, 129],\n",
       "       [124, 125, 125, ..., 124, 124, 122],\n",
       "       [118, 117, 115, ..., 116, 117, 115]], dtype=uint8)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pims_video[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define simple video browser with ipywidgets\n",
    "\n",
    "def browse_images_ptm(video):\n",
    "    frames=len(video)\n",
    "    interval=video.info['interval']\n",
    "    muperpix=video.info['muperpix']\n",
    "    filename=video.info['filename']\n",
    "    pixpermu=1/muperpix\n",
    "    \n",
    "    def view_image(framenum):\n",
    "        pyplot.figure(figsize=(6,6))\n",
    "        toplot=video[framenum]\n",
    "        pyplot.title(str(' time: ' + str(framenum*interval) + ' s'))\n",
    "        pyplot.imshow(toplot)\n",
    "        pyplot.set_cmap('gray')\n",
    "        pyplot.axis('off')\n",
    "        \n",
    "    w=widgets.interactive(view_image, framenum=(0,frames-21))\n",
    "    return w\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8748112911494befab9cd85dc48376db",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=139, description='framenum', max=279), Output()), _dom_classes=('widget-…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "browse_images_ptm(pims_video)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The pims_video object in this case is not connected to a file on filesystem but to a gridfs cursor.\n",
    "The benefit of this approach multiple:\n",
    "\n",
    "* Having large files stored on a database allow to access them remotely by multiple user and all the optimization on the access, search and transfer are managed by the database\n",
    "* The video uploading process can be easily managed through a web form submission\n",
    "* Search can be done on filename or any metadata present in the gridfs object\n",
    "* Multiple user can access same file at the same time\n",
    "* Result of analysis can be stored back to the database object to make them available without re-doing time consuming analysis steps like particle tracking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}