sudoku-final.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing.image import img_to_array\n",
    "from tensorflow.keras.models import load_model\n",
    "from sudoku import Sudoku\n",
    "import numpy as np\n",
    "import argparse\n",
    "import imutils\n",
    "import cv2\n",
    "from imutils.perspective import four_point_transform\n",
    "from skimage.segmentation import clear_border\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_puzzle(image, debug=False):\n",
    "\t# convert the image to grayscale and blur it slightly\n",
    "\tgray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
    "\tblurred = cv2.GaussianBlur(gray, (7, 7), 3)\n",
    "\n",
    "\t# apply adaptive thresholding and then invert the threshold map\n",
    "\tthresh = cv2.adaptiveThreshold(blurred, 255,\n",
    "\t\tcv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)\n",
    "\tthresh = cv2.bitwise_not(thresh)\n",
    "\n",
    "\t# find contours in the thresholded image and sort them by size in\n",
    "\t# descending order\n",
    "\tcnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,\n",
    "\t\tcv2.CHAIN_APPROX_SIMPLE)\n",
    "\tcnts = imutils.grab_contours(cnts)\n",
    "\tcnts = sorted(cnts, key=cv2.contourArea, reverse=True)\n",
    "\n",
    "\t# initialize a contour that corresponds to the puzzle outline\n",
    "\tpuzzleCnt = None\n",
    "\n",
    "\t# loop over the contours\n",
    "\tfor c in cnts:\n",
    "\t\t# approximate the contour\n",
    "\t\tperi = cv2.arcLength(c, True)\n",
    "\t\tapprox = cv2.approxPolyDP(c, 0.02 * peri, True)\n",
    "\n",
    "\t\t# if our approximated contour has four points, then we can\n",
    "\t\t# assume we have found the outline of the puzzle\n",
    "\t\tif len(approx) == 4:\n",
    "\t\t\tpuzzleCnt = approx\n",
    "\t\t\tbreak\n",
    "\n",
    "\t# if the puzzle contour is empty then our script could not find\n",
    "\t# the outline of the sudoku puzzle so raise an error\n",
    "\tif puzzleCnt is None:\n",
    "\t\traise Exception((\"Could not find sudoku puzzle outline. \"\n",
    "\t\t\t\"Try debugging your thresholding and contour steps.\"))\n",
    "\n",
    "\t# apply a four point perspective transform to both the original\n",
    "\t# image and grayscale image to obtain a top-down birds eye view\n",
    "\t# of the puzzle\n",
    "\tpuzzle = four_point_transform(image, puzzleCnt.reshape(4, 2))\n",
    "\twarped = four_point_transform(gray, puzzleCnt.reshape(4, 2))\n",
    "\n",
    "\t# return a 2-tuple of puzzle in both RGB and grayscale\n",
    "\treturn (puzzle, warped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_digit(cell, debug=False):\n",
    "\t# apply automatic thresholding to the cell and then clear any\n",
    "\t# connected borders that touch the border of the cell\n",
    "\tthresh = cv2.threshold(cell, 0, 255,\n",
    "\t\tcv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]\n",
    "\tthresh = clear_border(thresh)\n",
    "\n",
    "\t# find contours in the thresholded cell\n",
    "\tcnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,\n",
    "\t\tcv2.CHAIN_APPROX_SIMPLE)\n",
    "\tcnts = imutils.grab_contours(cnts)\n",
    "\n",
    "\t# if no contours were found than this is an empty cell\n",
    "\tif len(cnts) == 0:\n",
    "\t\treturn None\n",
    "\n",
    "\t# otherwise, find the largest contour in the cell and create a\n",
    "\t# mask for the contour\n",
    "\tc = max(cnts, key=cv2.contourArea)\n",
    "\tmask = np.zeros(thresh.shape, dtype=\"uint8\")\n",
    "\tcv2.drawContours(mask, [c], -1, 255, -1)\n",
    "\n",
    "\t# compute the percentage of masked pixels relative to the total\n",
    "\t# area of the image\n",
    "\t(h, w) = thresh.shape\n",
    "\tpercentFilled = cv2.countNonZero(mask) / float(w * h)\n",
    "\n",
    "\t# if less than 3% of the mask is filled then we are looking at\n",
    "\t# noise and can safely ignore the contour\n",
    "\tif percentFilled < 0.03:\n",
    "\t\treturn None\n",
    "\n",
    "\t# apply the mask to the thresholded cell\n",
    "\tdigit = cv2.bitwise_and(thresh, thresh, mask=mask)\n",
    "\n",
    "\t# return the digit to the calling function\n",
    "\treturn digit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = load_model('./digit_weights.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.imread('./sudoku2.png')\n",
    "image = imutils.resize(image, width=600)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "(puzzleImage, warped) = find_puzzle(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "board = np.zeros((9, 9), dtype=\"int\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "stepX = warped.shape[1] // 9\n",
    "stepY = warped.shape[0] // 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "cellLocs = []\n",
    "\n",
    "# loop over the grid locations\n",
    "for y in range(0, 9):\n",
    "    # initialize the current list of cell locations\n",
    "    row = []\n",
    "\n",
    "    for x in range(0, 9):\n",
    "        # compute the starting and ending (x, y)-coordinates of the\n",
    "        # current cell\n",
    "        startX = x * stepX\n",
    "        startY = y * stepY\n",
    "        endX = (x + 1) * stepX\n",
    "        endY = (y + 1) * stepY\n",
    "\n",
    "        # add the (x, y)-coordinates to our cell locations list\n",
    "        row.append((startX, startY, endX, endY))\n",
    "\n",
    "        # crop the cell from the warped transform image and then\n",
    "        # extract the digit from the cell\n",
    "        cell = warped[startY:endY, startX:endX]\n",
    "        digit = extract_digit(cell)\n",
    "\n",
    "        # verify that the digit is not empty\n",
    "        if digit is not None:\n",
    "\n",
    "            # resize the cell to 28x28 pixels and then prepare the\n",
    "            # cell for classification\n",
    "            roi = cv2.resize(digit, (28, 28))\n",
    "            roi = roi.astype(\"float\") / 255.0\n",
    "            roi = img_to_array(roi)\n",
    "            roi = np.expand_dims(roi, axis=0)\n",
    "\n",
    "            # classify the digit and update the sudoku board with the\n",
    "            # prediction\n",
    "            pred = model.predict(roi).argmax(axis=1)[0]\n",
    "            board[y, x] = pred\n",
    "\n",
    "    # add the row to our cell locations\n",
    "    cellLocs.append(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+-------+-------+\n",
      "|     6 | 4 8 1 | 3     |\n",
      "|   2   |       |   4   |\n",
      "| 7     |       |     9 |\n",
      "+-------+-------+-------+\n",
      "| 8     |   9   |     4 |\n",
      "| 6     | 3 4 2 |     1 |\n",
      "| 5     |   6   |     2 |\n",
      "+-------+-------+-------+\n",
      "| 3     |       |     5 |\n",
      "|   9   |       |   7   |\n",
      "|     5 | 7 1 6 | 2     |\n",
      "+-------+-------+-------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "puzzle = Sudoku(3, 3, board=board.tolist())\n",
    "puzzle.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------------------\n",
      "9x9 (3x3) SUDOKU PUZZLE\n",
      "Difficulty: SOLVED\n",
      "---------------------------\n",
      "+-------+-------+-------+\n",
      "| 9 5 6 | 4 8 1 | 3 2 7 |\n",
      "| 1 2 3 | 6 7 9 | 5 4 8 |\n",
      "| 7 4 8 | 2 5 3 | 6 1 9 |\n",
      "+-------+-------+-------+\n",
      "| 8 3 2 | 1 9 5 | 7 6 4 |\n",
      "| 6 7 9 | 3 4 2 | 8 5 1 |\n",
      "| 5 1 4 | 8 6 7 | 9 3 2 |\n",
      "+-------+-------+-------+\n",
      "| 3 6 7 | 9 2 4 | 1 8 5 |\n",
      "| 2 9 1 | 5 3 8 | 4 7 6 |\n",
      "| 4 8 5 | 7 1 6 | 2 9 3 |\n",
      "+-------+-------+-------+\n",
      "\n",
      "        \n"
     ]
    }
   ],
   "source": [
    "solution = puzzle.solve()\n",
    "solution.show_full()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for (cellRow, boardRow) in zip(cellLocs, solution.board):\n",
    "\t# loop over individual cell in the row\n",
    "\tfor (box, digit) in zip(cellRow, boardRow):\n",
    "\t\t# unpack the cell coordinates\n",
    "\t\tstartX, startY, endX, endY = box\n",
    "\n",
    "\t\t# compute the coordinates of where the digit will be drawn\n",
    "\t\t# on the output puzzle image\n",
    "\t\ttextX = int((endX - startX) * 0.33)\n",
    "\t\ttextY = int((endY - startY) * -0.2)\n",
    "\t\ttextX += startX\n",
    "\t\ttextY += endY\n",
    "\n",
    "\t\t# draw the result digit on the sudoku puzzle image\n",
    "\t\tcv2.putText(puzzleImage, str(digit), (textX, textY),\n",
    "\t\t\tcv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 255), 2)\n",
    "\n",
    "# show the output image\n",
    "cv2.imshow(\"Sudoku Result\", puzzleImage)\n",
    "cv2.waitKey(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}