PLANIMETRIC SHAPES.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "increased-fitness",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "printable-champion",
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.imread('D:/GS/FilteredHEDV2/FHED1.jpg', 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "funny-struggle",
   "metadata": {},
   "outputs": [],
   "source": [
    "ret, thresh = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "external-stationery",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Find the contours of the objects\n",
    "contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "varying-reasoning",
   "metadata": {},
   "outputs": [],
   "source": [
    "#First test out all of the things we need to calculate on an image\n",
    "#check values for sanity check before using the main for loop\n",
    "\n",
    "#Circularity\n",
    "\n",
    "# MAX AND MIN DIA and max and min aspect ratio\n",
    "\n",
    "#X and Y DIA and X/Y aspect ratio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "competent-array",
   "metadata": {},
   "outputs": [],
   "source": [
    "circularity_ratio = np.zeros(len(contours))\n",
    "\n",
    "\n",
    "for i, contour in enumerate(contours):\n",
    "        area = cv2.contourArea(contour)\n",
    "        perimeter = cv2.arcLength(contour, True)\n",
    "        circularity_ratio[i] = (4 * math.pi * area) / (perimeter ** 2)\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "labeled-cycling",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "363\n",
      "0.48775964737897093\n",
      "0.17827610700325774\n",
      "0.8418365193359838\n"
     ]
    }
   ],
   "source": [
    "print(len(circularity_ratio))\n",
    "print(np.mean(circularity_ratio))\n",
    "print(np.std(circularity_ratio))\n",
    "print(np.max(circularity_ratio))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "engaging-catholic",
   "metadata": {},
   "outputs": [],
   "source": [
    "#still testing on one image\n",
    "\n",
    "\n",
    "max_distances = []\n",
    "min_distances = []\n",
    "\n",
    "# Iterate through all the contours\n",
    "for contour in contours:\n",
    "    # Calculate the convex hull of the contour\n",
    "    hull = cv2.convexHull(contour)\n",
    "    \n",
    "    # Initialize the maximum and minimum distances to zero\n",
    "    max_distance = 0\n",
    "    min_distance = float('inf')\n",
    "    \n",
    "    # Iterate through all pairs of points on the convex hull\n",
    "    for i in range(len(hull)):\n",
    "        for j in range(i+1, len(hull)):\n",
    "            # Calculate the distance between the two points\n",
    "            distance = np.sqrt((hull[i][0][0] - hull[j][0][0])**2 + (hull[i][0][1] - hull[j][0][1])**2)\n",
    "\n",
    "            # Update the maximum and minimum distances if necessary\n",
    "            if distance > max_distance:\n",
    "                max_distance = distance\n",
    "            if distance < min_distance:\n",
    "                min_distance = distance\n",
    "    \n",
    "    # Add the maximum and minimum distances for the current contour to the list of distances\n",
    "    max_distances.append([max_distance])\n",
    "    min_distances.append([min_distance])\n",
    "\n",
    "\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "indonesian-workshop",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "363\n",
      "1.2450037601786725\n",
      "0.3249815688021042\n",
      "2.8284271247461903\n"
     ]
    }
   ],
   "source": [
    "print(len(min_distances))\n",
    "print(np.mean(min_distances))\n",
    "print(np.std(min_distances))\n",
    "print(np.max(min_distances))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bizarre-watch",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "363\n",
      "74.51572302838632\n",
      "57.03540896277775\n",
      "414.9650587700126\n"
     ]
    }
   ],
   "source": [
    "print(len(max_distances))\n",
    "print(np.mean(max_distances))\n",
    "print(np.std(max_distances))\n",
    "print(np.max(max_distances))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "according-mambo",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_DIA = np.zeros(len(contours))\n",
    "for i, contour in enumerate(contours):\n",
    "    # Get the bounding rectangle of the grain\n",
    "    x, y, w, h = cv2.boundingRect(contour)\n",
    "\n",
    "    # Calculate the x-diameter of the grain using the width of the bounding rectangle\n",
    "    X_DIA[i] = w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "sharing-detection",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "363\n",
      "60.11845730027548\n",
      "48.811548173415304\n",
      "386.0\n"
     ]
    }
   ],
   "source": [
    "print(len(X_DIA))\n",
    "print(np.mean(X_DIA))\n",
    "print(np.std(X_DIA))\n",
    "print(np.max(X_DIA))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "heated-tuesday",
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_DIA = np.zeros(len(contours))\n",
    "for i, contour in enumerate(contours):\n",
    "    # Get the bounding rectangle of the grain\n",
    "    x, y, w, h = cv2.boundingRect(contour)\n",
    "\n",
    "    # Calculate the x-diameter of the grain using the width of the bounding rectangle\n",
    "    Y_DIA[i] = h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "challenging-atlantic",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "363\n",
      "61.925619834710744\n",
      "47.880043857774574\n",
      "411.0\n"
     ]
    }
   ],
   "source": [
    "print(len(Y_DIA))\n",
    "print(np.mean(Y_DIA))\n",
    "print(np.std(Y_DIA))\n",
    "print(np.max(Y_DIA))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "lonely-organizer",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Now the Main for LOOPS, I will write one for each of the variables 3 total\n",
    "# 1. circ 2. max/min  3.X/Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acoustic-possession",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "passive-easter",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for loop for the whole file set\n",
    "n = 40\n",
    "CR = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "united-skirt",
   "metadata": {},
   "outputs": [],
   "source": [
    "#This loop reads all the images and then stores the area of each grain for the image in an array\n",
    "# Circularity ratio For Loop all images\n",
    "\n",
    "\n",
    "for t in range(n):\n",
    "\n",
    "    image = cv2.imread('D:/GS/FilteredGradV2/FGRAD' + str(t+1) + '.jpg', 0)\n",
    "\n",
    "    ret, thresh = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)\n",
    "\n",
    "    contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "\n",
    "    \n",
    "    for i, contour in enumerate(contours):\n",
    "            area = cv2.contourArea(contour)\n",
    "            perimeter = cv2.arcLength(contour, True)\n",
    "            circularity_ratio = (4 * math.pi * area) / (perimeter ** 2)\n",
    "            CR.append(circularity_ratio)\n",
    "        \n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "complex-december",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24740\n"
     ]
    }
   ],
   "source": [
    "#check the lengths make sense\n",
    "print(len(CR))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "hearing-identifier",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.27580025013495235\n",
      "0.14701528836550212\n"
     ]
    }
   ],
   "source": [
    "avg_CR = np.mean(CR)\n",
    "print(avg_CR)\n",
    "CR_std = np.std(CR)\n",
    "print(CR_std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "special-spectrum",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8965351562227398"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(CR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "going-keyboard",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.013734520537130342"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(CR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "speaking-hydrogen",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now the Max/MIN for loop\n",
    "# this loop takes about 30 seconds\n",
    "n = 40\n",
    "MAX = []\n",
    "MIN = []\n",
    "AR = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "secondary-latin",
   "metadata": {},
   "outputs": [],
   "source": [
    "# MAX MIN For Loop all images\n",
    "# aspect ratio as well\n",
    "\n",
    "for t in range(n):\n",
    "\n",
    "    image = cv2.imread('D:/GS/FilteredTHRESHV2/FTHRESH' + str(t+1) + '.jpg', 0)\n",
    "\n",
    "    ret, thresh = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)\n",
    "\n",
    "    contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "\n",
    "    \n",
    "    # Iterate through all the contours\n",
    "    for contour in contours:\n",
    "        # Calculate the convex hull of the contour\n",
    "        hull = cv2.convexHull(contour)\n",
    "\n",
    "        # Initialize the maximum and minimum distances to zero\n",
    "        max_distance = 0\n",
    "        min_distance = float('inf')\n",
    "\n",
    "        # Iterate through all pairs of points on the convex hull\n",
    "        for i in range(len(hull)):\n",
    "            for j in range(i+1, len(hull)):\n",
    "                # Calculate the distance between the two points\n",
    "                distance = np.sqrt((hull[i][0][0] - hull[j][0][0])**2 + (hull[i][0][1] - hull[j][0][1])**2)\n",
    "\n",
    "                # Update the maximum and minimum distances if necessary\n",
    "                if distance > max_distance:\n",
    "                    max_distance = distance\n",
    "                if distance < min_distance:\n",
    "                    min_distance = distance\n",
    "\n",
    "        # Add the maximum and minimum distances for the current contour to the list of distances\n",
    "        MAX.append([max_distance])\n",
    "        MIN.append([min_distance])\n",
    "        aspect_ratio = max_distance/min_distance\n",
    "        AR.append([aspect_ratio])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "binary-bangladesh",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9575\n",
      "88.45574791381331\n",
      "69.06035943914794\n",
      "668.4137939929127\n"
     ]
    }
   ],
   "source": [
    "print(len(MAX))\n",
    "print(np.mean(MAX))\n",
    "print(np.std(MAX))\n",
    "print(np.max(MAX))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "potential-pride",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9575\n",
      "1.5974682612746502\n",
      "0.5122531095219669\n",
      "4.242640687119285\n"
     ]
    }
   ],
   "source": [
    "print(len(MIN))\n",
    "print(np.mean(MIN))\n",
    "print(np.std(MIN))\n",
    "print(np.max(MIN))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "advance-tours",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39.31366573947258\n",
      "0.7099858938998446\n",
      "30.69349308406575\n",
      "0.22766804867642973\n"
     ]
    }
   ],
   "source": [
    "conversion = 1/2.25\n",
    "AVG_MAX_C = np.mean(MAX)*conversion\n",
    "AVG_MIN_C = np.mean(MIN)*conversion\n",
    "STD_MAX_C = np.std(MAX)*conversion\n",
    "STD_MIN_C = np.std(MIN)*conversion\n",
    "print(AVG_MAX_C)\n",
    "print(AVG_MIN_C)\n",
    "print(STD_MAX_C)\n",
    "print(STD_MIN_C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "suffering-suspension",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9575\n",
      "59.266820090850814\n",
      "49.62201140027152\n",
      "584.4997861419625\n"
     ]
    }
   ],
   "source": [
    "print(len(AR))\n",
    "print(np.mean(AR))\n",
    "print(np.std(AR))\n",
    "print(np.max(AR))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "suburban-search",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now the X/Y LOOP\n",
    "# this loop takes about 30 seconds\n",
    "n = 40\n",
    "X = []\n",
    "Y = []\n",
    "AR = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "impaired-bailey",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now the X/Y LOOP\n",
    "# this loop takes about 30 seconds\n",
    "\n",
    "for t in range(n):\n",
    "\n",
    "    image = cv2.imread('D:/GS/FilteredHEDV2/FHED' + str(t+1) + '.jpg', 0)\n",
    "\n",
    "    ret, thresh = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)\n",
    "\n",
    "    contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
    "\n",
    "    \n",
    "    for i, contour in enumerate(contours):\n",
    "        # Get the bounding rectangle of the grain\n",
    "        x, y, w, h = cv2.boundingRect(contour)\n",
    "\n",
    "        # Calculate the x-diameter of the grain using the width of the bounding rectangle\n",
    "        X.append([w])\n",
    "        Y.append([h])\n",
    "        aspect_ratio = w/h\n",
    "        AR.append([aspect_ratio])\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "seeing-switch",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15297\n",
      "1.0731558008294522\n",
      "0.5099244880754141\n",
      "6.0\n"
     ]
    }
   ],
   "source": [
    "print(len(AR))\n",
    "print(np.mean(AR))\n",
    "print(np.std(AR))\n",
    "print(np.max(AR))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "scheduled-burning",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24.80567722066055\n",
      "25.471399620840685\n",
      "19.513475162990826\n",
      "19.763686144578752\n"
     ]
    }
   ],
   "source": [
    "conversion = 1/2.25\n",
    "AVG_X = np.mean(X)*conversion\n",
    "AVG_Y = np.mean(Y)*conversion\n",
    "STD_X = np.std(X)*conversion\n",
    "STD_Y = np.std(Y)*conversion\n",
    "print(AVG_X)\n",
    "print(AVG_Y)\n",
    "print(STD_X)\n",
    "print(STD_Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "forty-juice",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}