params_creator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division\n",
    "from pylab import *\n",
    "import skimage as ski\n",
    "from skimage import data, io, filters, exposure, measure\n",
    "from skimage.filters import rank\n",
    "from skimage import img_as_float, img_as_ubyte\n",
    "from skimage.morphology import disk\n",
    "import skimage.morphology as mp\n",
    "from skimage import util\n",
    "from skimage.color import rgb2hsv, hsv2rgb, rgb2gray, gray2rgb\n",
    "from skimage.filters.edges import convolve\n",
    "from matplotlib import pylab as plt\n",
    "import numpy as np\n",
    "from skimage import feature\n",
    "from numpy import array\n",
    "from IPython.display import display\n",
    "from ipywidgets import interact, interactive, fixed\n",
    "from ipywidgets import *\n",
    "from ipykernel.pylab.backend_inline import flush_figures\n",
    "from multiprocessing.pool import ThreadPool\n",
    "from skimage.transform import hough_circle, hough_circle_peaks\n",
    "from skimage.draw import circle_perimeter\n",
    "from skimage.filters import threshold_otsu\n",
    "from skimage.segmentation import clear_border\n",
    "from skimage.measure import label, regionprops\n",
    "from skimage.morphology import closing, square\n",
    "from skimage.color import label2rgb\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "from scipy import ndimage\n",
    "import cv2\n",
    "\n",
    "\n",
    "def drawDiceImage(i, img):\n",
    "    plt.subplot(3, 2, i)\n",
    "    plt.imshow(img)\n",
    "\n",
    "\n",
    "def drawDiceImageAligned(total, i, img):\n",
    "    in_row = int(total / 3) + 1\n",
    "    ax = plt.subplot(in_row, int(total / in_row), i)\n",
    "    plt.imshow(img)\n",
    "    return ax\n",
    "\n",
    "\n",
    "def getEdges(img, p):\n",
    "    img = rgb2gray(img)\n",
    "    if 'l' in p and 'u' in p:\n",
    "        pp, pk = np.percentile(img, (p['l'], p['u']))\n",
    "        img = exposure.rescale_intensity(img, in_range=(pp, pk))\n",
    "    if 'gamma' in p:\n",
    "        # img = ski.exposure.adjust_gamma(img, p['gamma'])\n",
    "        img = img ** p['gamma']\n",
    "    img = ski.feature.canny(img, sigma=p['sig'])\n",
    "    return img\n",
    "\n",
    "\n",
    "\n",
    "def get_rectangles_with_dim(rectangles, dim_upper):\n",
    "    values = [x for x in rectangles if dim_upper >= x[\"width\"] / x[\"height\"] >= 1 / dim_upper]\n",
    "    sort_by_key(values, 'rarea')\n",
    "    return values\n",
    "\n",
    "\n",
    "def sort_by_key(values, key, rev=True):\n",
    "    values.sort(key=lambda x: x[key], reverse=rev)\n",
    "\n",
    "\n",
    "def try_to_find_dices(img):\n",
    "    filtered_dices = []\n",
    "    for p in params:\n",
    "        try:\n",
    "            dices_candidates = look_for_dices(img, p)\n",
    "            filtered_dices.extend(dices_candidates)\n",
    "        except ValueError:\n",
    "            pass\n",
    "\n",
    "    return filtered_dices\n",
    "\n",
    "\n",
    "def look_for_dices(img, params):\n",
    "    image = params['edgeFunc'](img, params)\n",
    "    regions = find_regions(image)\n",
    "    return filter_dices(regions)\n",
    "\n",
    "\n",
    "def parse_image(img):\n",
    "    filtered_dices = try_to_find_dices(img)\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(10, 6))\n",
    "    if len(filtered_dices) > 0:\n",
    "        firstOk = filtered_dices[0]\n",
    "        filtered = [x for x in filtered_dices if\n",
    "                    x['height'] >= firstOk['height'] / 2 and x['width'] >= firstOk['width'] / 2]\n",
    "        filtered = filtered_dices\n",
    "        total_length = len(filtered)\n",
    "        if total_length > 0:\n",
    "            draw_dice(ax, filtered, img)\n",
    "    ax.imshow(img)\n",
    "\n",
    "\n",
    "def draw_dice(ax, filtered, img):\n",
    "    for f in filtered:\n",
    "        dots_on_dice = find_on_dice(img, f)\n",
    "        for dot in dots_on_dice:\n",
    "            new_x = dot['rect'].get_x() + f['minx']\n",
    "            new_y = dot['rect'].get_y() + f['miny']\n",
    "            dot['rect'].set_xy((new_x, new_y))\n",
    "            ax.add_patch(dot['rect'])\n",
    "        dots_amount = len(dots_on_dice)\n",
    "        if dots_amount > 0:\n",
    "            size = len(img) / 250\n",
    "            cv2.putText(img, str(dots_amount), (f['minx'], f['miny']), 2, fontScale=size,  # 3\n",
    "                        color=(0, 140, 150), thickness=max(int(size), 2))\n",
    "        ax.add_patch(f['rect'])\n",
    "\n",
    "\n",
    "def filter_dices(regions):\n",
    "    values = []\n",
    "    for region in regions:\n",
    "        validate_region(region, values, lambda rect: rect['area'] >= 70, 'orange')\n",
    "    values = get_rectangles_with_dim(values, 2)\n",
    "    return values\n",
    "\n",
    "\n",
    "def find_regions(image):\n",
    "    thresh = threshold_otsu(image)\n",
    "    bw = closing(image > thresh, square(2))\n",
    "    cleared = clear_border(bw)\n",
    "    label_image = label(cleared)\n",
    "    return regionprops(label_image)\n",
    "\n",
    "\n",
    "def validate_region(region, values, validation_fun, color='blue'):\n",
    "    miny, minx, maxy, maxx = region.bbox\n",
    "    height = maxy - miny\n",
    "    width = maxx - minx\n",
    "    rect = mpatches.Rectangle((minx, miny), width, height,\n",
    "                              fill=False, edgecolor=color, linewidth=2)\n",
    "    rect_repr = {\"minx\": minx, \"miny\": miny, \"maxx\": maxx, \"maxy\": maxy, \"rect\": rect, \"area\": region.area,\n",
    "                 \"width\": width, \"height\": height, 'rarea': width * height, 'fill': region.convex_area}\n",
    "    if validation_fun(rect_repr):\n",
    "        values.append(rect_repr)\n",
    "\n",
    "def is_one_value_image(img):\n",
    "    return len(list(set([x for sublist in img for x in sublist]))) <= 1\n",
    "\n",
    "i = 1\n",
    "def find_on_dice(org_img, dice):\n",
    "    global i\n",
    "    dice_img_copy = org_img[dice['miny']:dice['maxy'], dice['minx']:dice['maxx']]\n",
    "    dice_img = getEdges(dice_img_copy, {'gamma': 1, 'sig': 1, 'l': 0, 'u': 100})\n",
    "#     drawDiceImage(i, dice_img)\n",
    "#     i += 1 \n",
    "    if is_one_value_image(dice_img):\n",
    "        return []\n",
    "\n",
    "    regions = find_regions(dice_img)\n",
    "    valid_regions = []\n",
    "    img_size = len(dice_img_copy) * len(dice_img_copy[0])\n",
    "    for region in regions:\n",
    "        validate_region(region, valid_regions, lambda rect: img_size * .005 <= rect['rarea'] <= img_size * .06)\n",
    "    ratio = 1.4\n",
    "    filtered = get_rectangles_with_dim(valid_regions, ratio)\n",
    "\n",
    "    if len(filtered) > 0:\n",
    "        filtered = filter_dots(filtered, ratio)\n",
    "\n",
    "    return filtered\n",
    "\n",
    "\n",
    "def filter_dots(filtered, ratio):\n",
    "    filtered = remove_mistaken_dots(filtered, ratio)\n",
    "    filtered = remove_overlaped(filtered)\n",
    "    filtered = remove_smaller_than_half_of_the_biggest(filtered)\n",
    "    filtered = remove_the_farthest_if_more_than_six(filtered)\n",
    "    return filtered\n",
    "\n",
    "\n",
    "def remove_the_farthest_if_more_than_six(filtered):\n",
    "    for f in filtered:\n",
    "        f['center'] = {\n",
    "            'x': int((f['minx'] + f['maxx']) / 2),\n",
    "            'y': int((f['miny'] + f['maxy']) / 2)\n",
    "        }\n",
    "    for f1 in filtered:\n",
    "        f1['total_dist'] = 0\n",
    "        for f2 in filtered:\n",
    "            f1['total_dist'] += get_distance_between(f1, f2)\n",
    "    sort_by_key(filtered, 'total_dist', False)\n",
    "    if len(filtered) > 6:\n",
    "        filtered = filtered[0:6]\n",
    "    return filtered\n",
    "\n",
    "\n",
    "def get_distance_between(f1, f2):\n",
    "    return sqrt(\n",
    "        abs(f1['center']['x'] - f2['center']['x']) ** 2 +\n",
    "        abs(f1['center']['y'] - f2['center']['y']) ** 2\n",
    "    )\n",
    "\n",
    "\n",
    "def remove_smaller_than_half_of_the_biggest(filtered):\n",
    "    max_area = max(get_rareas(filtered))\n",
    "    filtered = [f for f in filtered if f['rarea'] > 0.5 * max_area]\n",
    "    return filtered\n",
    "\n",
    "\n",
    "def remove_mistaken_dots(filtered, ratio):\n",
    "    by_rarea = get_rareas(filtered)\n",
    "    center_point = np.percentile(by_rarea, 80)\n",
    "    filtered_first = [f for f in filtered if center_point * 1 / ratio <= f['rarea'] <= center_point * ratio]\n",
    "    if len(filtered_first) < 0.3 * len(filtered):\n",
    "        ratio = ratio ** 2\n",
    "        filtered_first = [f for f in filtered if center_point * 1 / ratio <= f['rarea'] <= center_point * ratio]\n",
    "        if len(filtered_first) < 0.3 * len(filtered):\n",
    "            center_point = sum(by_rarea) / len(by_rarea)\n",
    "            filtered = [f for f in filtered if center_point * 1 / ratio <= f['rarea'] <= center_point * ratio]\n",
    "    else:\n",
    "        filtered = filtered_first\n",
    "    return filtered\n",
    "\n",
    "\n",
    "def get_rareas(filtered):\n",
    "    return [f['rarea'] for f in filtered]\n",
    "\n",
    "\n",
    "def remove_overlaped(filtered):\n",
    "    res = []\n",
    "    for f1 in filtered:\n",
    "        isOk = True\n",
    "        for f2 in filtered:\n",
    "            if f1 != f2:\n",
    "                if f1['rarea'] < f2['rarea']:\n",
    "                    if (sum([\n",
    "                        f2['miny'] <= f1['miny'] <= f2['maxy'] and f2['minx'] <= f1['minx'] <= f2['maxx'],\n",
    "                        f2['miny'] <= f1['maxy'] <= f2['maxy'] and f2['minx'] <= f1['minx'] <= f2['maxx'],\n",
    "                        f2['miny'] <= f1['miny'] <= f2['maxy'] and f2['minx'] <= f1['maxx'] <= f2['maxx'],\n",
    "                        f2['miny'] <= f1['maxy'] <= f2['maxy'] and f2['minx'] <= f1['maxx'] <= f2['maxx']\n",
    "                    ]) >= 2):\n",
    "                        isOk = False\n",
    "                        break\n",
    "        if isOk:\n",
    "            res.append(f1)\n",
    "    return res\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def just_canny(img, p):\n",
    "    img = rgb2gray(img)\n",
    "    # img = exposure.equalize_hist(img)\n",
    "    al = []\n",
    "    for i in img:\n",
    "        al.extend(i)\n",
    "    print(sum(al) / len(al))\n",
    "    img = ski.morphology.dilation(img)\n",
    "    img = ski.feature.canny(img, sigma=p['sig'], low_threshold=p['low'], high_threshold=p['high'])\n",
    "    return img\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "dicesToRead = [\n",
    "    '01', '02', '03', '04', '05',\n",
    "    '06', '07', '08', '09', '10',\n",
    "    '11', '12', '13', '14', '15',\n",
    "    '16', '17', '18', '19', '20',\n",
    "    '21'\n",
    "]\n",
    "\n",
    "params = [\n",
    "        {'gamma': 0.4, 'sig': 2.7, 'l': 91, 'u': 90, 'edgeFunc': lambda img, p: getEdges(img, p)},\n",
    "        {'l': 0.6, 'u': 15.4, 'tresh': 0.1, 'edgeFunc': lambda img, p: simpleGray(img, p)},\n",
    "        {'sig': 4, 'edgeFunc': lambda img, p: just_canny(img, p)},\n",
    "        {'l': 0.6, 'u': 15.4, 'tresh': 0.4, 'lev': 0.19, 'edgeFunc': lambda img, p: edges_with_contours(img, p)}\n",
    "        # {'gamma': 0.5, 'sig': 1.4, 'l': 0, 'u': 100, 'edgeFunc': lambda img, p: getEdges(img, p)},\n",
    "        # {'gamma': 0.5, 'sig': 1.4, 'l': 0, 'u': 85, 'edgeFunc': lambda img, p: simpleGray(img, p)},\n",
    "    ]\n",
    "\n",
    "def set_params(g, s, l, u, b, low, high, tresh, lev):\n",
    "    global params\n",
    "    params = [{'gamma': g, 'sig': s, 'l': l, 'u': u, 'b':b, 'lev': lev,\n",
    "               'edgeFunc': lambda img, p: just_canny(img, p), 'low':low, 'high':high, 'tresh':tresh}]\n",
    "\n",
    "dicesToRead = [\n",
    "    '18','13'\n",
    "]\n",
    "\n",
    "dices = [io.imread('./dices/dice{0}.jpg'.format(i)) for i in dicesToRead]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "10daf98f360b4b90a0c6033af5e07a3c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in Jupyter Notebook or JupyterLab, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another notebook frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.5, description='g', max=2.0, min=0.1), FloatSlider(value=3.7, description='s', max=4.0, min=0.5), FloatSlider(value=0.6, description='l', max=90.0, step=0.01), FloatSlider(value=15.4, description='u', min=1.0, step=0.01), FloatSlider(value=1.0, description='b', max=3.0, min=0.1), FloatSlider(value=0.05, description='low', max=1.0, step=0.01), FloatSlider(value=0.3, description='high', max=1.0, step=0.01), FloatSlider(value=0.4, description='tr', max=0.6, min=0.01, step=0.01), FloatSlider(value=0.15, description='lev', max=0.3, min=0.1, step=0.01), Output()), _dom_classes=('widget-interact',))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.drawDices>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def drawDices(g=0.5, s=3.7, l=0.6, u=15.4, b = 1, low=0.05, high = 0.3, tr=0.4, lev =0.15):\n",
    "    set_params(g,s,l,u, b, low, high, tr, lev)\n",
    "    fig = plt.figure(facecolor=\"black\", figsize=(60, 60))\n",
    "    for i, image in enumerate(dices):\n",
    "        image = np.copy(image)\n",
    "        parse_image(image)\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    print(params)\n",
    "    fig.savefig(\"dices.pdf\", facecolor=\"black\")\n",
    "    plt.close()\n",
    "\n",
    "\n",
    "interact(drawDices, g=(0.1,2,0.1), s=(0.5,4,0.1), l=(0,90,0.01), u=(1,100,0.01), \n",
    "         b=(0.1,3,0.1), low=(0,1,0.01), high=(0,1,0.01), tr=(0.01,0.6,0.01), lev=(0.1,0.3,0.01))"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}