get-fluid-level-data-live.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f13c298e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install imutils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9840f16c-ffdf-49da-b64b-f7b4990dcb38",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !conda install -c conda-forge ipywidgets -y\n",
    "\n",
    "#notes get semi circle tracking\n",
    "\n",
    "#https://stackoverflow.com/questions/20698613/detect-semicircle-in-opencv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "31d96db5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#https://pyimagesearch.com/2015/09/14/ball-tracking-with-opencv/\n",
    "\n",
    "# import the necessary packages\n",
    "from collections import deque\n",
    "from imutils.video import VideoStream\n",
    "import numpy as np\n",
    "import argparse\n",
    "import cv2\n",
    "import imutils\n",
    "import time\n",
    "from matplotlib import pyplot as plt\n",
    "from math import sqrt\n",
    "import urllib.request\n",
    "from datetime import datetime\n",
    "import ipywidgets as widgets\n",
    "import pandas as pd\n",
    "from statistics import mean, variance, stdev\n",
    "# construct the argument parse and parse the arguments\n",
    "ap = argparse.ArgumentParser()\n",
    "ap.add_argument(\"-v\", \"--video\", help=\"path to the (optional) video file\");\n",
    "ap.add_argument(\"-b\", \"--buffer\", type=int, default=64, help=\"max buffer size\");\n",
    "#args = vars(ap.parse_args())\n",
    "buffer = 64\n",
    "# define the lower and upper boundaries of the \"green\"\n",
    "# ball in the HSV color space, then initialize the\n",
    "# list of tracked points\n",
    "greenLower = (29, 86, 6)\n",
    "greenUpper = (64, 255, 255)\n",
    "\n",
    "#pts = deque(maxlen=args[\"buffer\"])\n",
    "pts = deque(maxlen = buffer)\n",
    "\n",
    "# if a video path was not supplied, grab the reference\n",
    "# to the webcam\n",
    "# if not args.get(\"video\", False):\n",
    "#     vs = VideoStream(src=0).start()\n",
    "# # otherwise, grab a reference to the video file\n",
    "# else:\n",
    "#     vs = cv2.VideoCapture(args[\"video\"])\n",
    "\n",
    "#vs = VideoStream(src=\"rtsp://advancedcameranode.local:8554/cam\").start()\n",
    "\n",
    "#vs = VideoStream(src=\"http://camerag11.local/html/min.php\").start()\n",
    "# allow the camera or video file to warm up\n",
    "#time.sleep(2.0)\n",
    "# from IPython.display import display\n",
    "# take_pic = 0\n",
    "# button = widgets.Button(description=\"Click Me!\")\n",
    "# output = widgets.Output()\n",
    "\n",
    "# display(button, output)\n",
    "# def on_button_clicked(b):\n",
    "#     with output:\n",
    "#         take_pic += 1\n",
    "#         print(\"Button clicked.\")\n",
    "#         print(str(take_pic))\n",
    "\n",
    "# button.on_click(on_button_clicked)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9c812cbf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "13bdf2be01e64458ade3d8aea08c5ca9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "ToggleButton(value=False, description='capture image')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66cd0ad59a8542279894834e85414f67",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "IntProgress(value=0, description='Buffer', max=50)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2a1ad28b63d54b17bf82046363190904",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "IntProgress(value=0, description='Captures', max=2)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66c72aa5c8c24a83908a6b29e7545a5e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='00', description='filename')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "dcad8c1d23f8476d8399e1691e797ae8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "IntSlider(value=1, description='Increment', max=30, min=1)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5e523c694b304e2085c022d3d313ac77",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "IntSlider(value=100, description='Threshold', max=255, min=1)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fd12a89ce74543dc97728c40debe7c73",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "ToggleButton(value=False, description='plot size')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d31687f45c83453fb866a101748dd083",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='19-June-2023T12:13:46', description='folder')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4a361dd6fd4342a4aeddcaf0f88ba9be",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Create Folder', style=ButtonStyle())"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a6b8744a15654d56a1a8092b248cac55",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatProgress(value=0.0, max=1.0)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ebbe0f72247f4e3796227122f2459387",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "ToggleButton(value=False, description='get dataframe')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "920f58d1ffb942b597afa2b6b859d1a5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "ToggleButton(value=False, description='force capture')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4fb02730551e45429e014e8fffbe2e44",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "ToggleButton(value=False, description='Stop')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "48b9996031734bf493c6278a4e75b374",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1313392c1e9f4eada2ac2f2e4cb211f6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Task pending name='Task-4' coro=<f() running at /var/folders/5z/d1d_q74d1hd653s14vwq9v800000gn/T/ipykernel_32706/759284790.py:219>>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%gui asyncio\n",
    "import asyncio\n",
    "from cgi import MiniFieldStorage\n",
    "import ipywidgets as widgets\n",
    "import os\n",
    "import math\n",
    "import csv\n",
    "import numpy as np\n",
    "import sys\n",
    "\n",
    "from datetime import datetime\n",
    "\n",
    "# Getting the current date and time\n",
    "dt = datetime.now()\n",
    "\n",
    "\n",
    "# set to your desired directory for image capture storage\n",
    "image_dir = \"/Users/pierre/Pictures/biology/Blob-Measuring/Level-Measurement-Experiment/stream-captures/\"\n",
    "\n",
    "BUFFER_SIZE = 50\n",
    "PRECISION_BUFFER_SIZE = 2\n",
    "\n",
    "# circle mode fits a circle to the detected contour\n",
    "circle_mode = False\n",
    "# hough mode uses the hough circles algorithm to detect circles\n",
    "hough_mode = False\n",
    "# in my testing I found neither of these to work better than the ellipse fitting approach that is run by default\n",
    "\n",
    "# stdev_threshold is the value of the standard deviation within the buffer that will trigger a capture, this filters out bad measurements caused by disturbance of the fluid surface\n",
    "stdev_threshold = 0.3\n",
    "\n",
    "# camera_name is the rpi hostname of the device on your local network that is hosting the MJPEG stream from RPi_Cam_Web_Interface\n",
    "camera_name = \"camerafluidleveldetect\"\n",
    "\n",
    "# Defined widgets for the GUI\n",
    "progress = widgets.FloatProgress(value=0.0, min=0.0, max=1.0)\n",
    "buffer_progress = widgets.IntProgress(value=0, min=0, max=BUFFER_SIZE)\n",
    "buffer_progress.description = \"Buffer\"\n",
    "capture_progress = widgets.IntProgress(value=0, min=0, max=PRECISION_BUFFER_SIZE)\n",
    "capture_progress.description = \"Captures\"\n",
    "capture_dataframe = widgets.ToggleButton()\n",
    "capture_dataframe.description = \"get dataframe\"\n",
    "capture_datapoint = widgets.ToggleButton()\n",
    "capture_datapoint.description = \"capture image\"\n",
    "force_capture = widgets.ToggleButton()\n",
    "force_capture.description = \"force capture\"\n",
    "display(capture_datapoint)\n",
    "display(buffer_progress)\n",
    "display(capture_progress)\n",
    "fluid_volume = widgets.Text()\n",
    "fluid_volume.value = \"00\"\n",
    "fluid_volume.description = \"filename\"\n",
    "#an int slider widget that sets the value of fluid_volume.value\n",
    "fluid_value_slider = widgets.IntSlider(value=1, min=1, max=30, step=1)\n",
    "fluid_value_slider.description = \"Increment\"\n",
    "\n",
    "\n",
    "threshold_value_slider = widgets.IntSlider(value=100, min=1, max=255, step=1)\n",
    "threshold_value_slider.description = \"Threshold\"\n",
    "\n",
    "img_folder = widgets.Text()\n",
    "img_folder.description = \"folder\"\n",
    "img_folder.value = dt.strftime(\"%d-%B-%YT%H:%M:%S\")\n",
    "plot = widgets.ToggleButton()\n",
    "plot.description = \"plot size\"\n",
    "\n",
    "output = widgets.Output()\n",
    "output_plot = widgets.Output()\n",
    "#a button to create a new folder\n",
    "dir_button = widgets.Button(description=\"Create Folder\")\n",
    "#a button widget that creates a directory from the img_folder.value parameter\n",
    "def create_folder(b):\n",
    "    with output:\n",
    "        if img_folder.value is not None:\n",
    "            if not os.path.exists(image_dir+img_folder.value):\n",
    "                os.makedirs(image_dir+img_folder.value)\n",
    "                print(\"Folder Created\")\n",
    "            else:\n",
    "                print(\"Folder already exists\")\n",
    "        else:\n",
    "            print(\"Folder not created\")\n",
    "\n",
    "def trace_active_rectangle(image, width, height, offsetX, offsetY):\n",
    "    centerX = int(image.shape[1] / 2)\n",
    "    centerY = int(image.shape[0] / 2)\n",
    "    # color is magenta\n",
    "    color = (255, 0, 255)\n",
    "    cv2.rectangle(image, (centerX + offsetX - int(width/2), centerY+offsetY-int(width/2)), (centerX + offsetX + int(width/2), centerY+offsetY + int(height/2)), color, 2)\n",
    "\n",
    "    # w = 50\n",
    "    # h = 5\n",
    "    # xOffset = 50\n",
    "    # yOffset = 50\n",
    "\n",
    "    # cv2.circle(frame, (centerX + xOffset, centerY + yOffset), radius=0, color=(0, 0, 255), thickness=-1)\n",
    "\n",
    "#low pass filter value from rolling buffer\n",
    "\n",
    "\n",
    "def get_best_circle(image):\n",
    "    #compute distance transform of image\n",
    "    image = cv2.bitwise_not(cv2.Canny(image,100,200))\n",
    "    # image = cv2.bitwise_not(cv2.Canny(image,10,20))\n",
    "    cv2.imshow(\"window2\", image)\n",
    "    dist = cv2.distanceTransform(image, cv2.DIST_L2, 0)\n",
    "    rows = image.shape[0]\n",
    "    min_distance = rows / 8\n",
    "    # min_distance = 1\n",
    "    circles = cv2.HoughCircles(image, cv2.HOUGH_GRADIENT, 1, min_distance , param1=50, param2=10, minRadius=40, maxRadius=70)      \n",
    "    minInlierDist = 0\n",
    "\n",
    "    max_radius = 0\n",
    "    max_inlier_percent = 0\n",
    "    max_arc_points = [[],[]]\n",
    "    max_center = (-1,-1)\n",
    "    image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)\n",
    "    for c in circles[0, :]:\n",
    "        counter = 0\n",
    "        inlier = 0\n",
    "        center = (c[0], c[1])\n",
    "        radius = c[2]\n",
    "        #maxInlierDist = radius/50.0\n",
    "        maxInlierDist = 1.5\n",
    "        inlier_arc = 0\n",
    "        max_inlier_arc = 0\n",
    "        last_point_inbounds = False\n",
    "\n",
    "        arc_points = [[],[]]\n",
    "        max_arc_points_current_circle = [[],[]]\n",
    "        #save first arc incase it loops around\n",
    "        first_arc = True\n",
    "        first_arc_points = [[],[]]\n",
    "\n",
    "\n",
    "        if maxInlierDist < minInlierDist: maxInlierDist = minInlierDist\n",
    "\n",
    "        for i in np.arange(0, 2*np.pi, 0.1):\n",
    "            counter += 1\n",
    "            x = center[0] + radius * np.cos(i)\n",
    "            y = center[1] + radius * np.sin(i)\n",
    "            try:\n",
    "                if dist.item(int(y), int(x)) < maxInlierDist:\n",
    "                    if last_point_inbounds:\n",
    "                        inlier_arc += 1\n",
    "                    else:\n",
    "                        inlier_arc = 1\n",
    "                        last_point_inbounds = True\n",
    "\n",
    "                    arc_points[0].append(int(x))\n",
    "                    arc_points[1].append(int(y))\n",
    "\n",
    "                    inlier += 1\n",
    "                    # cv2.circle(image, (int(x), int(y)), 1, (0, 255, 0), -1)\n",
    "\n",
    "                    #if last iteration, save arc\n",
    "                    if counter == len(np.arange(0, 2*np.pi, 0.1)):\n",
    "                        arc_points[0] = arc_points[0] + first_arc_points[0]\n",
    "                        arc_points[1] = arc_points[1] + first_arc_points[1]\n",
    "\n",
    "                        inlier_arc += len(first_arc_points[0])\n",
    "                        if inlier_arc > max_inlier_arc:\n",
    "                            max_inlier_arc = inlier_arc\n",
    "                            max_arc_points_current_circle = arc_points.copy()\n",
    "                else:\n",
    "                    if first_arc:\n",
    "                        first_arc_points = arc_points.copy()\n",
    "                        # first_arc_points[0].append(arc_points[0].copy())\n",
    "                        # first_arc_points[1].append(arc_points[1].copy())\n",
    "                        first_arc = False\n",
    "\n",
    "                    if inlier_arc > max_inlier_arc:\n",
    "                        max_inlier_arc = inlier_arc\n",
    "                        max_arc_points_current_circle = arc_points.copy()\n",
    "                    \n",
    "                    arc_points = [[],[]]\n",
    "                    last_point_inbounds = False\n",
    "\n",
    "                    # cv2.circle(image, (int(x), int(y)), 1, (255, 0, 0), -1)\n",
    "\n",
    "            except(IndexError):\n",
    "                pass\n",
    "                # print(\"IndexError, circle bigger than image\")\n",
    "\n",
    "        if max_inlier_arc/counter > max_inlier_percent:\n",
    "            max_inlier_percent = inlier/counter\n",
    "            max_radius = int(radius)\n",
    "            max_center = (int(center[0]), int(center[1]))\n",
    "            max_arc_points = max_arc_points_current_circle.copy()\n",
    "\n",
    "            # with output:\n",
    "            #     # print(str(100.0*inlier/counter) + ' percent of a circle with radius ' + str(radius) + \" detected\")\n",
    "    for i in range(len(max_arc_points[0])):\n",
    "        cv2.circle(image, (max_arc_points[0][i], max_arc_points[1][i]), 2, (255, 0, 255), -1)\n",
    "    # cv2.circle(image, max_center, int(max_radius), (255, 0, 255), 2)\n",
    "    # (int(max_center[0]),int(max_center[1]))\n",
    "    cv2.imshow(\"window2\", image)\n",
    "    return max_radius, max_center\n",
    "\n",
    "\n",
    "\n",
    "dir_button.on_click(create_folder)\n",
    "\n",
    "display(fluid_volume)\n",
    "display(fluid_value_slider)\n",
    "display(threshold_value_slider)\n",
    "display(plot)\n",
    "display(img_folder)\n",
    "display(dir_button)\n",
    "display(progress)\n",
    "display(capture_dataframe)\n",
    "#display(text_input)\n",
    "#text.value= str(button.value)\n",
    "display(force_capture)\n",
    "stop_button = widgets.ToggleButton()\n",
    "stop_button.description = \"Stop\"\n",
    "display(stop_button)\n",
    "\n",
    "display(output)\n",
    "display(output_plot)\n",
    "\n",
    "# a method that returns the mean but rejects outliers from the calculation\n",
    "def mean_filter(data, threshold):\n",
    "    data_mean = mean(data)\n",
    "    data_std = stdev(data)\n",
    "    data_filtered = [x for x in data if abs(x - data_mean) < threshold * data_std]\n",
    "    return mean(data_filtered), stdev(data_filtered)\n",
    "\n",
    "async def f():   \n",
    "    i=0\n",
    "    size = [[],[],[],[],[],[],[]]\n",
    "    perimeter_buffer_list = []\n",
    "    area_buffer_list = []\n",
    "\n",
    "    perimeter_value_frame = []\n",
    "    area_value_frame = []\n",
    "    dataframe_count = 0\n",
    "    dataframe_total = 100\n",
    "\n",
    "    perimeter_frame_dict = {}\n",
    "    area_frame_dict = {}\n",
    "    area_buffer = []\n",
    "    area_precision_buff = []\n",
    "    perimeter_buffer = []\n",
    "    perimeter_precision_buff = []\n",
    "    buffer_size = BUFFER_SIZE\n",
    "    buffer_fill = 0\n",
    "    first = True\n",
    "\n",
    "    for i in range(buffer_size):\n",
    "        area_buffer.append(0)\n",
    "        perimeter_buffer.append(0)\n",
    "\n",
    "    stream = urllib.request.urlopen('http://' + camera_name +'.local/html/cam_pic.php')\n",
    "    bytes = b''\n",
    "    #os.chdir(image_dir)\n",
    "\n",
    "    WINDOW_NAME = \"Camera\"\n",
    "    cv2.namedWindow(WINDOW_NAME)\n",
    "    cv2.namedWindow(\"window2\")\n",
    "    cv2.startWindowThread()\n",
    "    print(\"hello\")\n",
    "\n",
    "    #transfer_function_coeffs = [-6.40190835e-05 , 1.00543104e-01 , -3.52312603e+01]\n",
    "    transfer_function_coeffs = [0.02130269, -11.15089045]\n",
    "\n",
    "\n",
    "    while True:\n",
    "        # grab the frame from the threaded video stream, resize it, and convert it to grayscale\n",
    "        curr_dt = datetime.now()\n",
    "        timestamp = int(round(curr_dt.timestamp()))\n",
    "    #     print(\"Integer timestamp of current datetime: \",\n",
    "    #       timestamp)\n",
    "        bytes += stream.read(1024)\n",
    "        a = bytes.find(b'\\xff\\xd8') #frame starting \n",
    "        b = bytes.find(b'\\xff\\xd9') #frame ending\n",
    "        if a != -1 and b != -1:\n",
    "            jpg = bytes[a:b+2]\n",
    "            bytes = bytes[b+2:]\n",
    "            frame = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_COLOR)\n",
    "\n",
    "\n",
    "            centerX = frame.shape[1]/2\n",
    "            centerY = frame.shape[0]/2\n",
    "            w = 300\n",
    "            h = 300\n",
    "            x = int(centerX - w/2)\n",
    "            y = int(centerY - h/2)\n",
    "            #crop frame to focus only on middle section\n",
    "            frame = frame[y:y+h, x:x+w]\n",
    "            start_image = frame.copy()\n",
    "            bytes = b''\n",
    "            url = 'http://' + camera_name +'.local/html/cam_pic.php?' + str(timestamp)\n",
    "            #print(url)\n",
    "            stream = urllib.request.urlopen(url)\n",
    "            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n",
    "            gray_blurred = cv2.medianBlur(gray,91)\n",
    "\n",
    "            perimeter = \"boof\"\n",
    "\n",
    "            rows = frame.shape[0]\n",
    "            # minDist is parameter 5 in houghcircles() but does not work will minDist=val\n",
    "            # param1 is sensitivity to edge detection, param2 is num points to detect circles\n",
    "            xOffset = 15\n",
    "            yOffset = -10\n",
    "            centerX = int(frame.shape[1] / 2)\n",
    "            centerY = int(frame.shape[0] / 2)\n",
    "            w = 100\n",
    "            h = 100\n",
    "           \n",
    "\n",
    "            if hough_mode:\n",
    "                trace_active_rectangle(frame, w, h, xOffset, yOffset)\n",
    "                #following 2 lines needed to avoid error when displaying\n",
    "\n",
    "                gray_blurred = cv2.cvtColor(gray_blurred, cv2.COLOR_GRAY2BGR)\n",
    "                mask = np.zeros(frame.shape[:2], dtype=\"uint8\") \n",
    "\n",
    "                ret, thresh = cv2.threshold(gray, 100, 255, cv2.THRESH_BINARY)\n",
    "                frame = thresh.copy()\n",
    "                frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)\n",
    "                #trace_active_rectangle(frame, w, h, xOffset, yOffset)\n",
    "\n",
    "                # w=100\n",
    "                # h=100\n",
    "\n",
    "                try:\n",
    "                    radius, center = get_best_circle(thresh)\n",
    "                    #         if center[0] < centerX + xOffset - int(w/2) or center[0] > centerX + xOffset + int(w/2) or center[1] < centerY + yOffset - int(h/2) or center[1] > centerY + yOffset + int(h/2):\n",
    "                    #             continue\n",
    "                    if radius != 0:\n",
    "                        cv2.circle(frame, center, radius, (255, 0, 255), 3)\n",
    "                        perimeter = float(radius)\n",
    "                        perimeter_buffer.pop(0)\n",
    "                        perimeter_buffer.append(perimeter)\n",
    "                        buffer_fill += 1\n",
    "                        area = 0 #placeholder\n",
    "                        area_buffer.pop(0)\n",
    "                        area_buffer.append(area)\n",
    "                            \n",
    "                except(Exception):\n",
    "                    # print info about the exception\n",
    "                    print(sys.exc_info())\n",
    "                    print(\"Error: \", Exception)\n",
    "                    #print the exception\n",
    "\n",
    "\n",
    "            else: #contour mode\n",
    "                if circle_mode:\n",
    "                    gray_blurred = cv2.medianBlur(gray,21)\n",
    "                    ret, thresh = cv2.threshold(gray_blurred, 150, 255, cv2.THRESH_BINARY_INV)\n",
    "                else: #ellipse mode\n",
    "                    gray_blurred = cv2.medianBlur(gray,21)\n",
    "                    ret, thresh = cv2.threshold(gray_blurred, threshold_value_slider.value, 255, cv2.THRESH_BINARY)\n",
    "\n",
    "                cnt = 0\n",
    "                # frame = thresh\n",
    "                # frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)\n",
    "                # trace_active_rectangle(frame, w, h, xOffset, yOffset)\n",
    "                gray_blurred = cv2.cvtColor(gray_blurred, cv2.COLOR_GRAY2BGR)\n",
    "\n",
    "                mask = np.zeros(frame.shape[:2], dtype=\"uint8\") #define mask out here to avoid crashing when exception is thrown\n",
    "                try:\n",
    "                    contours,hierarchy = cv2.findContours(thresh, 1, cv2.CHAIN_APPROX_NONE)\n",
    "                    # cv2.drawContours(frame, contours, -1, (0,255,0), 3)\n",
    "                    threshold_area_min = 3000     #threshold area \n",
    "                    threshold_area_max = 20000\n",
    "                    # contours, hierarchy = cv2.findContours(thresh,1,2)  \n",
    "                    # cnt = contours[0]\n",
    "                    found = False\n",
    "                    for cntr in contours:  \n",
    "                        area = cv2.contourArea(cntr) \n",
    "                        if  area > threshold_area_min and area < threshold_area_max: \n",
    "                            #removed circle mode check because tracking the center still helps us in ellipso mode\n",
    "\n",
    "                            #get minimum enclosing circle\n",
    "                           \n",
    "                            #get maximum inscribed circle\n",
    "                            inscribed_circle = False\n",
    "                            if inscribed_circle:\n",
    "                                cv2.drawContours(mask, [cntr], -1, 255, -1)\n",
    "                                # cv2.distanceTransform(mask, dist, distanceType, maskSize)\n",
    "                                dist = cv2.distanceTransform(mask, cv2.DIST_L2, 0)\n",
    "                                NULL,max_val,NULL,max_indx=cv2.minMaxLoc(dist)\n",
    "\n",
    "                                (x,y),radius = max_indx, max_val\n",
    "                            # print(max_val,max_indx)\n",
    "                            else:\n",
    "\n",
    "                                mask = thresh\n",
    "                                (x,y),radius = cv2.minEnclosingCircle(cntr)\n",
    "\n",
    "                            # masked = cv2.bitwise_and(gray_blurred, image, mask=mask)\n",
    "                            # draw the circle and centroid on the frame\n",
    "                            center = (int(x),int(y))\n",
    "                            if center[0] < centerX + xOffset - int(w/2) or center[0] > centerX + xOffset + int(w/2) or center[1] < centerY + yOffset - int(h/2) or center[1] > centerY + yOffset + int(h/2):\n",
    "                                continue\n",
    "\n",
    "                            radius = int(radius)\n",
    "\n",
    "                            cv2.circle(frame,center,radius,(255,255,0),2)\n",
    "                            cv2.circle(start_image,center,radius,(255,255,0),2)\n",
    "                            #get perimeter of circle\n",
    "\n",
    "                            #color = cyan\n",
    "                            # cv2.circle(frame,center,radius,(0,255,0),2)\n",
    "                            # cv2.circle(start_image,center,radius,(0,255,0),2)\n",
    "                            cnt = cntr\n",
    "                            area_buffer.pop(0)\n",
    "                            area_buffer.append(area)\n",
    "                            # perimeter_buffer.pop(0)\n",
    "                            # perimeter_buffer.append(perimeter)\n",
    "                            buffer_fill += 1\n",
    "\n",
    "                            if circle_mode:\n",
    "                                perimeter = 2*np.pi*radius\n",
    "                                perimeter_buffer.pop(0)\n",
    "                                perimeter_buffer.append(perimeter)\n",
    "\n",
    "                            else:\n",
    "                                ellipse = cv2.fitEllipse(cnt)\n",
    "                                cv2.ellipse(frame,ellipse,(255,0,255),2)\n",
    "                                (a,b) = ellipse[1]\n",
    "                                perimeter = (2 * 3.14 * sqrt((a * a + b * b) / (2 * 1.0)))\n",
    "                                perimeter_buffer.pop(0)\n",
    "                                perimeter_buffer.append(perimeter)\n",
    "                            \n",
    "                            break\n",
    "                        # cnt = contours[0]\n",
    "                        # M = cv2.moments(cnt)\n",
    "\n",
    "\n",
    "                    \n",
    "                    # let circle = cv.minEnclosingCircle(cnt);\n",
    "                    # let contoursColor = new cv.Scalar(255, 255, 255);\n",
    "                    # let circleColor = new cv.Scalar(255, 0, 0);\n",
    "                    # cv.drawContours(dst, contours, 0, contoursColor, 1, 8, hierarchy, 100);\n",
    "                    # cv.circle(dst, circle.center, circle.radius, circleColor);\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "                except Exception as e:\n",
    "                    print(e)\n",
    "\n",
    "                    \n",
    "            buffer_progress.value = min(buffer_fill, buffer_size)\n",
    "            # Display measured values on frame\n",
    "   \n",
    "            font = cv2.FONT_HERSHEY_SIMPLEX\n",
    "            #org = (50, 50)\n",
    "            fontScale = 0.5\n",
    "            color = (0, 136, 17)\n",
    "            thickness = 1\n",
    "            \n",
    "            filtered_mean, filtered_stdev = mean_filter(perimeter_buffer, 1)\n",
    "            try:\n",
    "                display_frame = cv2.putText(frame, \"per: \" + str(round(perimeter,2)), (50,50), font, \n",
    "                                    fontScale, color, thickness, cv2.LINE_AA)\n",
    "                # display_frame = cv2.putText(display_frame, \"mean: \" + str(round(mean(perimeter_buffer),2)), (50,75), font, \n",
    "                #                     fontScale, color, thickness, cv2.LINE_AA)\n",
    "                # # display_frame = cv2.putText(display_frame, \"stdev: \"+str(round(stdev(perimeter_buffer),2)), (300,50), font, \n",
    "                # #         fontScale, color, thickness, cv2.LINE_AA)\n",
    "                # display_frame = cv2.putText(display_frame, \"stdev: \"+str(round(stdev(perimeter_buffer),2)), (50,100), font, \n",
    "                #          fontScale, color, thickness, cv2.LINE_AA)\n",
    "                display_frame = cv2.putText(display_frame, \"var: \"+ str(round(variance(perimeter_buffer),2)), (300,75), font, \n",
    "                        fontScale, color, thickness, cv2.LINE_AA)\n",
    "\n",
    "\n",
    "\n",
    "                display_frame = cv2.putText(display_frame, \"mean: \" + str(round(filtered_mean,2)), (50,75), font, \n",
    "                                    fontScale, color, thickness, cv2.LINE_AA)\n",
    "                display_frame = cv2.putText(display_frame, \"stdev: \"+str(round(filtered_stdev,2)), (50,100), font, \n",
    "                         fontScale, color, thickness, cv2.LINE_AA)\n",
    "\n",
    "                # display_frame = cv2.putText(display_frame, \"volume estimate: \"+ str(round(np.polyval(transfer_function_coeffs, mean(perimeter_buffer)),2)).zfill(6) + \" ml\", (150,300), font, \n",
    "                #         fontScale, color, thickness, cv2.LINE_AA)\n",
    "                        \n",
    "            except Exception as e:\n",
    "                print(e)\n",
    "                display_frame = cv2.putText(frame, \"boof\", (50,100), font, \n",
    "                        fontScale, color, thickness, cv2.LINE_AA)\n",
    "            #display_frame = frame\n",
    "            display_frame = np.concatenate((display_frame, start_image), axis=1)\n",
    "            display_frame = np.concatenate((display_frame, gray_blurred), axis=1)\n",
    "            mask = cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)\n",
    "            display_frame = np.concatenate((display_frame, mask), axis=1)\n",
    "            # Display frame on screen\n",
    "            cv2.imshow(WINDOW_NAME, display_frame)\n",
    "            key = cv2.waitKey(1) & 0xFF\n",
    "            # if the 'q' key is pressed, stop the loop\n",
    "            if key == ord(\"q\"):\n",
    "                cv2.destroyAllWindows()\n",
    "                cv2.waitKey(1)\n",
    "                break\n",
    "            i += 1 \n",
    "\n",
    "            # After button is pressed, wait for stdev of perimeter to be below a certain threshold\n",
    "            # if stdev(perimeter_buffer) < 0.5 then capture a datapoint and reset buffer\n",
    "            # capture image\n",
    "            if capture_datapoint.value == True:\n",
    "                #i = 0\n",
    "\n",
    "                #if first time, buffer_fill = 0\n",
    "                if first:\n",
    "                    buffer_fill = 0\n",
    "                    first = False\n",
    "                    message = \"Taking datapoint for \" + fluid_volume.value + \" tenths of a ml\"\n",
    "                    output_plot.append_stdout(message +'\\n')\n",
    "                    # with output_plot:\n",
    "                    #     print(\"Taking datapoint for \" + fluid_volume.value + \" tenths of a ml\")\n",
    "\n",
    "                if(filtered_stdev <= stdev_threshold and buffer_fill >= buffer_size) or force_capture.value == True:\n",
    "\n",
    "                    force_capture.value = False\n",
    "                    perimeter_precision_buff.append(filtered_mean)\n",
    "                    area_precision_buff.append(mean(area_buffer))\n",
    "\n",
    "                    perimeter_named_data = [int(fluid_volume.value)/10]\n",
    "                    perimeter_named_data = perimeter_named_data + perimeter_buffer.copy()\n",
    "                    perimeter_buffer_list.append(perimeter_named_data.copy())\n",
    "\n",
    "                    area_named_data = [int(fluid_volume.value)/10]\n",
    "                    area_named_data = area_named_data + area_buffer.copy()\n",
    "                    area_buffer_list.append(area_named_data.copy())\n",
    "\n",
    "                    # list to csv\n",
    "                    with open(image_dir+img_folder.value+\"/\"+'area_buffer.csv', 'w') as f:\n",
    "                        writer = csv.writer(f)\n",
    "                        writer.writerows(area_buffer_list)\n",
    "                    with open(image_dir+img_folder.value+\"/\"+'perimeter_buffer.csv', 'w') as f:\n",
    "                        writer = csv.writer(f)\n",
    "                        writer.writerows(perimeter_buffer_list)\n",
    "\n",
    "\n",
    "\n",
    "                    \n",
    "                    #reset buffer (effectively)\n",
    "                    buffer_fill = 0\n",
    "                    capture_progress.value += 1\n",
    "                    if capture_progress.value >= int(PRECISION_BUFFER_SIZE):\n",
    "                        cv2.imwrite(image_dir+img_folder.value + \"/\" + fluid_volume.value+\".jpg\",frame)\n",
    "                        capture_datapoint.value = False\n",
    "                        first = True\n",
    "                        capture_progress.value = 0\n",
    "\n",
    "                        size[0].append(int(fluid_volume.value)/10)\n",
    "                        size[1].append(perimeter)\n",
    "                        # size[2].append(mean(perimeter_buffer))\n",
    "                        # size[3].append(stdev(perimeter_buffer))\n",
    "                        size[2].append(mean(perimeter_precision_buff))\n",
    "                        size[3].append(stdev(perimeter_precision_buff))\n",
    "                        # size[4].append(cv2.contourArea(cnt))\n",
    "                        size[4].append(area)\n",
    "                        # size[5].append(mean(area_buffer))\n",
    "                        # size[6].append(stdev(area_buffer))\n",
    "                        size[5].append(mean(area_precision_buff))\n",
    "                        size[6].append(stdev(area_precision_buff))\n",
    "                        \n",
    "                        # size[7].append(perimeter_buffer)\n",
    "                        # size[8].append(area_buffer)\n",
    "\n",
    "                        perimeter_frame_dict[fluid_volume.value] = perimeter_precision_buff\n",
    "                        perimeter_precision_buff = []\n",
    "                        area_frame_dict[fluid_volume.value] = area_precision_buff\n",
    "                        area_precision_buff = []\n",
    "                        df = pd.DataFrame(perimeter_frame_dict)\n",
    "                        df.to_csv(image_dir+img_folder.value+\"/\"+'perimeter_dataframe.csv')\n",
    "                        df = pd.DataFrame(area_frame_dict)\n",
    "                        df.to_csv(image_dir+img_folder.value+\"/\"+'area_dataframe.csv')\n",
    "\n",
    "                        fluid_volume.value = str(int(fluid_volume.value)+fluid_value_slider.value).zfill(2)\n",
    "                        message = \"ready for next capture, last mean: \" + str(round(filtered_mean,2))\n",
    "                        output_plot.append_stdout(message +'\\n')\n",
    "                # capture_dataframe.value = True\n",
    "            await asyncio.sleep(0.001)\n",
    "            \n",
    "            if capture_dataframe.value == True:\n",
    "                perimeter_value_frame.append(perimeter)\n",
    "                area_value_frame.append(cv2.contourArea(cnt))\n",
    "                dataframe_count += 1\n",
    "                progress.value = float(dataframe_count+1)/dataframe_total\n",
    "                if dataframe_count >= dataframe_total:\n",
    "                    capture_dataframe.value = False\n",
    "                    dataframe_count = 0\n",
    "\n",
    "                    #fill frames with data\n",
    "                    perimeter_frame_dict[fluid_volume.value] = perimeter_value_frame\n",
    "                    perimeter_value_frame = []\n",
    "                    area_frame_dict[fluid_volume.value] = area_value_frame\n",
    "                    area_value_frame = []\n",
    "                    df = pd.DataFrame(perimeter_frame_dict)\n",
    "                    df.to_csv(image_dir+img_folder.value+\"/\"+'perimeter_dataframe.csv')\n",
    "                    df = pd.DataFrame(area_frame_dict)\n",
    "                    df.to_csv(image_dir+img_folder.value+\"/\"+'area_dataframe.csv')\n",
    "                    \n",
    "                \n",
    "                \n",
    "            if plot.value == True:\n",
    "                #print(size)\n",
    "                plot.value = False\n",
    "                dict = {\"volume\" : size[0] , \"perimeter\" : size[1], \"perimeter_pb_mean\" : size[2],\"perimeter_pb_stdev\" : size[3], \"contour_area\" : size[4], \"contour_area_pb_mean\":size[5], \"contour_area_pb_stdev\":size[6]}\n",
    "                df = pd.DataFrame(dict) \n",
    "                # saving the dataframe \n",
    "                df.to_csv(image_dir+img_folder.value+\"/\"+'all_values.csv') \n",
    "\n",
    "                \n",
    "                try:\n",
    "                    fig, ax = plt.subplots()\n",
    "                    ax.errorbar(size[0], size[2], yerr=size[3],fmt=\"o\", mfc='red',\n",
    "                            mec='green')#, ms=20, mew=4)\n",
    "                    # plt.title(\"Light Diffusion Average\")\n",
    "                    # plt.show\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",
    "                    fig2, ax2 = plt.subplots()\n",
    "                    ax2.plot(size[0],size[2], 'ro')\n",
    "                    x=size[0]\n",
    "                    y=size[1]\n",
    "                    z = np.polyfit(x, y,1)\n",
    "                    p = np.poly1d(z)\n",
    "                    ax2.plot(x,p(x),'k--',linewidth=2)\n",
    "                    color = 0.8\n",
    "                    ax2.set_ylabel('Size ($mm^2$)')\n",
    "                    ax2.set_xlabel('ml')\n",
    "                    ax2.set_title(\"Light Diffusion Average\")\n",
    "                    plt.show()\n",
    "                    #print( \"y=%.6fx+(%.6f)\"%(z[0],z[1]))\n",
    "\n",
    "\n",
    "                    \n",
    "                except Exception as e:\n",
    "                    print(e)\n",
    "                    pass\n",
    "                    \n",
    "            if stop_button.value == True:\n",
    "                cv2.destroyAllWindows()\n",
    "                cv2.waitKey(1)\n",
    "                return\n",
    "        \n",
    "asyncio.create_task(f())\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d273f279",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e61e275",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad294d64",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import urllib.request\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "\n",
    "stream = urllib.request.urlopen('http://camerag11.local/html/cam_pic.php')\n",
    "bytes = b''\n",
    "while True:\n",
    "    \n",
    "\n",
    "    curr_dt = datetime.now()\n",
    "    timestamp = int(round(curr_dt.timestamp()))\n",
    "\n",
    "#     print(\"Integer timestamp of current datetime: \",\n",
    "#       timestamp)\n",
    "    bytes += stream.read(1024)\n",
    "    a = bytes.find(b'\\xff\\xd8') #frame starting \n",
    "    b = bytes.find(b'\\xff\\xd9') #frame ending\n",
    "    if a != -1 and b != -1:\n",
    "        jpg = bytes[a:b+2]\n",
    "        bytes = bytes[b+2:]\n",
    "        img = cv2.imdecode(np.frombuffer(jpg, dtype=np.uint8), cv2.IMREAD_COLOR)\n",
    "        cv2.imshow('image', img)\n",
    "        bytes = b''\n",
    "        url = 'http://camerag11.local/html/cam_pic.php?' + str(timestamp)\n",
    "        print(url)\n",
    "        stream = urllib.request.urlopen(url)\n",
    "        \n",
    "        if cv2.waitKey(1) == 27:\n",
    "            cv2.destroyAllWindows()\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "568718dc-ae88-4478-9039-f2ccb27b432f",
   "metadata": {},
   "outputs": [],
   "source": [
    "%gui asyncio\n",
    "import asyncio\n",
    "import ipywidgets as widgets\n",
    "\n",
    "button = widgets.ToggleButton()\n",
    "display(button)\n",
    "text = widgets.Text()\n",
    "text_input = widgets.Text()\n",
    "display(text)\n",
    "display(text_input)\n",
    "text.value= str(button.value)\n",
    "\n",
    "stop_button = widgets.ToggleButton()\n",
    "stop_button.description = \"Stop\"\n",
    "display(stop_button)\n",
    "\n",
    "async def f():   \n",
    "    i=0\n",
    "    while True:\n",
    "        i += 1\n",
    "        #text.value = str(i) + \" \" + str(button.value)\n",
    "        if button.value == True:\n",
    "            i = 0\n",
    "            button.value = False\n",
    "            text.value = text_input.value\n",
    "        await asyncio.sleep(0.001)\n",
    "        if stop_button.value == True:\n",
    "            return\n",
    "\n",
    "asyncio.create_task(f());"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  },
  "vscode": {
   "interpreter": {
    "hash": "3ec8f1b2517460a7fea7378739fe7664b5a33dfb55335b66cc1a5af5ab6bd4af"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}