notebooks/Create Resized Images.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This code ingests:\n",
    "    \n",
    "- A set of photos (e.g. `photos/png1600` or `depth/png320`)\n",
    "\n",
    "And outputs:\n",
    "\n",
    "- A `.npy` file or a set of `.jpg` or `.png` images containing resized and cropped versions of the images.\n",
    "\n",
    "This notebook also shows a preview of the resized images in a grid of small multiples when saving .npy files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils.imutil import *\n",
    "from utils.list_all_files import *\n",
    "from utils.crop import *\n",
    "from utils.progress import *\n",
    "from utils.mosaic import *\n",
    "import os\n",
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_dir = '../data/photos/png1600'\n",
    "output_dir = '../data/photos/npy32'\n",
    "\n",
    "# input_dir = '../data/detectron/png1600'\n",
    "# output_dir = '../data/detectron/npy32'\n",
    "\n",
    "# input_dir = '../data/depth/png320'\n",
    "# output_dir = '../data/depth/npy32'\n",
    "\n",
    "# input_dir = '../data/saliency/jpg640'\n",
    "# output_dir = '../data/saliency/npy32'\n",
    "\n",
    "# input_dir = '../data/openface/jpg640-ellipses'\n",
    "# output_dir = '../data/openface/npy32-ellipses'\n",
    "\n",
    "output_fmt = '.npy' # .jpg, .png, .npy\n",
    "output_side = 32\n",
    "max_n = None #256\n",
    "\n",
    "# crop = outer_square_crop\n",
    "crop = inner_square_crop\n",
    "# crop = None\n",
    "\n",
    "covert_to_grayscale = True # False\n",
    "output_dtype = np.uint8 # None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59278 0:01:14 801.70/s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 512,
       "width": 512
      }
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def natural_sort_key(s, _nsre=re.compile('([0-9]+)')):\n",
    "    return [int(text) if text.isdigit() else text.lower()\n",
    "            for text in _nsre.split(s)]\n",
    "\n",
    "def get_id(fn):\n",
    "    return os.path.splitext(os.path.basename(fn))[0]\n",
    "\n",
    "def job(task):\n",
    "    try:\n",
    "        input_fn, output_fn = task\n",
    "        img = imread(input_fn)\n",
    "        if crop is not None:\n",
    "            img = crop(img)\n",
    "        img = imresize(img, max_side=output_side)\n",
    "        if covert_to_grayscale and len(img.shape) == 3:\n",
    "            img = img.mean(axis=2)\n",
    "        if output_dtype is not None:\n",
    "            img = img.astype(output_dtype)\n",
    "        if output_fmt == '.npy':\n",
    "            return img\n",
    "        else:\n",
    "            imwrite(output_fn, img)\n",
    "            return img.shape\n",
    "    except:\n",
    "        print('Error:', input_fn)\n",
    "        raise\n",
    "\n",
    "tasks = []\n",
    "for input_fn in list_all_files(input_dir):\n",
    "    relpath = os.path.relpath(input_fn, input_dir)\n",
    "    reldir = os.path.split(relpath)[0]\n",
    "    if output_fmt == '.npy':\n",
    "        tasks.append((input_fn, relpath))\n",
    "    else:\n",
    "        output_fn = os.path.join(output_dir, os.path.splitext(relpath)[0] + output_fmt)\n",
    "        os.makedirs(os.path.split(output_fn)[0], exist_ok=True)\n",
    "        tasks.append((input_fn, output_fn))\n",
    "        \n",
    "tasks.sort(key=lambda x: natural_sort_key(get_id(x[0])))\n",
    "\n",
    "if max_n is not None:\n",
    "    tasks = tasks[:max_n]\n",
    "\n",
    "results = progress_parallel(job, tasks)\n",
    "\n",
    "if output_fmt == '.npy':\n",
    "    images = np.asarray(results)\n",
    "    imshow(make_mosaic(images[:256]))\n",
    "    \n",
    "    os.makedirs(output_dir, exist_ok=True)\n",
    "    np.save(os.path.join(output_dir, 'images.npy'), images)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}