Calibration_pixel_to_real_life_measurement_Object_length_and_width_measurement_from_Image.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "nYL12SjQNAVV"
      },
      "outputs": [],
      "source": [
        "import cv2\n",
        "from google.colab.patches import cv2_imshow\n",
        "import numpy as np\n",
        "import pandas as pd\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "2cDybgIqMr-D"
      },
      "outputs": [],
      "source": [
        "## Utility .py file.\n",
        "\n",
        "def getcontour(img, thr = [100,100], showcanny = False, minarea = 10000, filter = 4, draw = False):\n",
        "    imggray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
        "    imgblur = cv2.GaussianBlur(imggray, (5,5), 1)\n",
        "    imgcanny = cv2.Canny(imgblur, thr[0], thr[1])\n",
        "    kernel = np.ones((5,5)) \n",
        "    imgdial = cv2.dilate(imgcanny, kernel, iterations = 3)\n",
        "    imgeros = cv2.erode(imgdial, kernel, iterations = 2)\n",
        "    \n",
        "    if showcanny:cv2.imshow('Canny', imgeros)\n",
        "\n",
        "    contours, hierarchy = cv2.findContours(imgeros, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
        "\n",
        "# Constraints, for area of contour.\n",
        "# Approximation of curve, that is with 4 point and closed curve for quadrilateral.\n",
        "# cv2.approxPolyDP function to smooth and approximate the quadrilateral.\n",
        "    finalcontour = []\n",
        "\n",
        "    for i in contours:\n",
        "        area = cv2.contourArea(i)\n",
        "        if area > minarea:\n",
        "            peri = cv2.arcLength(i, True)\n",
        "            approx = cv2.approxPolyDP(i, 0.02*peri, True) \n",
        "            bbox = cv2.boundingRect(approx)\n",
        "\n",
        "            if filter > 0:                 # if curve of the approximation has minimum 4 points.\n",
        "                if len(approx) == filter:  # if approximation curve has minimum 4 point then we are choosing those contours curve.  \n",
        "                    finalcontour.append([len(approx), area, approx, bbox, i])\n",
        "            else:\n",
        "                finalcontour.append([len(approx), area, approx, bbox, i])\n",
        "    finalcontour = sorted(finalcontour, key = lambda finalcontour: finalcontour[1], reverse = True) ## It will become Big to small using reverse = True\n",
        "    if draw:\n",
        "        for con in finalcontour:\n",
        "            cv2.drawContours(img, con[4], -1, (0,0,128), 3)\n",
        "    return img, finalcontour\n",
        "\n",
        "def reorder(myPoints):\n",
        "    #print(myPoints.shape)\n",
        "    myPointsNew = np.zeros_like(myPoints)\n",
        "    myPoints = myPoints.reshape((4,2))\n",
        "    add = myPoints.sum(1)\n",
        "    myPointsNew[0] = myPoints[np.argmin(add)]\n",
        "    myPointsNew[3] = myPoints[np.argmax(add)]\n",
        "    diff = np.diff(myPoints,axis=1)\n",
        "    myPointsNew[1]= myPoints[np.argmin(diff)]\n",
        "    myPointsNew[2] = myPoints[np.argmax(diff)]\n",
        "    return myPointsNew\n",
        "\n",
        "def warpImg (img,points,w,h,pad=20):\n",
        "    # print(points)\n",
        "    points =reorder(points)\n",
        "    pts1 = np.float32(points)\n",
        "    pts2 = np.float32([[0,0],[w,0],[0,h],[w,h]])\n",
        "    matrix = cv2.getPerspectiveTransform(pts1,pts2)\n",
        "    imgWarp = cv2.warpPerspective(img,matrix,(w,h))\n",
        "    imgWarp = imgWarp[pad:imgWarp.shape[0]-pad,pad:imgWarp.shape[1]-pad]\n",
        "    return imgWarp\n",
        "\n",
        "def findDis(pts1,pts2):\n",
        "    return ((pts2[0]-pts1[0])**2 + (pts2[1]-pts1[1])**2)**0.5\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "VQwGMxs1Mjyv"
      },
      "outputs": [],
      "source": [
        "# img = cv2.imread(\"/content/real.jpg\")\n",
        "# cv2_imshow(img)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "SHB3VnTwL6Sw"
      },
      "outputs": [],
      "source": [
        "## Object measurement main.py file.\n",
        "\n",
        "path = \"/content/1.jpg\"\n",
        "img = cv2.imread(path) \n",
        "\n",
        "imgcnt, conts = getcontour(img, minarea = 25, filter = 4)\n",
        "#cv2_imshow(imgcnt)\n",
        "#print(len(conts))\n",
        "\n",
        "scale = 3\n",
        "wp = 210 * scale\n",
        "hp = 297 * scale\n",
        "\n",
        "if len(conts) != 0:\n",
        "    biggest = conts[0][2]\n",
        "    imgWarp = warpImg(img, biggest, wp,hp)\n",
        "    #cv2_imshow(imgWarp)\n",
        "    imgContours2, conts2 = getcontour(imgWarp,minarea=20, filter=4,thr=[100,100],draw = False)\n",
        "    #cv2_imshow(imgContours2)\n",
        "\n",
        "    if len(conts) != 0:\n",
        "        for obj in conts2:\n",
        "            cv2.polylines(imgContours2,[obj[2]],True,(0,255,0),2)\n",
        "            #cv2_imshow(imgContours2)\n",
        "            nPoints = reorder(obj[2])\n",
        "            nW = round((findDis(nPoints[0][0]//scale,nPoints[1][0]//scale)/10),1)\n",
        "            nH = round((findDis(nPoints[0][0]//scale,nPoints[2][0]//scale)/10),1)\n",
        "            cv2.arrowedLine(imgContours2, (nPoints[0][0][0], nPoints[0][0][1]), (nPoints[1][0][0], nPoints[1][0][1]),\n",
        "                            (255, 0, 255), 3, 8, 0, 0.05)\n",
        "            cv2.arrowedLine(imgContours2, (nPoints[0][0][0], nPoints[0][0][1]), (nPoints[2][0][0], nPoints[2][0][1]),\n",
        "                            (255, 0, 255), 3, 8, 0, 0.05)\n",
        "            x, y, w, h = obj[3]\n",
        "            cv2.putText(imgContours2, '{}cm'.format(nW), (x + 30, y - 10), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1.5,\n",
        "                        (255, 0, 255), 2)\n",
        "            cv2.putText(imgContours2, '{}cm'.format(nH), (x - 70, y + h // 2), cv2.FONT_HERSHEY_COMPLEX_SMALL, 1.5,\n",
        "                        (255, 0, 255), 2)\n",
        "    cv2_imshow(imgContours2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "v6ux3kADNpzW"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}