add datasets

2 files changed, 578 insertions, 0 deletions

diff --git a/megapixels/notebooks/datasets/face_tracer.ipynb b/megapixels/notebooks/datasets/face_tracer.ipynb
new file mode 100644
index 00000000..b67e0942
--- /dev/null
+++ b/megapixels/notebooks/datasets/face_tracer.ipynb
@@ -0,0 +1,578 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Face Tracer\n",
+    "\n",
+    "Create visualizations based on the FaceTracer dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import os\n",
+    "from os.path import join\n",
+    "from pathlib import Path\n",
+    "import math\n",
+    "\n",
+    "import cv2 as cv\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from PIL import Image, ImageDraw\n",
+    "%matplotlib inline\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import sys\n",
+    "sys.path.append('/work/megapixels_dev/megapixels/')\n",
+    "from app.settings import app_cfg as cfg\n",
+    "from app.utils import im_utils, file_utils"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dir_facetracer = join(cfg.DATA_STORE_NAS, 'datasets/people/face_tracer')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "attributes.txt                                \u001b[0m\u001b[34;42m@eaDir\u001b[0m/         \u001b[01;31mfacetracer.zip\u001b[0m\r\n",
+      "Bitouk_SIGGRAPH08.pdf                         faceindex.txt   Kumar_ECCV08.pdf\r\n",
+      "\u001b[34;42mCAVE _ Databases_ FaceTracer Database_files\u001b[0m/  facelabels.txt  url.txt\r\n",
+      "CAVE _ Databases_ FaceTracer Database.html    facestats.txt\r\n",
+      "CAVE _ Databases_ FaceTracer Database.pdf     facetracer.py\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "%ls $dir_facetracer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "# FaceTracer Dataset v1.0 - facestats.txt - http://www.cs.columbia.edu/CAVE/databases/facetracer/\r\n",
+      "# Format: face_id\tcrop_w\tcrop_h\tcrop_x0\tcrop_y0\tyaw\tpitch\troll\tleft_eye_left_x\tleft_eye_left_y\tleft_eye_right_x\tleft_eye_right_y\tright_eye_left_x\tright_eye_left_y\tright_eye_right_x\tright_eye_right_y\tmouth_left_x\tmouth_left_y\tmouth_right_x\tmouth_right_y\r\n",
+      "1\t133\t138\t0\t0\t-6\t3\t5\t35\t69\t50\t71\t71\t73\t87\t72\t41\t104\t79\t106\r\n",
+      "2\t64\t72\t71\t0\t-14\t17\t-8\t21\t24\t26\t23\t35\t21\t41\t19\t27\t39\t42\t35\r\n",
+      "3\t128\t180\t0\t0\t-9\t6\t4\t32\t76\t46\t77\t65\t79\t80\t78\t37\t108\t72\t110\r\n",
+      "cat: write error: Broken pipe\r\n"
+     ]
+    }
+   ],
+   "source": [
+    "%cat $dir_facetracer/'facestats.txt' | head -n5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Help on function read_csv in module pandas.io.parsers:\n",
+      "\n",
+      "read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, iterator=False, chunksize=None, compression='infer', thousands=None, decimal=b'.', lineterminator=None, quotechar='\"', quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, tupleize_cols=None, error_bad_lines=True, warn_bad_lines=True, skipfooter=0, doublequote=True, delim_whitespace=False, low_memory=True, memory_map=False, float_precision=None)\n",
+      "    Read CSV (comma-separated) file into DataFrame\n",
+      "    \n",
+      "    Also supports optionally iterating or breaking of the file\n",
+      "    into chunks.\n",
+      "    \n",
+      "    Additional help can be found in the `online docs for IO Tools\n",
+      "    <http://pandas.pydata.org/pandas-docs/stable/io.html>`_.\n",
+      "    \n",
+      "    Parameters\n",
+      "    ----------\n",
+      "    filepath_or_buffer : str, pathlib.Path, py._path.local.LocalPath or any \\\n",
+      "    object with a read() method (such as a file handle or StringIO)\n",
+      "        The string could be a URL. Valid URL schemes include http, ftp, s3, and\n",
+      "        file. For file URLs, a host is expected. For instance, a local file could\n",
+      "        be file://localhost/path/to/table.csv\n",
+      "    sep : str, default ','\n",
+      "        Delimiter to use. If sep is None, the C engine cannot automatically detect\n",
+      "        the separator, but the Python parsing engine can, meaning the latter will\n",
+      "        be used and automatically detect the separator by Python's builtin sniffer\n",
+      "        tool, ``csv.Sniffer``. In addition, separators longer than 1 character and\n",
+      "        different from ``'\\s+'`` will be interpreted as regular expressions and\n",
+      "        will also force the use of the Python parsing engine. Note that regex\n",
+      "        delimiters are prone to ignoring quoted data. Regex example: ``'\\r\\t'``\n",
+      "    delimiter : str, default ``None``\n",
+      "        Alternative argument name for sep.\n",
+      "    delim_whitespace : boolean, default False\n",
+      "        Specifies whether or not whitespace (e.g. ``' '`` or ``'\\t'``) will be\n",
+      "        used as the sep. Equivalent to setting ``sep='\\s+'``. If this option\n",
+      "        is set to True, nothing should be passed in for the ``delimiter``\n",
+      "        parameter.\n",
+      "    \n",
+      "        .. versionadded:: 0.18.1 support for the Python parser.\n",
+      "    \n",
+      "    header : int or list of ints, default 'infer'\n",
+      "        Row number(s) to use as the column names, and the start of the\n",
+      "        data.  Default behavior is to infer the column names: if no names\n",
+      "        are passed the behavior is identical to ``header=0`` and column\n",
+      "        names are inferred from the first line of the file, if column\n",
+      "        names are passed explicitly then the behavior is identical to\n",
+      "        ``header=None``. Explicitly pass ``header=0`` to be able to\n",
+      "        replace existing names. The header can be a list of integers that\n",
+      "        specify row locations for a multi-index on the columns\n",
+      "        e.g. [0,1,3]. Intervening rows that are not specified will be\n",
+      "        skipped (e.g. 2 in this example is skipped). Note that this\n",
+      "        parameter ignores commented lines and empty lines if\n",
+      "        ``skip_blank_lines=True``, so header=0 denotes the first line of\n",
+      "        data rather than the first line of the file.\n",
+      "    names : array-like, default None\n",
+      "        List of column names to use. If file contains no header row, then you\n",
+      "        should explicitly pass header=None. Duplicates in this list will cause\n",
+      "        a ``UserWarning`` to be issued.\n",
+      "    index_col : int or sequence or False, default None\n",
+      "        Column to use as the row labels of the DataFrame. If a sequence is given, a\n",
+      "        MultiIndex is used. If you have a malformed file with delimiters at the end\n",
+      "        of each line, you might consider index_col=False to force pandas to _not_\n",
+      "        use the first column as the index (row names)\n",
+      "    usecols : list-like or callable, default None\n",
+      "        Return a subset of the columns. If list-like, all elements must either\n",
+      "        be positional (i.e. integer indices into the document columns) or strings\n",
+      "        that correspond to column names provided either by the user in `names` or\n",
+      "        inferred from the document header row(s). For example, a valid list-like\n",
+      "        `usecols` parameter would be [0, 1, 2] or ['foo', 'bar', 'baz']. Element\n",
+      "        order is ignored, so ``usecols=[0, 1]`` is the same as ``[1, 0]``.\n",
+      "        To instantiate a DataFrame from ``data`` with element order preserved use\n",
+      "        ``pd.read_csv(data, usecols=['foo', 'bar'])[['foo', 'bar']]`` for columns\n",
+      "        in ``['foo', 'bar']`` order or\n",
+      "        ``pd.read_csv(data, usecols=['foo', 'bar'])[['bar', 'foo']]``\n",
+      "        for ``['bar', 'foo']`` order.\n",
+      "    \n",
+      "        If callable, the callable function will be evaluated against the column\n",
+      "        names, returning names where the callable function evaluates to True. An\n",
+      "        example of a valid callable argument would be ``lambda x: x.upper() in\n",
+      "        ['AAA', 'BBB', 'DDD']``. Using this parameter results in much faster\n",
+      "        parsing time and lower memory usage.\n",
+      "    squeeze : boolean, default False\n",
+      "        If the parsed data only contains one column then return a Series\n",
+      "    prefix : str, default None\n",
+      "        Prefix to add to column numbers when no header, e.g. 'X' for X0, X1, ...\n",
+      "    mangle_dupe_cols : boolean, default True\n",
+      "        Duplicate columns will be specified as 'X', 'X.1', ...'X.N', rather than\n",
+      "        'X'...'X'. Passing in False will cause data to be overwritten if there\n",
+      "        are duplicate names in the columns.\n",
+      "    dtype : Type name or dict of column -> type, default None\n",
+      "        Data type for data or columns. E.g. {'a': np.float64, 'b': np.int32}\n",
+      "        Use `str` or `object` together with suitable `na_values` settings\n",
+      "        to preserve and not interpret dtype.\n",
+      "        If converters are specified, they will be applied INSTEAD\n",
+      "        of dtype conversion.\n",
+      "    engine : {'c', 'python'}, optional\n",
+      "        Parser engine to use. The C engine is faster while the python engine is\n",
+      "        currently more feature-complete.\n",
+      "    converters : dict, default None\n",
+      "        Dict of functions for converting values in certain columns. Keys can either\n",
+      "        be integers or column labels\n",
+      "    true_values : list, default None\n",
+      "        Values to consider as True\n",
+      "    false_values : list, default None\n",
+      "        Values to consider as False\n",
+      "    skipinitialspace : boolean, default False\n",
+      "        Skip spaces after delimiter.\n",
+      "    skiprows : list-like or integer or callable, default None\n",
+      "        Line numbers to skip (0-indexed) or number of lines to skip (int)\n",
+      "        at the start of the file.\n",
+      "    \n",
+      "        If callable, the callable function will be evaluated against the row\n",
+      "        indices, returning True if the row should be skipped and False otherwise.\n",
+      "        An example of a valid callable argument would be ``lambda x: x in [0, 2]``.\n",
+      "    skipfooter : int, default 0\n",
+      "        Number of lines at bottom of file to skip (Unsupported with engine='c')\n",
+      "    nrows : int, default None\n",
+      "        Number of rows of file to read. Useful for reading pieces of large files\n",
+      "    na_values : scalar, str, list-like, or dict, default None\n",
+      "        Additional strings to recognize as NA/NaN. If dict passed, specific\n",
+      "        per-column NA values.  By default the following values are interpreted as\n",
+      "        NaN: '', '#N/A', '#N/A N/A', '#NA', '-1.#IND', '-1.#QNAN', '-NaN', '-nan',\n",
+      "        '1.#IND', '1.#QNAN', 'N/A', 'NA', 'NULL', 'NaN', 'n/a', 'nan',\n",
+      "        'null'.\n",
+      "    keep_default_na : bool, default True\n",
+      "        Whether or not to include the default NaN values when parsing the data.\n",
+      "        Depending on whether `na_values` is passed in, the behavior is as follows:\n",
+      "    \n",
+      "        * If `keep_default_na` is True, and `na_values` are specified, `na_values`\n",
+      "          is appended to the default NaN values used for parsing.\n",
+      "        * If `keep_default_na` is True, and `na_values` are not specified, only\n",
+      "          the default NaN values are used for parsing.\n",
+      "        * If `keep_default_na` is False, and `na_values` are specified, only\n",
+      "          the NaN values specified `na_values` are used for parsing.\n",
+      "        * If `keep_default_na` is False, and `na_values` are not specified, no\n",
+      "          strings will be parsed as NaN.\n",
+      "    \n",
+      "        Note that if `na_filter` is passed in as False, the `keep_default_na` and\n",
+      "        `na_values` parameters will be ignored.\n",
+      "    na_filter : boolean, default True\n",
+      "        Detect missing value markers (empty strings and the value of na_values). In\n",
+      "        data without any NAs, passing na_filter=False can improve the performance\n",
+      "        of reading a large file\n",
+      "    verbose : boolean, default False\n",
+      "        Indicate number of NA values placed in non-numeric columns\n",
+      "    skip_blank_lines : boolean, default True\n",
+      "        If True, skip over blank lines rather than interpreting as NaN values\n",
+      "    parse_dates : boolean or list of ints or names or list of lists or dict, default False\n",
+      "    \n",
+      "        * boolean. If True -> try parsing the index.\n",
+      "        * list of ints or names. e.g. If [1, 2, 3] -> try parsing columns 1, 2, 3\n",
+      "          each as a separate date column.\n",
+      "        * list of lists. e.g.  If [[1, 3]] -> combine columns 1 and 3 and parse as\n",
+      "          a single date column.\n",
+      "        * dict, e.g. {'foo' : [1, 3]} -> parse columns 1, 3 as date and call result\n",
+      "          'foo'\n",
+      "    \n",
+      "        If a column or index contains an unparseable date, the entire column or\n",
+      "        index will be returned unaltered as an object data type. For non-standard\n",
+      "        datetime parsing, use ``pd.to_datetime`` after ``pd.read_csv``\n",
+      "    \n",
+      "        Note: A fast-path exists for iso8601-formatted dates.\n",
+      "    infer_datetime_format : boolean, default False\n",
+      "        If True and `parse_dates` is enabled, pandas will attempt to infer the\n",
+      "        format of the datetime strings in the columns, and if it can be inferred,\n",
+      "        switch to a faster method of parsing them. In some cases this can increase\n",
+      "        the parsing speed by 5-10x.\n",
+      "    keep_date_col : boolean, default False\n",
+      "        If True and `parse_dates` specifies combining multiple columns then\n",
+      "        keep the original columns.\n",
+      "    date_parser : function, default None\n",
+      "        Function to use for converting a sequence of string columns to an array of\n",
+      "        datetime instances. The default uses ``dateutil.parser.parser`` to do the\n",
+      "        conversion. Pandas will try to call `date_parser` in three different ways,\n",
+      "        advancing to the next if an exception occurs: 1) Pass one or more arrays\n",
+      "        (as defined by `parse_dates`) as arguments; 2) concatenate (row-wise) the\n",
+      "        string values from the columns defined by `parse_dates` into a single array\n",
+      "        and pass that; and 3) call `date_parser` once for each row using one or\n",
+      "        more strings (corresponding to the columns defined by `parse_dates`) as\n",
+      "        arguments.\n",
+      "    dayfirst : boolean, default False\n",
+      "        DD/MM format dates, international and European format\n",
+      "    iterator : boolean, default False\n",
+      "        Return TextFileReader object for iteration or getting chunks with\n",
+      "        ``get_chunk()``.\n",
+      "    chunksize : int, default None\n",
+      "        Return TextFileReader object for iteration.\n",
+      "        See the `IO Tools docs\n",
+      "        <http://pandas.pydata.org/pandas-docs/stable/io.html#io-chunking>`_\n",
+      "        for more information on ``iterator`` and ``chunksize``.\n",
+      "    compression : {'infer', 'gzip', 'bz2', 'zip', 'xz', None}, default 'infer'\n",
+      "        For on-the-fly decompression of on-disk data. If 'infer' and\n",
+      "        `filepath_or_buffer` is path-like, then detect compression from the\n",
+      "        following extensions: '.gz', '.bz2', '.zip', or '.xz' (otherwise no\n",
+      "        decompression). If using 'zip', the ZIP file must contain only one data\n",
+      "        file to be read in. Set to None for no decompression.\n",
+      "    \n",
+      "        .. versionadded:: 0.18.1 support for 'zip' and 'xz' compression.\n",
+      "    \n",
+      "    thousands : str, default None\n",
+      "        Thousands separator\n",
+      "    decimal : str, default '.'\n",
+      "        Character to recognize as decimal point (e.g. use ',' for European data).\n",
+      "    float_precision : string, default None\n",
+      "        Specifies which converter the C engine should use for floating-point\n",
+      "        values. The options are `None` for the ordinary converter,\n",
+      "        `high` for the high-precision converter, and `round_trip` for the\n",
+      "        round-trip converter.\n",
+      "    lineterminator : str (length 1), default None\n",
+      "        Character to break file into lines. Only valid with C parser.\n",
+      "    quotechar : str (length 1), optional\n",
+      "        The character used to denote the start and end of a quoted item. Quoted\n",
+      "        items can include the delimiter and it will be ignored.\n",
+      "    quoting : int or csv.QUOTE_* instance, default 0\n",
+      "        Control field quoting behavior per ``csv.QUOTE_*`` constants. Use one of\n",
+      "        QUOTE_MINIMAL (0), QUOTE_ALL (1), QUOTE_NONNUMERIC (2) or QUOTE_NONE (3).\n",
+      "    doublequote : boolean, default ``True``\n",
+      "       When quotechar is specified and quoting is not ``QUOTE_NONE``, indicate\n",
+      "       whether or not to interpret two consecutive quotechar elements INSIDE a\n",
+      "       field as a single ``quotechar`` element.\n",
+      "    escapechar : str (length 1), default None\n",
+      "        One-character string used to escape delimiter when quoting is QUOTE_NONE.\n",
+      "    comment : str, default None\n",
+      "        Indicates remainder of line should not be parsed. If found at the beginning\n",
+      "        of a line, the line will be ignored altogether. This parameter must be a\n",
+      "        single character. Like empty lines (as long as ``skip_blank_lines=True``),\n",
+      "        fully commented lines are ignored by the parameter `header` but not by\n",
+      "        `skiprows`. For example, if ``comment='#'``, parsing\n",
+      "        ``#empty\\na,b,c\\n1,2,3`` with ``header=0`` will result in 'a,b,c' being\n",
+      "        treated as the header.\n",
+      "    encoding : str, default None\n",
+      "        Encoding to use for UTF when reading/writing (ex. 'utf-8'). `List of Python\n",
+      "        standard encodings\n",
+      "        <https://docs.python.org/3/library/codecs.html#standard-encodings>`_\n",
+      "    dialect : str or csv.Dialect instance, default None\n",
+      "        If provided, this parameter will override values (default or not) for the\n",
+      "        following parameters: `delimiter`, `doublequote`, `escapechar`,\n",
+      "        `skipinitialspace`, `quotechar`, and `quoting`. If it is necessary to\n",
+      "        override values, a ParserWarning will be issued. See csv.Dialect\n",
+      "        documentation for more details.\n",
+      "    tupleize_cols : boolean, default False\n",
+      "        .. deprecated:: 0.21.0\n",
+      "           This argument will be removed and will always convert to MultiIndex\n",
+      "    \n",
+      "        Leave a list of tuples on columns as is (default is to convert to\n",
+      "        a MultiIndex on the columns)\n",
+      "    error_bad_lines : boolean, default True\n",
+      "        Lines with too many fields (e.g. a csv line with too many commas) will by\n",
+      "        default cause an exception to be raised, and no DataFrame will be returned.\n",
+      "        If False, then these \"bad lines\" will dropped from the DataFrame that is\n",
+      "        returned.\n",
+      "    warn_bad_lines : boolean, default True\n",
+      "        If error_bad_lines is False, and warn_bad_lines is True, a warning for each\n",
+      "        \"bad line\" will be output.\n",
+      "    low_memory : boolean, default True\n",
+      "        Internally process the file in chunks, resulting in lower memory use\n",
+      "        while parsing, but possibly mixed type inference.  To ensure no mixed\n",
+      "        types either set False, or specify the type with the `dtype` parameter.\n",
+      "        Note that the entire file is read into a single DataFrame regardless,\n",
+      "        use the `chunksize` or `iterator` parameter to return the data in chunks.\n",
+      "        (Only valid with C parser)\n",
+      "    memory_map : boolean, default False\n",
+      "        If a filepath is provided for `filepath_or_buffer`, map the file object\n",
+      "        directly onto memory and access the data directly from there. Using this\n",
+      "        option can improve performance because there is no longer any I/O overhead.\n",
+      "    \n",
+      "    Returns\n",
+      "    -------\n",
+      "    result : DataFrame or TextParser\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "help(pd.read_csv)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 124,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fp_stats = join(dir_facetracer, 'facestats.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 135,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class FaceData:\n",
+    "  \n",
+    "  def __init__(self, d):\n",
+    "    # convert defaulta data to normalized square\n",
+    "    self.dots = []\n",
+    "    x, y = d['crop_x0'], d['crop_y0']\n",
+    "    w, h = d['crop_w'], d['crop_h']\n",
+    "    # left eye, left\n",
+    "    self.dots.append( [d['left_eye_left_x'], d['left_eye_left_y']] )\n",
+    "    # left eye, right\n",
+    "    self.dots.append( [d['left_eye_right_x'], d['left_eye_right_y']] )\n",
+    "    # right eye, left\n",
+    "    self.dots.append( [d['right_eye_left_x'], d['right_eye_left_y']] )\n",
+    "    # right eye, right\n",
+    "    self.dots.append( [d['right_eye_right_x'], d['right_eye_right_y']] ) \n",
+    "    # mouth left\n",
+    "    self.dots.append( [d['mouth_left_x'], d['mouth_left_y']] )\n",
+    "    # mouth right\n",
+    "    self.dots.append( [d['mouth_right_x'], d['mouth_right_y']] )\n",
+    "    \n",
+    "    # normalize points\n",
+    "    self.dots_norm = self.dots.copy()\n",
+    "    for dot in self.dots_norm:\n",
+    "      dot[0] /= w\n",
+    "      dot[1] /= h\n",
+    "      \n",
+    "      \n",
+    "  def to_dim(self, wh):\n",
+    "    scaled  = []\n",
+    "    for d in self.dots:\n",
+    "      scaled.append( (int(d[0] * wh[0]), int(d[1] * wh[1])) )\n",
+    "    return scaled"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 143,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_stats = pd.read_csv(fp_stats, delimiter='\\t')\n",
+    "#df_stats = df_stats[0:20]\n",
+    "\n",
+    "faces = []\n",
+    "for i, row in df_stats.iterrows():\n",
+    "  faces.append(FaceData(row))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 144,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib as mpl\n",
+    "import matplotlib.cm as mplcm\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib import cm\n",
+    "\n",
+    "def get_color_map(cmap='prism', ncolors=20, as_hex=False, reverse=False, bgr=True):\n",
+    "  norm  = mpl.colors.Normalize(vmin=0, vmax=ncolors-1)\n",
+    "  scalars = mplcm.ScalarMappable(norm=norm, cmap=cmap)\n",
+    "  colors = [scalars.to_rgba(i) for i in range(ncolors)]\n",
+    "  colors = [(int(255*c[0]),int(255*c[1]),int(255*c[2])) for c in colors]  \n",
+    "  if reverse:\n",
+    "    colors = colors[::-1]\n",
+    "  if bgr:\n",
+    "    colors = [c[::-1] for c in colors]\n",
+    "  if as_hex:\n",
+    "    colors = ['#{:02x}{:02x}{:02x}'.format(c[0],c[1],c[2]) for c in colors]\n",
+    "  return colors\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 173,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "w, h = (1600, 2000)\n",
+    "r = 1\n",
+    "im = np.ones((h, w, 3)).astype(np.uint8) * 0\n",
+    "\n",
+    "colors = get_color_map(cmap='jet', ncolors=len(faces))\n",
+    "\n",
+    "for i, face in enumerate(faces):\n",
+    "  dots = face.to_dim((w, h))\n",
+    "  for dot in dots:\n",
+    "    cv.circle(im, dot, r, colors[i], -1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 174,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f2b33beaa58>"
+      ]
+     },
+     "execution_count": 174,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "cv.imwrite('face_tracer.png', im)\n",
+    "plt.figure(figsize=(10,10))\n",
+    "plt.xticks([]), plt.yticks([])\n",
+    "plt.imshow(cv.cvtColor(im, cv.COLOR_BGR2RGB))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f2ad218a710>"
+      ]
+     },
+     "execution_count": 112,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "im = Image.new('RGB', (500,500), color='#FFFFFF')\n",
+    "im_draw = ImageDraw.Draw(im)\n",
+    "im_draw.rectangle(((0, 0), (100, 100)), fill=\"black\")\n",
+    "im_draw.ellipse( (10, 10, 50, 50), fill=\"#ff0000\")\n",
+    "\n",
+    "plt.figure(figsize=(10,10))\n",
+    "plt.xticks([]), plt.yticks([])\n",
+    "plt.imshow(im)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python [conda env:vframe]",
+   "language": "python",
+   "name": "conda-env-vframe-py"
+  },
+  "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.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/megapixels/notebooks/datasets/face_tracer.png b/megapixels/notebooks/datasets/face_tracer.png
new file mode 100644
index 00000000..dc04f0a6
--- /dev/null
+++ b/megapixels/notebooks/datasets/face_tracer.png