canny_2.0.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from skimage import io,color\n",
    "from scipy import signal,ndimage\n",
    "from matplotlib import pyplot as plt\n",
    "import queue\n",
    "from scipy.ndimage import gaussian_filter\n",
    "from PIL import Image\n",
    "import glob\n",
    "from numpy.lib.stride_tricks import as_strided\n",
    "\n",
    "q = queue.SimpleQueue()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Gaussian filter\n",
    "def Gaussian(size, sigma): #5x5\n",
    "    size = int(size) //2\n",
    "    x, y = np.mgrid[-size:size+1, -size:size+1]\n",
    "    normalization = 1/(2.0*np.pi*sigma**2)\n",
    "    return np.exp(-((x**2+y**2))/2)*normalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sobel filter\n",
    "def sobel_filters(img):\n",
    "    # sobel filter init\n",
    "    sobel_x = np.array([[1, 0, -1],\n",
    "                        [2, 0, -2],\n",
    "                        [1, 0, -1]])\n",
    "    sobel_y = sobel_x.ravel(order='F').reshape((3,3))\n",
    "\n",
    "    \n",
    "    ## sobel filtering\n",
    "    sobel_x_img = signal.convolve2d(img,sobel_x, boundary = 'symm')\n",
    "    sobel_y_img = signal.convolve2d(img,sobel_y, boundary = 'symm')\n",
    "    \n",
    "    sobel_img = np.sqrt(np.square(sobel_x_img) + np.square(sobel_y_img))\n",
    "    sobel_img = sobel_img / sobel_img.max() * 255\n",
    "    sobel_direc = np.arctan2(sobel_x_img, sobel_y_img)\n",
    "\n",
    "#     print(sobel_img)\n",
    "#     print(sobel_direc)\n",
    "#     print('sobel_img', sobel_img.shape, '\\nsobel_direc',sobel_direc.shape)\n",
    "\n",
    "    return sobel_img,sobel_direc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 0 ns\n"
     ]
    }
   ],
   "source": [
    "# Non Maximum suppression\n",
    "%time\n",
    "def non_max_sup(box,direc):\n",
    "    \n",
    "    y_len, x_len = box.shape\n",
    "    \n",
    "    # return array\n",
    "    keep = np.zeros((y_len-2)*(x_len-2))\n",
    "    \n",
    "    frame_1 = np.zeros((3,3))\n",
    "    frame_2 = np.zeros(3)\n",
    "        \n",
    "    \n",
    "    s = np.array([-np.pi, -np.pi*7/8, -np.pi*5/8, -np.pi*3/8, -np.pi/8, np.pi/8, np.pi*3/8, np.pi*5/8, np.pi*7/8, np.pi])\n",
    "    \n",
    "    sector = np.digitize(direc, s)\n",
    "    sector[(sector == 1) | (sector == 5) | (sector == 9)] = 0\n",
    "    sector[(sector == 2)| (sector == 6)] = 1\n",
    "    sector[(sector == 3) | (sector == 7)] = 2\n",
    "    sector[(sector == 4) | (sector == 8)] = 3\n",
    "\n",
    "    sectoring = sector[1:-1,1:-1]\n",
    "    sectoring = sectoring.flatten()\n",
    "      \n",
    "    expanded_input = as_strided(\n",
    "        box,\n",
    "        shape=(\n",
    "            box.shape[0] - frame_1.shape[0] + 1,  # The feature map is a few pixels smaller than the input\n",
    "            box.shape[1] - frame_1.shape[1] + 1,\n",
    "            3,3\n",
    "        ),\n",
    "        strides=(\n",
    "            box.strides[0],\n",
    "            box.strides[1],\n",
    "            box.strides[0],  # When we move one step in the 3rd dimension, we should move one step in the original data too\n",
    "            box.strides[1],\n",
    "        ),\n",
    "        writeable=False,  # totally use this to avoid writing to memory in weird places\n",
    "    )\n",
    "    \n",
    "    a = expanded_input.reshape((y_len-2)*(x_len-2),9)\n",
    "    angle = np.array([  [False, True, False, False, True, False, False, True, False],\n",
    "                        [True, False, False, False, True, False, False, False, True],\n",
    "                        [False, False, False, True, True, True, False, False, False],\n",
    "                        [False, False, True, False, True, False, True, False, False] ])\n",
    "    \n",
    "    a[np.where(sectoring == 0)] = a[np.where(sectoring == 0)]*angle[0]\n",
    "    a[np.where(sectoring == 1)] = a[np.where(sectoring == 1)]*angle[1]\n",
    "    a[np.where(sectoring == 2)] = a[np.where(sectoring == 2)]*angle[2]\n",
    "    a[np.where(sectoring == 3)] = a[np.where(sectoring == 3)]*angle[3]\n",
    "    \n",
    "    max_position = np.argmax(a, axis=1).reshape((y_len-2)*(x_len-2),1)\n",
    "    a[np.where(max_position != 4)[0],4] = a[np.where(max_position != 4)[0],4]*0\n",
    "    \n",
    "    keep = a[:,4].reshape(y_len-2,x_len-2)\n",
    "            \n",
    "    return keep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# double threshold\n",
    "def threshold(img, high_threshold, low_threshold, strong_pixel, weak_pixel):#strong, weak, non-relevant\n",
    "    \n",
    "    m,n=img.shape\n",
    "    img[img>=high_threshold] = strong_pixel\n",
    "    img[img<low_threshold] = 0\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replay(box, keep, max_var):\n",
    "    \n",
    "    y_len, x_len = box.shape\n",
    "    \n",
    "    frame = np.zeros((3, 3))\n",
    "    \n",
    "    while not q.empty():\n",
    "        i,j = q.get()\n",
    "        \n",
    "        if box[i,j] != max_var :\n",
    "            \n",
    "            box[i,j] = max_var\n",
    "            keep[i-1,j-1] = max_var\n",
    "            \n",
    "            frame[:] = box[i-1:i+2, j-1:j+2]\n",
    "            \n",
    "            for n in range(0,3):\n",
    "                for m in range(0,3):\n",
    "                    if frame[n,m] > 0 and frame[n,m] < max_var:\n",
    "                        q.put((i+n-1,j+m-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hysteresis(box, max_var):\n",
    "    \n",
    "    y_len, x_len = box.shape\n",
    "\n",
    "    box_2 = np.zeros((y_len + 2, x_len + 2))\n",
    "    box_2[1:-1, 1:-1] = box[:]\n",
    "    \n",
    "    keep = np.zeros((y_len,x_len))\n",
    "    \n",
    "    frame = np.zeros((3, 3))\n",
    "    frame_2 = np.zeros(9)\n",
    "    \n",
    "    for i in range(0, y_len):\n",
    "        for j in range(0, x_len):\n",
    "            \n",
    "            if box_2[i+1, j+1] == max_var :\n",
    "                \n",
    "                keep[i,j] = max_var\n",
    "                \n",
    "                frame = box_2[i:i+3, j:j+3]\n",
    "                \n",
    "                for n in range(0,3):\n",
    "                    for m in range(0,3):\n",
    "                        if frame[n,m] > 0 and frame[n,m] < max_var:\n",
    "                            q.put((i+n,j+m))\n",
    "            \n",
    "            \n",
    "                while not q.empty():\n",
    "                    replay(box_2, keep, max_var)\n",
    "                        \n",
    "    return keep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_image(img):\n",
    "    plt.figure(figsize=(8,16))\n",
    "    if img.shape[0] == 3:\n",
    "        img=img.transpose(1,2,0)\n",
    "    plt.subplot(2,2,1)\n",
    "    plt.imshow(img,cmap='gray')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Canny_detector(img):\n",
    "    gaussian_size=5\n",
    "    sigma = 5\n",
    "    high_thres=50\n",
    "    low_thres=30\n",
    "    strong_pixel=255\n",
    "    weak_pixel=100\n",
    "    \n",
    "    #sigma= int(input(\"Input sigma::\"))\n",
    "    #high_thres, low_thres = map(float, input(\"Input high_thres, low_threshold::\").split())\n",
    "    #print(sigma, high_thres, low_thres)\n",
    "    \n",
    "    smoothed_image1=signal.convolve2d(img,Gaussian(gaussian_size, sigma),mode='same',boundary = 'symm')\n",
    "    \n",
    "    gradient, theta=sobel_filters(smoothed_image1)\n",
    "    nonMax_Img= non_max_sup(gradient, theta)\n",
    "    # show_image(nonMax_Img)\n",
    "    \n",
    "    threshold_Img=threshold(nonMax_Img, high_thres, low_thres, strong_pixel, weak_pixel)    \n",
    "    img_final=hysteresis(threshold_Img, strong_pixel)\n",
    "    \n",
    "    return img_final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x1152 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 50 30\n",
      "Time == 0.46\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x1152 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import time\n",
    "import cv2 as cv\n",
    "start=time.time()\n",
    "test_img = 'data/model02.jpg'\n",
    "img = io.imread(test_img,True)\n",
    "show_image(img)\n",
    "img=Canny_detector(img)\n",
    "\n",
    "end = time.time()\n",
    "print(\"Time == {:.2f}\".format(end-start))\n",
    "show_image(img)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.asarray([[1,2,3],[-1,-1,-1]])\n",
    "b= np.array([[0,1,2],[2,3,1]])\n",
    "a[ (b==1) 각도에 맞게 \n",
    "  슬라이싱을 해서 그 3가지 값을 비교해서 그중 가장 크면 ] = 남겨\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=np.arange(10).reshape((2,5))\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "(2,)\n",
      "(2, 3, 3)\n",
      "(20, 4)\n",
      "(4,)\n",
      "(20, 4, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[[0, 1, 2],\n",
       "        [1, 2, 3],\n",
       "        [2, 3, 4]],\n",
       "\n",
       "       [[5, 6, 7],\n",
       "        [6, 7, 8],\n",
       "        [7, 8, 9]]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def rolling_window(a, window):\n",
    "    shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)# 2+3,3\n",
    "    print(a.shape[-1])# 5\n",
    "    print(a.shape[:-1])# (2,)\n",
    "    print(shape)# (2,3,3)\n",
    "    \n",
    "    strides = a.strides + (a.strides[-1],)\n",
    "    \n",
    "    print(a.strides)\n",
    "    print((a.strides[-1],))\n",
    "    print(strides)\n",
    "    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)\n",
    "\n",
    "rolling_window(x,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time == 0.2455148696899414\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 101.,  102.,  103., ...,  196.,  197.,  198.],\n",
       "       [ 201.,  202.,  203., ...,  296.,  297.,  298.],\n",
       "       [ 301.,  302.,  303., ...,  396.,  397.,  398.],\n",
       "       ...,\n",
       "       [9601., 9602., 9603., ..., 9696., 9697., 9698.],\n",
       "       [9701., 9702., 9703., ..., 9796., 9797., 9798.],\n",
       "       [9801., 9802., 9803., ..., 9896., 9897., 9898.]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "inputs = np.arange(10000).reshape(100, 100)\n",
    "kernel = np.asarray([[0,0,0],\n",
    "                    [0,1,0],\n",
    "                    [0,0,0]])\n",
    "\n",
    "\n",
    "feature_map = np.zeros(\n",
    "   (inputs.shape[0] - kernel.shape[0] + 1,\n",
    "    inputs.shape[1] - kernel.shape[1] + 1,\n",
    "))\n",
    "\n",
    "start=time.time()\n",
    "\n",
    "for x in range(inputs.shape[0] - kernel.shape[0] + 1):\n",
    "    for y in range(inputs.shape[1] - kernel.shape[1] + 1):\n",
    "        for i in range(kernel.shape[0]):\n",
    "            for j in range(kernel.shape[1]):\n",
    "                feature_map[x][y] += inputs[x + i][y + j] * kernel[i][j]\n",
    "                \n",
    "print(\"time == {}\".format((time.time()-start)))\n",
    "feature_map                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time == 0.000997781753540039\n",
      "[[ 101  102  103 ...  196  197  198]\n",
      " [ 201  202  203 ...  296  297  298]\n",
      " [ 301  302  303 ...  396  397  398]\n",
      " ...\n",
      " [9601 9602 9603 ... 9696 9697 9698]\n",
      " [9701 9702 9703 ... 9796 9797 9798]\n",
      " [9801 9802 9803 ... 9896 9897 9898]]\n"
     ]
    }
   ],
   "source": [
    "from numpy.lib.stride_tricks import as_strided\n",
    "\n",
    "\n",
    "input = np.arange(10000).reshape(100, 100)\n",
    "kernel = np.asarray([[0,0,0],\n",
    "                    [0,1,0],\n",
    "                    [0,0,0]])\n",
    "\n",
    "start=time.time()\n",
    "expanded_input = as_strided(\n",
    "    input,\n",
    "    shape=(\n",
    "        input.shape[0] - kernel.shape[0] + 1,  # The feature map is a few pixels smaller than the input\n",
    "        input.shape[1] - kernel.shape[1] + 1,\n",
    "        kernel.shape[0],\n",
    "        kernel.shape[1],\n",
    "    ),\n",
    "    strides=(\n",
    "        input.strides[0],\n",
    "        input.strides[1],\n",
    "        input.strides[0],  # When we move one step in the 3rd dimension, we should move one step in the original data too\n",
    "        input.strides[1],\n",
    "    ),\n",
    "    writeable=False,  # totally use this to avoid writing to memory in weird places\n",
    ")\n",
    "#expanded_input\n",
    "\n",
    "feature_map = np.einsum('xyij,ij->xy',expanded_input,kernel,)\n",
    "print(\"time == {}\".format((time.time()-start)))\n",
    "print(feature_map)\n",
    "#np.mean(expanded_input,-1)"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}