measure-organoid-size-with-blob-detection.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2;\n",
    "import numpy as np;\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "error",
     "evalue": "OpenCV(4.5.3) /Users/runner/miniforge3/conda-bld/libopencv_1630689852376/work/modules/imgproc/src/color.cpp:182: error: (-215:Assertion failed) !_src.empty() in function 'cvtColor'\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31merror\u001b[0m                                     Traceback (most recent call last)",
      "Input \u001b[0;32mIn [3]\u001b[0m, in \u001b[0;36m<cell line: 9>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m keypoints \u001b[38;5;241m=\u001b[39m detector\u001b[38;5;241m.\u001b[39mdetect(im)\n\u001b[1;32m      5\u001b[0m \u001b[38;5;66;03m# Draw detected blobs as red circles.\u001b[39;00m\n\u001b[1;32m      6\u001b[0m \n\u001b[1;32m      7\u001b[0m \u001b[38;5;66;03m# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures the size of the circle corresponds to the size of blob\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m im_with_keypoints \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mdrawKeypoints(im, keypoints, np\u001b[38;5;241m.\u001b[39marray([]), (\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m255\u001b[39m), cv2\u001b[38;5;241m.\u001b[39mDRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)\n\u001b[1;32m     10\u001b[0m \u001b[38;5;66;03m# Show keypoints\u001b[39;00m\n\u001b[1;32m     12\u001b[0m th, dst \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mthreshold(im,\u001b[38;5;241m90\u001b[39m,\u001b[38;5;241m255\u001b[39m, cv2\u001b[38;5;241m.\u001b[39mTHRESH_BINARY);\n",
      "\u001b[0;31merror\u001b[0m: OpenCV(4.5.3) /Users/runner/miniforge3/conda-bld/libopencv_1630689852376/work/modules/imgproc/src/color.cpp:182: error: (-215:Assertion failed) !_src.empty() in function 'cvtColor'\n"
     ]
    }
   ],
   "source": [
    "im = cv2.imread(\"002.jpeg\", cv2.IMREAD_GRAYSCALE)\n",
    "detector = cv2.SimpleBlobDetector_create()\n",
    "# Detect blobs.\n",
    "keypoints = detector.detect(im)\n",
    "# Draw detected blobs as red circles.\n",
    "\n",
    "# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures the size of the circle corresponds to the size of blob\n",
    "\n",
    "im_with_keypoints = cv2.drawKeypoints(im, keypoints, np.array([]), (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)\n",
    "# Show keypoints\n",
    "\n",
    "th, dst = cv2.threshold(im,90,255, cv2.THRESH_BINARY);\n",
    "\n",
    "\n",
    "cv2.imwrite(\"opencv-thresh-binary-maxval.jpg\", dst);\n",
    "\n",
    "# cv2.imshow(\"Keypoints\", im_with_keypoints)\n",
    "# cv2.waitKey(0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "error",
     "evalue": "OpenCV(4.5.3) /Users/runner/miniforge3/conda-bld/libopencv_1630689852376/work/modules/imgproc/src/color.cpp:182: error: (-215:Assertion failed) !_src.empty() in function 'cvtColor'\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31merror\u001b[0m                                     Traceback (most recent call last)",
      "Input \u001b[0;32mIn [4]\u001b[0m, in \u001b[0;36m<cell line: 9>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m keypoints \u001b[38;5;241m=\u001b[39m detector\u001b[38;5;241m.\u001b[39mdetect(im)\n\u001b[1;32m      5\u001b[0m \u001b[38;5;66;03m# Draw detected blobs as red circles.\u001b[39;00m\n\u001b[1;32m      6\u001b[0m \n\u001b[1;32m      7\u001b[0m \u001b[38;5;66;03m# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures the size of the circle corresponds to the size of blob\u001b[39;00m\n\u001b[0;32m----> 9\u001b[0m im_with_keypoints \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mdrawKeypoints(im, keypoints, np\u001b[38;5;241m.\u001b[39marray([]), (\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m255\u001b[39m), cv2\u001b[38;5;241m.\u001b[39mDRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)\n\u001b[1;32m     10\u001b[0m \u001b[38;5;66;03m# Show keypoints\u001b[39;00m\n\u001b[1;32m     13\u001b[0m cv2\u001b[38;5;241m.\u001b[39mimshow(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mKeypoints\u001b[39m\u001b[38;5;124m\"\u001b[39m, im_with_keypoints)\n",
      "\u001b[0;31merror\u001b[0m: OpenCV(4.5.3) /Users/runner/miniforge3/conda-bld/libopencv_1630689852376/work/modules/imgproc/src/color.cpp:182: error: (-215:Assertion failed) !_src.empty() in function 'cvtColor'\n"
     ]
    }
   ],
   "source": [
    "im = cv2.imread(\"opencv-thresh-binary-maxval.jpg\", cv2.IMREAD_GRAYSCALE)\n",
    "detector = cv2.SimpleBlobDetector_create()\n",
    "# Detect blobs.\n",
    "keypoints = detector.detect(im)\n",
    "# Draw detected blobs as red circles.\n",
    "\n",
    "# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures the size of the circle corresponds to the size of blob\n",
    "\n",
    "im_with_keypoints = cv2.drawKeypoints(im, keypoints, np.array([]), (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)\n",
    "# Show keypoints\n",
    "\n",
    "\n",
    "cv2.imshow(\"Keypoints\", im_with_keypoints)\n",
    "cv2.waitKey(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import cv2\n",
    "import glob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "error",
     "evalue": "OpenCV(4.5.3) /Users/runner/miniforge3/conda-bld/libopencv_1630689852376/work/modules/imgproc/src/smooth.dispatch.cpp:617: error: (-215:Assertion failed) !_src.empty() in function 'GaussianBlur'\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31merror\u001b[0m                                     Traceback (most recent call last)",
      "Input \u001b[0;32mIn [8]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m im \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mimread(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mopencv-thresh-binary-maxval.jpg\u001b[39m\u001b[38;5;124m\"\u001b[39m, cv2\u001b[38;5;241m.\u001b[39mIMREAD_GRAYSCALE)\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# Blur image to remove noise\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m frame\u001b[38;5;241m=\u001b[39mcv2\u001b[38;5;241m.\u001b[39mGaussianBlur(im, (\u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m3\u001b[39m), \u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m      5\u001b[0m \u001b[38;5;66;03m# Switch image from BGR colorspace to HSV\u001b[39;00m\n\u001b[1;32m      6\u001b[0m hsv \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mcvtColor(frame, cv2\u001b[38;5;241m.\u001b[39mCOLOR_BGR2HSV)\n",
      "\u001b[0;31merror\u001b[0m: OpenCV(4.5.3) /Users/runner/miniforge3/conda-bld/libopencv_1630689852376/work/modules/imgproc/src/smooth.dispatch.cpp:617: error: (-215:Assertion failed) !_src.empty() in function 'GaussianBlur'\n"
     ]
    }
   ],
   "source": [
    "    im = cv2.imread(\"opencv-thresh-binary-maxval.jpg\", cv2.IMREAD_GRAYSCALE)\n",
    "    # Blur image to remove noise\n",
    "    frame=cv2.GaussianBlur(im, (3, 3), 0)\n",
    " \n",
    "    # Switch image from BGR colorspace to HSV\n",
    "    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)\n",
    "    \n",
    "    # define range of purple color in HSV\n",
    "    purpleMin = (115,50,10)\n",
    "    purpleMax = (160, 255, 255)\n",
    "    \n",
    "    # Sets pixels to white if in purple range, else will be set to black\n",
    "    mask = cv2.inRange(hsv, purpleMin, purpleMax)\n",
    "        \n",
    "    # Bitwise-AND of mask and purple only image - only used for display\n",
    "    res = cv2.bitwise_and(frame, frame, mask= mask)\n",
    "#    mask = cv2.erode(mask, None, iterations=1)\n",
    "    # commented out erode call, detection more accurate without it\n",
    " \n",
    "    # dilate makes the in range areas larger\n",
    "    mask = cv2.dilate(mask, None, iterations=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "error",
     "evalue": "OpenCV(4.5.3) /Users/runner/miniforge3/conda-bld/libopencv_1630689852376/work/modules/imgproc/src/smooth.dispatch.cpp:617: error: (-215:Assertion failed) !_src.empty() in function 'GaussianBlur'\n",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31merror\u001b[0m                                     Traceback (most recent call last)",
      "Input \u001b[0;32mIn [9]\u001b[0m, in \u001b[0;36m<cell line: 8>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m DRAW_CIRCLE_RADIUS \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m18\u001b[39m\n\u001b[1;32m      7\u001b[0m img \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mimread(num\u001b[38;5;241m+\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.jpeg\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m----> 8\u001b[0m blur \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mGaussianBlur(img,(\u001b[38;5;241m49\u001b[39m,\u001b[38;5;241m49\u001b[39m),\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m      9\u001b[0m gray_img \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mcvtColor(blur, cv2\u001b[38;5;241m.\u001b[39mCOLOR_BGR2GRAY)\n\u001b[1;32m     12\u001b[0m ret, thresh \u001b[38;5;241m=\u001b[39m cv2\u001b[38;5;241m.\u001b[39mthreshold(gray_img, \u001b[38;5;241m100\u001b[39m, \u001b[38;5;241m255\u001b[39m, cv2\u001b[38;5;241m.\u001b[39mTHRESH_BINARY)\n",
      "\u001b[0;31merror\u001b[0m: OpenCV(4.5.3) /Users/runner/miniforge3/conda-bld/libopencv_1630689852376/work/modules/imgproc/src/smooth.dispatch.cpp:617: error: (-215:Assertion failed) !_src.empty() in function 'GaussianBlur'\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "num = \"225\"\n",
    "kernel = np.ones((11,11),np.uint8)\n",
    "CONNECTIVITY = 4\n",
    "DRAW_CIRCLE_RADIUS = 18\n",
    "img = cv2.imread(path+num+'.jpeg')\n",
    "blur = cv2.GaussianBlur(img,(49,49),0)\n",
    "gray_img = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "\n",
    "ret, thresh = cv2.threshold(gray_img, 100, 255, cv2.THRESH_BINARY)\n",
    "erosion = cv2.erode(thresh,kernel,iterations = 1)\n",
    "\n",
    "components = cv2.connectedComponentsWithStats(erosion, CONNECTIVITY, cv2.CV_32S)\n",
    "\n",
    "centers = components[3]\n",
    "centers[0]=centers[1]\n",
    "for center in centers:\n",
    "    cv2.circle(img, (int(center[0]), int(center[1])), DRAW_CIRCLE_RADIUS, (0,0,255), thickness=1)\n",
    "    \n",
    "\n",
    "\n",
    "# cv2.imshow('Original', img)\n",
    "# cv2.imshow('Blur', blur)\n",
    "# cv2.imshow('Thresh', thresh)\n",
    "# cv2.imshow('Erosion', erosion)\n",
    "# cv2.waitKey(0)\n",
    "cv2.imwrite(num +\"-thresh.jpg\", thresh);\n",
    "\n",
    "cv2.countNonZero(thresh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting matplotlib\n",
      "  Downloading matplotlib-3.5.2-cp39-cp39-macosx_11_0_arm64.whl (7.2 MB)\n",
      "     |████████████████████████████████| 7.2 MB 3.6 MB/s            \n",
      "\u001b[?25hCollecting fonttools>=4.22.0\n",
      "  Downloading fonttools-4.33.3-py3-none-any.whl (930 kB)\n",
      "     |████████████████████████████████| 930 kB 3.7 MB/s            \n",
      "\u001b[?25hRequirement already satisfied: packaging>=20.0 in /Users/pierre/miniforge3/lib/python3.9/site-packages (from matplotlib) (21.3)\n",
      "Requirement already satisfied: pyparsing>=2.2.1 in /Users/pierre/miniforge3/lib/python3.9/site-packages (from matplotlib) (3.0.9)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /Users/pierre/miniforge3/lib/python3.9/site-packages (from matplotlib) (2.8.2)\n",
      "Requirement already satisfied: pillow>=6.2.0 in /Users/pierre/miniforge3/lib/python3.9/site-packages (from matplotlib) (9.1.0)\n",
      "Collecting cycler>=0.10\n",
      "  Using cached cycler-0.11.0-py3-none-any.whl (6.4 kB)\n",
      "Requirement already satisfied: numpy>=1.17 in /Users/pierre/miniforge3/lib/python3.9/site-packages (from matplotlib) (1.22.4)\n",
      "Collecting kiwisolver>=1.0.1\n",
      "  Using cached kiwisolver-1.4.2-cp39-cp39-macosx_11_0_arm64.whl (63 kB)\n",
      "Requirement already satisfied: six>=1.5 in /Users/pierre/miniforge3/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n",
      "Installing collected packages: kiwisolver, fonttools, cycler, matplotlib\n",
      "Successfully installed cycler-0.11.0 fonttools-4.33.3 kiwisolver-1.4.2 matplotlib-3.5.2\n"
     ]
    }
   ],
   "source": [
    "#!conda install -c conda-forge opencv -y\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01\n",
      "02\n",
      "03\n",
      "04\n",
      "05\n",
      "06\n",
      "07\n",
      "08\n",
      "09\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "25\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "import os\n",
    "import re\n",
    "size = [[],[]]\n",
    "lastVal = 0\n",
    "diffs = [0,0,0,0,0,0]\n",
    "vals = [0]\n",
    "lastDiff = 0.1\n",
    "#path=\"./Fluidics-Paper-Experiment/Figure-Selections/processed/\"\n",
    "path = \"/Users/pierre/Pictures/biology/Blob-Measuring/Level-Measurement-Experiment/cropped-dataset/\"\n",
    "#path = \"./Fluidics-Paper-Experiment/2020-02-07-fluidics-imaging-2-timelapse-2022-04-12T11:54/C15/Cropped-and-adjusted/\"\n",
    "for entry in sorted(os.scandir(path),key=lambda e: e.name):\n",
    "    #print(entry)\n",
    "    if (entry.path.endswith(\".jpeg\") or entry.path.endswith(\".png\")) and entry.is_file():\n",
    "        num = re.split('\\.|/',entry.path)\n",
    "        num = num[len(num)-2]\n",
    "        print(num)\n",
    "        img = cv2.imread(entry.path)\n",
    "        blur = cv2.GaussianBlur(img,(49,49),0)\n",
    "        gray_img = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)\n",
    "        ret, thresh = cv2.threshold(gray_img, 110, 255, cv2.THRESH_BINARY)\n",
    "        cv2.imwrite(path+\"thresh/\"+num +\"-thresh.jpg\", thresh);\n",
    "        #print(img.shape)\n",
    "        #print(cv2.countNonZero(thresh))\n",
    "        #size[0].append(int(re.split('-|/',entry.path)[1]))\n",
    "        \n",
    "        val = (img.shape[0]*img.shape[1]-cv2.countNonZero(thresh))#*0.0000033397\n",
    "#         diff = abs(abs(val)-abs(lastVal))\n",
    "#         diffs.append(diff)\n",
    "#         meanDiff = np.mean(diffs[len(diffs)-5:len(diffs)])\n",
    "#         meanVals = np.mean(vals[len(vals)-5:len(vals)])\n",
    "#         print(abs(meanVals))\n",
    "\n",
    "#         if abs(val-1.1*meanVals) < 0.2:#and val-lastVal > -0.1:\n",
    "#             size[0].append(int(num))\n",
    "#             size[1].append((val))\n",
    "#             vals.append(val)\n",
    "#             lastVal = val\n",
    "#             lastDiff = diff\n",
    "\n",
    "\n",
    "        size[0].append(int(num)/24)\n",
    "        size[1].append((val))\n",
    "\n",
    "#         print(re.split('-|/',entry.path)[1])\n",
    "#         print(img.shape[0]*img.shape[1]-cv2.countNonZero(thresh))\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y=89713.547457x+(-361959.935774)\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pylab as plt\n",
    "plt.plot(size[0],size[1], 'ro')\n",
    "x= size[0];\n",
    "y=size[1];\n",
    "z = np.polyfit(x, y, 3)\n",
    "p = np.poly1d(z)\n",
    "plt.plot(x,p(x),'k--',linewidth=2)\n",
    "color = 0.8;\n",
    "plt.ylabel('Size ($mm^2$)')\n",
    "plt.xlabel('Time (days)')\n",
    "plt.title(\"Organoid Growth\")\n",
    "plt.show()\n",
    "print( \"y=%.6fx+(%.6f)\"%(z[0],z[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6286141616411733e-08"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['./236.jpeg']"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "entry.path.split(\"\\.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'236'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.split('\\.|/',entry.path)[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diffs[len(diffs)-5:len(diffs)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "diffs=[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.2375929374, 0.3455954957, 0.1200722341, 0.4936944922, 0.2526917211]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals[len(vals)-5:len(vals)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.4583333333333333, 1.2916666666666667, 2.125, 2.875, 3.75, 4.583333333333333, 5.458333333333333, 6.291666666666667], [0.0884252369, 0.1172301494, 0.1852731972, 0.2684150287, 0.360654203, 0.4573084607, 0.5538458289, 0.722076537]]\n"
     ]
    }
   ],
   "source": [
    "print(size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "06\n",
      "07\n",
      "08\n",
      "09\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n",
      "31\n",
      "32\n",
      "33\n"
     ]
    }
   ],
   "source": [
    "#this is the one to optimize for lights\n",
    "\n",
    "import cv2\n",
    "import numpy as np\n",
    "import os\n",
    "import re\n",
    "size = [[],[]]\n",
    "lastVal = 0\n",
    "diffs = [0,0,0,0,0,0]\n",
    "vals = [0]\n",
    "lastDiff = 0.1\n",
    "#path=\"./Fluidics-Paper-Experiment/Figure-Selections/processed/\"\n",
    "path = \"/Users/pierre/Pictures/biology/Blob-Measuring/Level-Measurement-Experiment/second-dataset/cropped-dataset/\"\n",
    "#path = \"./Fluidics-Paper-Experiment/2020-02-07-fluidics-imaging-2-timelapse-2022-04-12T11:54/C15/Cropped-and-adjusted/\"\n",
    "for entry in sorted(os.scandir(path),key=lambda e: e.name):\n",
    "    #print(entry)\n",
    "    if (entry.path.endswith(\".jpeg\") or entry.path.endswith(\".png\")) and entry.is_file():\n",
    "        num = re.split('\\.|/',entry.path)\n",
    "        num = num[len(num)-2]\n",
    "        print(num)\n",
    "        img = cv2.imread(entry.path)\n",
    "        #blur = cv2.GaussianBlur(img,(49,49),0)\n",
    "        blur = cv2.blur(img,(49,49))\n",
    "        gray_img = cv2.cvtColor(blur, cv2.COLOR_BGR2GRAY)\n",
    "        ret, thresh = cv2.threshold(gray_img, 50, 255, cv2.THRESH_BINARY_INV)\n",
    "        cv2.imwrite(path+\"thresh/\"+num +\"-thresh.jpg\", thresh);\n",
    "        #print(img.shape)\n",
    "        #print(cv2.countNonZero(thresh))\n",
    "        #size[0].append(int(re.split('-|/',entry.path)[1]))\n",
    "        \n",
    "        val = (img.shape[0]*img.shape[1]-cv2.countNonZero(thresh))#*0.0000033397\n",
    "#         diff = abs(abs(val)-abs(lastVal))\n",
    "#         diffs.append(diff)\n",
    "#         meanDiff = np.mean(diffs[len(diffs)-5:len(diffs)])\n",
    "#         meanVals = np.mean(vals[len(vals)-5:len(vals)])\n",
    "#         print(abs(meanVals))\n",
    "\n",
    "#         if abs(val-1.1*meanVals) < 0.2:#and val-lastVal > -0.1:\n",
    "#             size[0].append(int(num))\n",
    "#             size[1].append((val))\n",
    "#             vals.append(val)\n",
    "#             lastVal = val\n",
    "#             lastDiff = diff\n",
    "\n",
    "\n",
    "        size[0].append(int(num)/10)\n",
    "        size[1].append((val))\n",
    "\n",
    "#         print(re.split('-|/',entry.path)[1])\n",
    "#         print(img.shape[0]*img.shape[1]-cv2.countNonZero(thresh))\n",
    "        \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y=-15564.673632x+(131791.010742)\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pylab as plt\n",
    "plt.plot(size[0],size[1], 'ro')\n",
    "x= size[0];\n",
    "y=size[1];\n",
    "z = np.polyfit(x, y, 3)\n",
    "p = np.poly1d(z)\n",
    "plt.plot(x,p(x),'k--',linewidth=2)\n",
    "color = 0.8;\n",
    "plt.ylabel('Size ($mm^2$)')\n",
    "plt.xlabel('ml')\n",
    "plt.title(\"Light Diffusion\")\n",
    "plt.show()\n",
    "print( \"y=%.6fx+(%.6f)\"%(z[0],z[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "|"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 64-bit",
   "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.9.13"
  },
  "vscode": {
   "interpreter": {
    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}