HandGestion.ipynb · gggliuye/Opencv_based_hand_detection

加入 Gitee

与超过 1200万开发者一起发现、参与优秀开源项目，私有仓库也完全免费：）

克隆/下载

HandGestion.ipynb 14.98 KB

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the version of opencv used is : 4.1.2\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "print(\"the version of opencv used is : \" + cv2.__version__)\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_sample_points_hand(image_ori):\n",
    "    cols = image_ori.shape[1]\n",
    "    rows = image_ori.shape[0]\n",
    "    sample_points = np.zeros((7, 2))\n",
    "    sample_points[0] = [cols/2, rows/4]\n",
    "    sample_points[1] = [cols*5/12, rows*5/12]\n",
    "    sample_points[2] = [cols*7/12, rows*5/12]\n",
    "    sample_points[3] = [cols/2, rows*7/12]\n",
    "    sample_points[4] = [cols/1.5, rows*7/12]\n",
    "    sample_points[5] = [cols*4/9, rows*3/4]\n",
    "    sample_points[6] = [cols*5/9, rows*3/4]\n",
    "    for i in range(7):\n",
    "        cv2.circle(image_ori, (int(sample_points[i][0]), int(sample_points[i][1])), 5, (0, 0, 255),2) \n",
    "   \n",
    "    avgHandColor = [];\n",
    "    for i in range(7):\n",
    "        avgHandColor.append(image_ori[int(sample_points[i][1]), int(sample_points[i][0]),:]);\n",
    "\n",
    "    return image_ori, avgHandColor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_sample_points_background(image_ori):\n",
    "    cols = image_ori.shape[1]\n",
    "    rows = image_ori.shape[0]\n",
    "    sample_points = np.zeros((7, 2))\n",
    "    sample_points[0] = [cols/6, rows/3]\n",
    "    sample_points[1] = [cols/6, rows*2/3]\n",
    "    sample_points[2] = [cols/2, rows/6]\n",
    "    sample_points[3] = [cols/2, rows/2]\n",
    "    sample_points[4] = [cols/2, rows*5/6]\n",
    "    sample_points[5] = [cols*5/6, rows/3]\n",
    "    sample_points[6] = [cols*5/6, rows*2/3]\n",
    "    for i in range(7):\n",
    "        cv2.circle(image_ori, (int(sample_points[i][0]), int(sample_points[i][1])), 5, (0, 0, 255),2) \n",
    "   \n",
    "    avgBackColor = [];\n",
    "    for i in range(7):\n",
    "        avgBackColor.append(image_ori[int(sample_points[i][1]), int(sample_points[i][0]),:]);\n",
    "\n",
    "    return image_ori, avgBackColor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# step 1. Extract back ground sample pixels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "background sample pixel get :\n",
      "[ 64 115 141]\n",
      "[ 50 120 136]\n",
      "[109 110 138]\n",
      "[ 81 112 141]\n",
      "[ 55 121 137]\n",
      "[ 82 112 145]\n",
      "[ 62 114 141]\n"
     ]
    }
   ],
   "source": [
    "# make sample background\n",
    "cap = cv2.VideoCapture(0)\n",
    "if not (cap.isOpened()):\n",
    "    print(\"Could not open video device\")\n",
    "else:\n",
    "    # Capture frame-by-frame\n",
    "    ret, frame = cap.read()\n",
    "\n",
    "    # Our operations on the frame come here\n",
    "    converted_image = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)\n",
    "    with_points, avg_back_color = make_sample_points_background(converted_image)\n",
    "\n",
    "    # Display the resulting frame\n",
    "    cv2.imshow('frame',converted_image)\n",
    "    cv2.waitKey(1)\n",
    "    print(\"background sample pixel get :\")\n",
    "    for i in range(len(avg_back_color)):\n",
    "        print(avg_back_color[i])\n",
    "\n",
    "# When everything done, release the capture\n",
    "cap.release()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# step 2. Extract hand sample pixels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "background sample pixel get :\n",
      "[114 141 149]\n",
      "[ 62 146 138]\n",
      "[100 145 145]\n",
      "[106 151 145]\n",
      "[ 80 141 149]\n",
      "[101 145 144]\n",
      "[ 89 143 148]\n"
     ]
    }
   ],
   "source": [
    "# make sample background\n",
    "cap = cv2.VideoCapture(0)\n",
    "if not (cap.isOpened()):\n",
    "    print(\"Could not open video device\")\n",
    "else:  \n",
    "    while(True):\n",
    "        # Capture frame-by-frame\n",
    "        ret, frame = cap.read()\n",
    "\n",
    "        # Our operations on the frame come here\n",
    "        converted_image = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)\n",
    "        _, avg_hand_color = make_sample_points_hand(converted_image)\n",
    "\n",
    "        # Display the resulting frame\n",
    "        cv2.imshow('frame',converted_image)\n",
    "        if cv2.waitKey(1) & 0xFF == ord('q'):\n",
    "            break\n",
    "\n",
    "    # When everything done, release the capture\n",
    "    cap.release()\n",
    "    cv2.destroyAllWindows()\n",
    "    print(\"background sample pixel get :\")\n",
    "    for i in range(len(avg_hand_color)):\n",
    "        print(avg_hand_color[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions for detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "lab_space_range_hand = np.array([80,10,10])\n",
    "def make_mask_hand(image_input):\n",
    "    image_thersholds = []\n",
    "    for i in range(7):\n",
    "        lower_bound = avg_hand_color[i] - lab_space_range_hand\n",
    "        upper_bound = avg_hand_color[i] + lab_space_range_hand\n",
    "        frame_threshold = cv2.inRange(image_input, lower_bound, upper_bound)\n",
    "        image_thersholds.append(frame_threshold)\n",
    "    \n",
    "    mask_image = np.zeros((480,640),  dtype=np.uint8)\n",
    "    for i in range(7):\n",
    "        mask_image = mask_image + image_thersholds[i]\n",
    "        \n",
    "    mask_image = cv2.medianBlur(mask_image,3)\n",
    "    \n",
    "    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))\n",
    "    #mask_image = cv2.erode(mask_image,kernel,iterations=2)\n",
    "    #mask_image = cv2.dilate(mask_image,kernel,iterations=2)\n",
    "    \n",
    "    return mask_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "lab_space_range_back = np.array([50,3,3])\n",
    "def make_mask_background(image_input):\n",
    "    image_thersholds = []\n",
    "    for i in range(7):\n",
    "        lower_bound = avg_back_color[i] - lab_space_range_back\n",
    "        upper_bound = avg_back_color[i] + lab_space_range_back\n",
    "        frame_threshold = cv2.inRange(image_input, lower_bound, upper_bound)\n",
    "        image_thersholds.append(frame_threshold)\n",
    "    \n",
    "    mask_image = np.zeros((480,640),  dtype=np.uint8)\n",
    "    for i in range(7):\n",
    "        mask_image = mask_image + image_thersholds[i]\n",
    "        \n",
    "    cv2.bitwise_not(mask_image, mask_image);\n",
    "    mask_image = cv2.medianBlur(mask_image,3)\n",
    "    \n",
    "    return mask_image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_largest_contour(contours):\n",
    "    max_id = -1\n",
    "    count_num = -1\n",
    "    for i in range(len(contours)):\n",
    "        count_t = contours[i].size\n",
    "        if(count_t > count_num):\n",
    "            count_num = count_t\n",
    "            max_id = i\n",
    "    return max_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def average_points(points):\n",
    "    summary_x = 0\n",
    "    summary_y = 0\n",
    "    length = len(points)\n",
    "    for i in range(length):\n",
    "        summary_x = summary_x + points[i][0]\n",
    "        summary_y = summary_y + points[i][1]\n",
    "    summary_x = summary_x / length\n",
    "    summary_y = summary_y / length\n",
    "    return tuple([int(summary_x), int(summary_y)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_hand_cycle(far_points):\n",
    "    summary_x = 0\n",
    "    summary_y = 0\n",
    "    length = len(far_points)\n",
    "    for i in range(length):\n",
    "        summary_x = summary_x + far_points[i][0]\n",
    "        summary_y = summary_y + far_points[i][1]\n",
    "    summary_x = summary_x / length\n",
    "    summary_y = summary_y / length\n",
    "    \n",
    "    radius = 0\n",
    "    for i in range(length):\n",
    "        dx = far_points[i][0] - summary_x\n",
    "        dy = far_points[i][1] - summary_y\n",
    "        radius = radius + np.sqrt(dx*dx + dy*dy)\n",
    "    radius = radius / length\n",
    "    \n",
    "    return tuple([int(summary_x), int(summary_y)]), int(radius)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_hand(image_ori, max_contour):\n",
    "    cnt = max_contour\n",
    "    hull = cv2.convexHull(max_contour,returnPoints = False)\n",
    "    defects = cv2.convexityDefects(max_contour,hull)\n",
    "    if(defects is None):\n",
    "        return\n",
    "    \n",
    "    pts_inbetween = []\n",
    "    far_points = []\n",
    "    finger_points = []\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(image_ori,start,end,[0,255,0],2)\n",
    "        if(d > 1000):\n",
    "            cv2.circle(image_ori,far,5,[0,0,255],-1)\n",
    "            far_points.append(far)\n",
    "            if(len(pts_inbetween) > 0):\n",
    "                finger_point = average_points(pts_inbetween)\n",
    "                finger_points.append(finger_point)\n",
    "                cv2.circle(image_ori,finger_point,5,[255,0,255],-1)\n",
    "                pts_inbetween = []\n",
    "        else:\n",
    "            pts_inbetween.append(start)\n",
    "    \n",
    "    if(len(far_points) > 0):\n",
    "        cycle_center, radius = find_hand_cycle(far_points)\n",
    "        for i in range(len(finger_points)):\n",
    "            cv2.line(image_ori, cycle_center, finger_points[i], (0,0,255), 2)\n",
    "        #cv2.circle(image_ori,cycle_center,5,[0,255,255],radius)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#lab_space_range = np.array([50,10,10])\n",
    "def image_processing(image_ori):\n",
    "    converted_image = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)\n",
    "    # print(converted_image.shape) # is (480, 640, 3)\n",
    "        \n",
    "    mask_hand = make_mask_hand(converted_image)\n",
    "    mask_back = make_mask_background(converted_image)\n",
    "    \n",
    "    hand_mask = cv2.bitwise_and(mask_hand,mask_hand,mask=mask_back)\n",
    "    \n",
    "    contours, _ = cv2.findContours(hand_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n",
    "    max_id = find_largest_contour(contours)\n",
    "    \n",
    "    if(max_id > -1):\n",
    "        cv2.drawContours(image_ori,contours[max_id],-1,(0,255,0),2)\n",
    "        hull = cv2.convexHull(contours[max_id])\n",
    "        length = len(hull)\n",
    "        #for i in range(len(hull)):\n",
    "            #cv2.line(image_ori, tuple(hull[i][0]), tuple(hull[(i+1)%length][0]), (0,0,255), 2)\n",
    "            #cv2.circle(image_ori, tuple(hull[i][0]), 5, (255, 0, 0),5) \n",
    "        \n",
    "        find_hand(image_ori, contours[max_id])\n",
    "        #approx = cv2.approxPolyDP(contours[max_id], 2, True)\n",
    "        #cv2.polylines(image_ori, [approx], True, (0, 255, 255), 2)\n",
    "    \n",
    "    \n",
    "    #temp = np.ones(image_ori.shape,np.uint8)*255\n",
    "    #cv2.drawContours(image_ori,contours,-1,(0,255,0),3)\n",
    "    \n",
    "    return image_ori"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# step 3. Process New Frames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "cap = cv2.VideoCapture(0)\n",
    "if not (cap.isOpened()):\n",
    "    print(\"Could not open video device\")\n",
    "\n",
    "while(True):\n",
    "    # Capture frame-by-frame\n",
    "    ret, frame = cap.read()\n",
    "\n",
    "    # Our operations on the frame come here\n",
    "    processed_image = image_processing(frame)\n",
    "\n",
    "    # Display the resulting frame\n",
    "    cv2.imshow('frame',processed_image)\n",
    "    if cv2.waitKey(1) & 0xFF == ord('q'):\n",
    "        break\n",
    "\n",
    "# When everything done, release the capture\n",
    "cap.release()\n",
    "cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# step 3.1 Process New Frames And Save video/GIF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import imageio\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "fps = 30\n",
    "size = (640, 480)\n",
    "video = cv2.VideoWriter(\"VideoTest.avi\", cv2.VideoWriter_fourcc('I', '4', '2', '0'), fps, size)\n",
    "\n",
    "cap = cv2.VideoCapture(0)\n",
    "gif_buff = []\n",
    "if not (cap.isOpened()):\n",
    "    print(\"Could not open video device\")\n",
    "\n",
    "while(True):\n",
    "    # Capture frame-by-frame\n",
    "    ret, frame = cap.read()\n",
    "\n",
    "    # Our operations on the frame come here\n",
    "    processed_image = image_processing(frame)\n",
    "\n",
    "    # Display the resulting frame\n",
    "    cv2.imshow('frame',processed_image)\n",
    "    video.write(processed_image)\n",
    "    gif_buff.append(processed_image)\n",
    "    if cv2.waitKey(1) & 0xFF == ord('q'):\n",
    "        break\n",
    "\n",
    "# When everything done, release the capture\n",
    "cap.release()\n",
    "cv2.destroyAllWindows()\n",
    "\n",
    "video.release()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inv_fps = 1 / fps\n",
    "gif = imageio.mimsave('hand_detection.gif',gif_buff,'GIF',duration=inv_fps)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python3 tf15",
   "language": "python",
   "name": "tf15"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}

一键复制编辑原始数据按行查看历史

提交于 2020-05-22 10:09 . init files

马建仓 AI 助手

尝试更多

代码解读

代码找茬

代码优化

Python

https://gitee.com/gggliuye/Opencv_based_hand_detection.git

git@gitee.com:gggliuye/Opencv_based_hand_detection.git

gggliuye

Opencv_based_hand_detection

master

gggliuye/Opencv_based_hand_detection

简介

发行版

贡献者

近期动态

gggliuye/Opencv_based_hand_detection .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

gggliuye/Opencv_based_hand_detection