grasp_detection_object_at_centre.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "optimum-leonard",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1\n",
    "import numpy as np\n",
    "import cv2\n",
    "\n",
    "green = (0,255,0)\n",
    "red = (0,0,255)\n",
    "white = (255,255,255)\n",
    "fonts = cv2.FONT_HERSHEY_COMPLEX\n",
    "cap = cv2.VideoCapture(0)\n",
    "\n",
    "###################################################################\n",
    "\n",
    "# 2. size of the frame\n",
    "width = 960\n",
    "height= 720\n",
    "cap.set(3,height)\n",
    "cap.set(4,width)\n",
    "\n",
    "###################################################################\n",
    "\n",
    "def empty(a):\n",
    "    pass\n",
    "\n",
    "###################################################################\n",
    "\n",
    "# 5. windows and trackbars\n",
    "cv2.namedWindow(\"Parameters\")\n",
    "cv2.createTrackbar(\"Threshold1\",\"Parameters\",70,255,empty)\n",
    "cv2.createTrackbar(\"Threshold2\",\"Parameters\",70,255,empty)\n",
    "cv2.createTrackbar(\"Area\",\"Parameters\",1000,10000,empty)\n",
    "\n",
    "###################################################################\n",
    "\n",
    "# 8. find contours function\n",
    "def getContours(img,imgContour):\n",
    "    \n",
    "# 9. arguments: image, contour retrieval mode, contour approximation method\n",
    "# outputs the contours and hierarchy\n",
    "# Contours is a Python list of all the contours in the image\n",
    "# Each contour is a Numpy array of (x,y) coordinates of boundary points of the object\n",
    "    contours, hierarchy = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)\n",
    "# 10    \n",
    "    for cnt in contours:\n",
    "# 11        \n",
    "        area = cv2.contourArea(cnt)\n",
    "        areaMin = cv2.getTrackbarPos(\"Area\", \"Parameters\")        \n",
    "        if area > areaMin:\n",
    "#             cv2.drawContours(imgContour,cnt,-1,red,7)\n",
    "            peri = cv2.arcLength(cnt, True)\n",
    "    \n",
    "# 12. approximate the shape of polygonal curves to the specified precision\n",
    "            approx = cv2.approxPolyDP(cnt, 0.02 * peri, True)\n",
    "#             print(len(approx))\n",
    "\n",
    "# 13. coordinates of top-left corner, width, height\n",
    "            x,y,w,h = cv2.boundingRect(approx)\n",
    "    \n",
    "# for central coordinates\n",
    "            if(x+w > 400 and 400 > x and y+h > 285 and 285 > y):\n",
    "# draw rectangle\n",
    "                cv2.rectangle(imgContour,(x,y),(x+w,y+h),green,3)\n",
    "                \n",
    "#                 cv2.putText(imgContour,\"Points: \" + str(len(approx)),(x+w+20,y+20),fonts,0.7,green,2)\n",
    "#                 cv2.putText(imgContour,\"Height: \" + str(int(h)),(x+w+20,y),fonts,0.7,green,2)\n",
    "#                 cv2.putText(imgContour,\"Width: \" + str(int(w)),(x+w+20,y+25),fonts,0.7,green,2)\n",
    "#                 cv2.putText(imgContour,\"Aspect: \" + str(round((h/w),1)),(x+w+20,y+25),fonts,0.7,green,2)\n",
    "#                 cv2.putText(imgContour,\"Distance: \" + str(int(distance)),(x+w+20,y+25),fonts,0.7,green,2)\n",
    "#                 cv2.putText(imgContour,\"Area: \" + str(int(area)),(x+w+20,y+50),fonts,0.7,green,2)\n",
    "\n",
    "                if(area < 8300):\n",
    "                    cv2.putText(imgContour,\"Pinch\",(x,y+h+20),fonts,0.7,green,2)\n",
    "                elif(area > 15000):\n",
    "                    cv2.putText(imgContour,\"Power\",(x,y+h+20),fonts,0.7,green,2)\n",
    "                else:\n",
    "                    cv2.putText(imgContour,\"Tripod\",(x,y+h+20),fonts,0.7,green,2)\n",
    "    \n",
    "###################################################################\n",
    "\n",
    "while(True):        \n",
    "    success, img = cap.read()    # Capture frame-by-frame\n",
    "    imgContour = img    \n",
    "# 4\n",
    "    imgGray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)    \n",
    "    \n",
    "# 6. Canny edge detector is an edge detection operator that uses a multi-stage algorithm\n",
    "# to detect a wide range of edges in images\n",
    "\n",
    "# canny image takes 2 thresholds (upper and lower)\n",
    "# If a pixel gradient is higher than the upper threshold, it is accepted as an edge.\n",
    "# If it is between the two thresholds, it will be accepted only if it is connected\n",
    "# to a pixel that is above the upper threshold.\n",
    "\n",
    "# get trackbar position from the parameters window\n",
    "    threshold1 = cv2.getTrackbarPos(\"Threshold1\",\"Parameters\")\n",
    "    threshold2 = cv2.getTrackbarPos(\"Threshold2\",\"Parameters\")\n",
    "    imgCanny = cv2.Canny(imgGray,threshold1,threshold2)\n",
    "    \n",
    "# 7. dilation function to remove overlaps and noise    \n",
    "    kernel = np.ones((5,5))\n",
    "    imgDil = cv2.dilate(imgCanny, kernel, iterations=1)\n",
    "    \n",
    "# contour: outline representing or bounding the shape    \n",
    "    getContours(imgDil, imgContour)\n",
    "    \n",
    "#     imgStack = stackImages(0.8,([img, imgBlur, imgGray], [imgDil,imgDil,imgDil]))\n",
    "# 3\n",
    "    cv2.imshow('frame',imgContour)\n",
    "    \n",
    "###################################################################\n",
    "\n",
    "    if cv2.waitKey(1)==27: break    # esc\n",
    "\n",
    "cap.release()\n",
    "cv2.destroyAllWindows()"
   ]
  }
 ],
 "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": 5
}