roi_extract.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 2,
 "metadata": {
  "language_info": {
   "name": "python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "version": "3.7.2-final"
  },
  "orig_nbformat": 2,
  "file_extension": ".py",
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3,
  "kernelspec": {
   "name": "python37264bitenvvirtualenv202d67ff0f384954aa8f675575565d1a",
   "display_name": "Python 3.7.2 64-bit ('env': virtualenv)"
  }
 },
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import math\n",
    "import random\n",
    "img = cv2.imread('data\\XY_20090222_F1_A_F_F_E2_1F_E2_E2_E2_1E_E1_E2_E_yiyanzhe.jpg')\n",
    "\n",
    "# 配置常量\n",
    "PROCESS_OUTPUT_DIR = 'process_output/'\n",
    "LOG_PROCESS_IMG = True\n",
    "## 阈值\n",
    "BINARY_THRESH = 20 # 二值化\n",
    "K_THRESH = (-2, 2)  # 选取直线斜率\n",
    "PARALLEL_THRESH = 10 # 平行线斜率判定\n",
    "LINE_LEN_THRESH = 50 # 直线长度\n",
    "CLOSER_PARALLEL_LINE_THRESH = 50 # 线段端点距离极差"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 图像处理\n",
    "template = cv2.imread('data/L.png')\n",
    "w,h = template.shape[:-1]\n",
    "res = cv2.matchTemplate(img, template, cv2.TM_CCOEFF)\n",
    "min_val,max_val,min_loc,max_loc = cv2.minMaxLoc(res)\n",
    "top_left = max_loc\n",
    "bottom_right = (top_left[0]+w,top_left[1]+h)\n",
    "cv2.rectangle(img, top_left, bottom_right, 255,2)\n",
    "dump_process_img('handled_raw', img)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper\n",
    "dump_process_img = lambda name, img: cv2.imwrite(PROCESS_OUTPUT_DIR + name + '.jpg', img) if LOG_PROCESS_IMG else ''\n",
    "def print_lines(img, name, lines, color = 255):\n",
    "    for line in lines:\n",
    "        x1, y1, x2, y2 = line[0]\n",
    "        cv2.line(img, (x1, y1), (x2, y2), color, 2)\n",
    "    dump_process_img(name, img)\n",
    "def cal_line_len(x1, y1, x2, y2):\n",
    "    return math.sqrt(math.pow(x1 - x2, 2) + math.pow(y1 - y2, 2))\n",
    "\n",
    "# 基础方法\n",
    "# 转灰度图\n",
    "def cvt_gray(img):\n",
    "    return cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)\n",
    "# 二值化\n",
    "def cvt_binary(img):\n",
    "    ret, binary_img = cv2.threshold(gray_image, BINARY_THRESH, 255, cv2.THRESH_BINARY)\n",
    "    return binary_img\n",
    "# 降噪 中值滤波\n",
    "def blur(img):\n",
    "    return cv2.medianBlur(img, 5)\n",
    "# 边缘检测\n",
    "def edge_detection(binary_img):\n",
    "    return cv2.Canny(binary_img, 20, 240)\n",
    "# 直线检测\n",
    "def line_detection(edges):\n",
    "    return cv2.HoughLinesP(edges, 1, np.pi/180, 100, maxLineGap=25)\n",
    "# 计算斜率\n",
    "def k_of_lines(lines):\n",
    "    k = []\n",
    "    for line in lines:\n",
    "        x1, y1, x2, y2 = line[0]\n",
    "        k.append((y1 - y2) / (x1 - x2))\n",
    "    return k\n",
    "# 得到的平行线可能是同一侧的，判断算法：\n",
    "#   - 计算端点两距离得到四个值\n",
    "#   - if 极差超出阈值说明线段靠近\n",
    "def judge_line_distance (l1, l2):\n",
    "    xa, ya, xb, yb = l1[0]\n",
    "    xc, yc, xd, yd = l1[0]\n",
    "    d1 = cal_line_len(xa, ya, xc, yc)\n",
    "    d2 = cal_line_len(xa, ya, xd, yd)\n",
    "    d3 = cal_line_len(xb, yb, xc, yc)\n",
    "    d4 = cal_line_len(xb, yb, xd, yd)\n",
    "    print(max(d1, d2, d3, d4) - min(d1, d2, d3, d4))\n",
    "    return max(d1, d2, d3, d4) - min(d1, d2, d3, d4) <= CLOSER_PARALLEL_LINE_THRESH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "gray_image = cvt_gray(img)\n",
    "dump_process_img('gray', gray_image)\n",
    "\n",
    "binary_img = cvt_binary(gray_image)\n",
    "dump_process_img('row_binary', binary_img)\n",
    "\n",
    "binary_img = blur(binary_img)\n",
    "dump_process_img('blured_binary', binary_img)\n",
    "\n",
    "edges = edge_detection(binary_img)\n",
    "dump_process_img('edges', edges)\n",
    "\n",
    "lines = line_detection(edges)\n",
    "print_lines(np.zeros(edges.shape), 'lines',lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 过滤无效直线\n",
    "k = k_of_lines(lines)\n",
    "\n",
    "# 裁剪比例尺区域\n",
    "k_0_lines = []\n",
    "for i in range(len(k)):\n",
    "    if abs(k[i]) <= 0.05:\n",
    "        k_0_lines.append(lines[i])\n",
    "\n",
    "x_min = 999999999\n",
    "for line in k_0_lines:\n",
    "    x1, y1, x2, y2 = line[0]\n",
    "    if min(x1, x2) < x_min:\n",
    "        x_min = min(x1, x2)\n",
    "lines_idx_to_del = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(lines)):\n",
    "    x1, y1, x2, y2 = lines[i][0]\n",
    "    mid_height = edges.shape[0] * 0.66\n",
    "    if x1 >= x_min or \\\n",
    "        x2 >= x_min or \\\n",
    "        y1 <= mid_height or \\\n",
    "        y2 <= mid_height or \\\n",
    "        x1 == x2 or \\\n",
    "        K_THRESH[0] < k[i] < K_THRESH[1] or \\\n",
    "        cal_line_len(x1, y1, x2, y2) < LINE_LEN_THRESH:\n",
    "        lines_idx_to_del.append(i)\n",
    "lines = np.delete(lines, lines_idx_to_del, axis=0)\n",
    "k = np.delete(k, lines_idx_to_del)\n",
    "print_lines(np.zeros(edges.shape), 'filtered_lines',lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 找平行线\n",
    "parallel_lines_idx = []\n",
    "y_max = edges.shape[1]\n",
    "for k1_idx in range(len(k)):\n",
    "    for k2_idx in range(k1_idx + 1, len(k)):\n",
    "        if abs(k[k1_idx] - k[k2_idx]) <= PARALLEL_THRESH:\n",
    "            parallel_lines_idx.append((k1_idx, k2_idx, abs(k[k1_idx] - k[k2_idx])))\n",
    "\n",
    "\n",
    "# 先随便选一个，后面优化再处理，可能出现选中相邻的两条线\n",
    "chosen_line_pair = random.choice(parallel_lines_idx)\n",
    "\n",
    "# 绘制平行线判定结果\n",
    "empty = np.zeros(edges.shape)\n",
    "l1 = lines[chosen_line_pair[0]]\n",
    "l2 = lines[chosen_line_pair[1]]\n",
    "x1, y1, x2, y2 = l1[0]\n",
    "cv2.line(empty, (x1, y1), (x2, y2), 255, 2)\n",
    "x1, y1, x2, y2 = l2[0]\n",
    "cv2.line(empty, (x1, y1), (x2, y2), 255, 2)\n",
    "dump_process_img('test', empty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 旋转\n",
    "(h, w) = edges.shape[:2]\n",
    "p = (w // 2, h // 2)\n",
    "\n",
    "angle = math.atan(k[chosen_line_pair[0]]) * 180 / math.pi + 90\n",
    "M = cv2.getRotationMatrix2D(p, angle, 1.0)\n",
    "rotated = cv2.warpAffine(edges[:, :x_min], M, (w, h))\n",
    "rotated_raw = cv2.warpAffine(img, M, (w, h))\n",
    "rotated_bin = cv2.warpAffine(binary_img, M, (w, h))\n",
    "dump_process_img('rotated', rotated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "811 927\n"
    },
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 找中点\n",
    "M = cv2.moments(rotated)\n",
    "cX = int(M[\"m10\"] / M[\"m00\"])\n",
    "cY = int(M[\"m01\"] / M[\"m00\"])\n",
    "print(cX, cY)\n",
    "cv2.circle(rotated_raw, (cX, cY), 5, (255, 0, 0), -1)\n",
    "dump_process_img('mid-point', rotated_raw)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "array([[0, 0, 0, ..., 0, 0, 0],\n       [0, 0, 0, ..., 0, 0, 0],\n       [0, 0, 0, ..., 0, 0, 0],\n       ...,\n       [0, 0, 0, ..., 0, 0, 0],\n       [0, 0, 0, ..., 0, 0, 0],\n       [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)"
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "True"
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 找凹点\n",
    "contours, hierarchy = cv2.findContours(rotated,2,1)\n",
    "cnt = []\n",
    "for c in contours:\n",
    "    cnt.extend(c)\n",
    "cnt = np.array(cnt)\n",
    "hull = cv2.convexHull(cnt, returnPoints = False)\n",
    "defects = cv2.convexityDefects(cnt, hull)\n",
    "for i in range(defects.shape[0]):\n",
    "    s,e,f,d = defects[i,0] \n",
    "    start = tuple(cnt[s][0]) \n",
    "    end = tuple(cnt[e][0]) \n",
    "    far = tuple(cnt[f][0]) \n",
    "    cv2.line(rotated_raw, start,end,[0,255,0],2) \n",
    "    cv2.circle(rotated_raw, far,5,[0,0,255],-1)\n",
    "dump_process_img('hull', rotated_raw)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "length = len(hull)\n",
    "for i in range(len(hull)):\n",
    "    cv2.line(img, tuple(hull[i][0]), tuple(hull[(i+1)%length][0]), (0,255,0), 2)\n"
   ]
  }
 ]
}