Drop Splitting CAs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8bd83805",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import libraries======================================================================================\n",
    "import glob,os\n",
    "import matplotlib.pyplot as plt\n",
    "import cv2\n",
    "import shutil  \n",
    "import numpy as np\n",
    "from scipy.optimize import curve_fit\n",
    "from numpy import arange, array, arctan,pi, median\n",
    "import warnings\n",
    "import pandas as pd\n",
    "import natsort\n",
    "\n",
    "#Adjust Image Size (just for plotting)=================================================================\n",
    "plt.rcParams[\"figure.figsize\"] = (30,20)\n",
    "\n",
    "#Import updateXY Function==============================================================================\n",
    "def updateXY(Xpoint,Ypoint,Direction,i):\n",
    "    if Direction=='Up':\n",
    "        xl=int(Xpoint)\n",
    "        yl=int(Ypoint)-i\n",
    "    if Direction=='UR':\n",
    "        xl=int(Xpoint)+i\n",
    "        yl=int(Ypoint)-i\n",
    "    if Direction=='Right':\n",
    "        xl=int(Xpoint)+i\n",
    "        yl=int(Ypoint)\n",
    "    if Direction=='DR':\n",
    "        xl=int(Xpoint)+i\n",
    "        yl=int(Ypoint)+i\n",
    "    if Direction=='Down':\n",
    "        xl=int(Xpoint)\n",
    "        yl=int(Ypoint)+i\n",
    "    if Direction=='DL':\n",
    "        xl=int(Xpoint)-i\n",
    "        yl=int(Ypoint)+i\n",
    "    if Direction=='Left':\n",
    "        xl=int(Xpoint)-i\n",
    "        yl=int(Ypoint)\n",
    "    if Direction=='UL':\n",
    "        xl=int(Xpoint)-i\n",
    "        yl=int(Ypoint)-i\n",
    "    return(xl,yl)\n",
    "#Import IncreaseRes2 Function\n",
    "\n",
    "def IncreaseRes2(Image,Xpoint,Ypoint,IR_Thr,Direction):\n",
    "    X_next=[]\n",
    "    Y_next=[]\n",
    "    Reasons=[]\n",
    "    #Move and gather values\n",
    "    XL_next=[]\n",
    "    YL_next=[]\n",
    "    Value_next=[]\n",
    "    ThereIsNoAnswer=0\n",
    "    for i in range(10):\n",
    "        #Moving direction\n",
    "        xl,yl=updateXY(Xpoint,Ypoint,Direction,i)\n",
    "        #Making cordinations and values series\n",
    "        XL_next=XL_next+[xl]\n",
    "        YL_next=YL_next+[yl]\n",
    "        try:\n",
    "            Image[int(yl),int(xl)]\n",
    "        except:\n",
    "            ThereIsNoAnswer=1\n",
    "            Reasons=Reasons+['DimentionError']\n",
    "            break\n",
    "        Value_next=Value_next+[Image[int(yl),int(xl)]]\n",
    "        #Break If there is zero\n",
    "        if Image[int(yl),int(xl)]==0:\n",
    "            ThereIsNoAnswer=1\n",
    "            Reasons=Reasons+['ZeroNum']\n",
    "            break\n",
    "        #Break if the value is decreasing   \n",
    "        if len(Value_next) >1:\n",
    "            if Value_next[-2]>=Value_next[-1]:\n",
    "                ThereIsNoAnswer=1\n",
    "                Reasons=Reasons+['Decreasing']\n",
    "                break\n",
    "        #Break if is more than the Threshold\n",
    "        if Image[int(yl),int(xl)]>=IR_Thr:  \n",
    "            if len(Value_next)==1:\n",
    "                #Exception: No answer if direction has Zero\n",
    "                xl,yl=updateXY(Xpoint,Ypoint,Direction,i+1)\n",
    "                if Image[int(yl),int(xl)]==0:\n",
    "                    ThereIsNoAnswer=1\n",
    "                    Reasons=Reasons+['ZeroNum, wrong direction']\n",
    "                    break\n",
    "                if Value_next>Image[int(yl),int(xl)]:\n",
    "                    ThereIsNoAnswer=1\n",
    "                    Reasons=Reasons+['Decreasing, wrong direction']\n",
    "                    break          \n",
    "            Reasons=Reasons+['OK']\n",
    "            break\n",
    "    #Convert Value Matrix to differential value matrix \n",
    "    Converted_Value_next=Value_next.copy()\n",
    "    if ThereIsNoAnswer==0:\n",
    "        if len(Value_next)==1:\n",
    "            Converted_Value_next[0]=IR_Thr\n",
    "        if len(Value_next)>1:\n",
    "            for i in range(len(Value_next)-1):\n",
    "                if Converted_Value_next[i+1]>IR_Thr:\n",
    "                    Converted_Value_next[i+1]=IR_Thr-Value_next[i]\n",
    "                    break\n",
    "                Converted_Value_next[i+1]=Value_next[i+1]-Value_next[i]\n",
    "    if ThereIsNoAnswer==0:\n",
    "        Cumulative_Value=[] \n",
    "        for i in range(len(Converted_Value_next)):        \n",
    "            Cumulative_Value=Cumulative_Value+[XL_next[i]*Converted_Value_next[i]]\n",
    "        X_next=X_next+[np.array(Cumulative_Value).sum()/IR_Thr]\n",
    "        Cumulative_Value=[] \n",
    "        for i in range(len(Converted_Value_next)):\n",
    "            Cumulative_Value=Cumulative_Value+[YL_next[i]*Converted_Value_next[i]]\n",
    "        Y_next=Y_next+[np.array(Cumulative_Value).sum()/IR_Thr]\n",
    "    if ThereIsNoAnswer==1:\n",
    "        X_next=X_next+[0]\n",
    "        Y_next=Y_next+[0]\n",
    "        ThereIsNoAnswer=0\n",
    "    return(X_next, Y_next, Reasons)\n",
    "\n",
    "#Line equation\n",
    "def objective(x, a, b):\n",
    "    return a *x + b    \n",
    "\n",
    "def rotate_image(image, angle):\n",
    "    height, width = image.shape[:2]\n",
    "    rotation_matrix = cv2.getRotationMatrix2D((width / 2, height / 2), angle, 1)\n",
    "    rotated_image = cv2.warpAffine(image, rotation_matrix, (width, height))\n",
    "    return rotated_image\n",
    "\n",
    "def find_reds(pic):\n",
    "    red_xs=np.where(pic[:,:,0]!=pic[:,:,1])[1]\n",
    "    red_ys=np.where(pic[:,:,0]!=pic[:,:,1])[0]\n",
    "    return(red_xs,red_ys)\n",
    "    \n",
    "def morph(Img, kernel_size=(6,6)):\n",
    "    kernel = np.ones(kernel_size,np.uint8) \n",
    "    Img=cv2.morphologyEx(np.array(Img), cv2.MORPH_CLOSE, kernel)\n",
    "    Img=cv2.morphologyEx(np.array(Img), cv2.MORPH_OPEN, kernel)\n",
    "    return(Img)\n",
    "\n",
    "def find_anglepix(Img, Thr, YLength):\n",
    "    Img2=Img.copy()\n",
    "    # Find Advancing and Receding Pixels\n",
    "    X=[]\n",
    "    Y=[]\n",
    "    for y in np.arange(Img.shape[0]-YLength,Img.shape[0]):\n",
    "        for x in range(Img.shape[1]):\n",
    "             if Img[y,x,0] > Thr:\n",
    "                Img2[y,x,:]=[0,0,255]\n",
    "                X=X+[x]\n",
    "                Y=Y+[y]\n",
    "                break\n",
    "    return(X,Y,Img2)\n",
    "\n",
    "def increase_res(Img ,X, Y, IR_Thr, Dir='Right'):\n",
    "    X_updated=[]\n",
    "    for x in range(len(X)):\n",
    "        x_updated=IncreaseRes2(Img[:,:,0],X[x],Y[x],IR_Thr,Dir)[0]\n",
    "        X_updated=X_updated+x_updated\n",
    "    return(X_updated)\n",
    "\n",
    "def fit_line(X_updated,Y):\n",
    "    popt, _ = curve_fit(objective, X_updated, max(Y)-np.array(Y))\n",
    "    a, b = popt\n",
    "    x_line = np.arange(min(X_updated), max(X_updated), .00001)\n",
    "    y_line = objective(x_line, a, b)\n",
    "    return(x_line, y_line)\n",
    "\n",
    "def angle_calc(x_line,y_line):\n",
    "    if len(x_line)!=0:\n",
    "        dx=x_line[1]-x_line[0]\n",
    "        dy=y_line[1]-y_line[0]\n",
    "        gradian=arctan((dy)/(dx))\n",
    "        if dy*dx<0:\n",
    "            Rdegree=180+gradian*180/pi\n",
    "        if dy*dx>0:\n",
    "            Rdegree=gradian*180/pi\n",
    "    else:\n",
    "        Rdegree=90\n",
    "    return(Rdegree)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "87e399be-dc25-4650-a048-71d69887fad2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "glob: Built-in module (no version)\n",
      "os: Built-in module (no version)\n",
      "matplotlib: 3.8.0\n",
      "cv2: 4.10.0\n",
      "shutil: Built-in module (no version)\n",
      "numpy: 1.26.4\n",
      "scipy: 1.11.4\n",
      "pandas: 2.1.4\n",
      "natsort: 8.4.0\n"
     ]
    }
   ],
   "source": [
    "import glob\n",
    "import os\n",
    "import matplotlib\n",
    "import cv2\n",
    "import shutil\n",
    "import numpy as np\n",
    "from scipy import __version__ as scipy_version\n",
    "import warnings\n",
    "import pandas as pd\n",
    "import natsort\n",
    "\n",
    "# Print version of each library\n",
    "print(f\"glob: Built-in module (no version)\")\n",
    "print(f\"os: Built-in module (no version)\")\n",
    "print(f\"matplotlib: {matplotlib.__version__}\")\n",
    "print(f\"cv2: {cv2.__version__}\")\n",
    "print(f\"shutil: Built-in module (no version)\")\n",
    "print(f\"numpy: {np.__version__}\")\n",
    "print(f\"scipy: {scipy_version}\")\n",
    "print(f\"pandas: {pd.__version__}\")\n",
    "print(f\"natsort: {natsort.__version__}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f5e67fb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Frame Selecting+++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "1 : 1 __ 2 : 2 __ 3 : 3 __ 4 : 4 __ 5 : 5 __ 6 : 6 __ 7 : 7 __ 8 : 8 __ 9 : 9 __ 10 : 10 __ 11 : 11 __ 12 : 12 __ 13 : 13 __ 14 : 14 __ 15 : 15 __ 16 : 16 __ 17 : 17 __ 18 : 18 __ 19 : 19 __ 20 : 20 __ 21 : 21 __ 22 : 22 __ 23 : 23 __ 24 : 24 __ 25 : 25 __ 26 : 26 __ 27 : 27 __ 28 : 28 __ 29 : 29 __ 30 : 30 __ 31 : 31 __ 32 : 32 __ 33 : 33 __ 34 : 34 __ 35 : 35 __ 36 : 36 __ 37 : 37 __ 38 : 38 __ 39 : 39 __ 40 : 40 __ 41 : 41 __ 42 : 42 __ 43 : 43 __ 44 : 44 __ 45 : 45 __ 46 : 46 __ 47 : 47 __ 48 : 48 __ 49 : 49 __ 50 : 50 __ 51 : 51 __ 52 : 52 __ 53 : 53 __ 54 : 54 __ 55 : 55 __ 56 : 56 __ 57 : 57 __ 58 : 58 __ 59 : 59 __ 60 : 60 __ 61 : 61 __ 62 : 62 __ 63 : 63 __ 64 : 64 __ 65 : 65 __ 66 : 66 __ 67 : 67 __ 68 : 68 __ 69 : 69 __ 70 : 70 __ 71 : 71 __ 72 : 72 __ 73 : 73 __ 74 : 74 __ 75 : 75 __ 76 : 76 __ 77 : 77 __ 78 : 78 __ 79 : 79 __ 80 : 80 __ 81 : 81 __ 82 : 82 __ 83 : 83 __ 84 : 84 __ 85 : 85 __ 86 : 86 __ 87 : 87 __ 88 : 88 __ 89 : 89 __ 90 : 90 __ 91 : 91 __ 92 : 92 __ 93 : 93 __ 94 : 94 __ 95 : 95 __ 96 : 96 __ 97 : 97 __ 98 : 98 __ 99 : 99 __ 100 : 100 __ 101 : 101 __ 102 : 102 __ 103 : 103 __ 104 : 104 __ 105 : 105 __ 106 : 106 __ 107 : 107 __ 108 : 108 __ 109 : 109 __ 110 : 110 __ 111 : 111 __ 112 : 112 __ 113 : 113 __ 114 : 114 __ 115 : 115 __ 116 : 116 __ 117 : 117 __ 118 : 118 __ 119 : 119 __ 120 : 120 __ 121 : 121 __ 122 : 122 __ 123 : 123 __ 124 : 124 __ 125 : 125 __ 126 : 126 __ 127 : 127 __ 128 : 128 __ 129 : 129 __ "
     ]
    }
   ],
   "source": [
    "#What is the file address \n",
    "ad=os.getcwd()\n",
    "\n",
    "#What is the file name\n",
    "vidcap = cv2.VideoCapture(ad+\"\\\\\"+'example.avi')\n",
    "#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
    "\n",
    "#Convert Video to Frames\n",
    "#For chirag: if you did it once, please skip this cell for next time\n",
    "SelectingRate=1\n",
    "success,image = vidcap.read()\n",
    "count=0\n",
    "Num=0\n",
    "NewFolder=ad+\"\\\\\"+\"Frames\"\n",
    "try:\n",
    "    os.makedirs(NewFolder)\n",
    "except:\n",
    "    shutil.rmtree(NewFolder)\n",
    "    os.makedirs(NewFolder)\n",
    "NewFolder=ad+\"\\\\\"+\"Frames\"\n",
    "print('Frame Selecting+++++++++++++++++++++++++++++++++++++++++++++++++',end='\\n')\n",
    "while True:\n",
    "    count += SelectingRate\n",
    "    vidcap.set(cv2.CAP_PROP_POS_FRAMES, count)\n",
    "    success,image = vidcap.read()\n",
    "    if count%SelectingRate!=0:\n",
    "        continue\n",
    "    try:\n",
    "        Num+=1\n",
    "        print(Num,':',count,end=' __ ')\n",
    "        cv2.imwrite(NewFolder+\"\\\\\"+\"%d.tif\" % count, image)\n",
    "    except:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "214d290d",
   "metadata": {},
   "outputs": [],
   "source": [
    "Thr=80             #object detection threshold 60-120\n",
    "IR_Thr=160         #subpixel threshold 120-200\n",
    "YLength=10         #number of selected pixels for CA measurement\n",
    "noise_kernel=(6,6) #noise handling kernel\n",
    "\n",
    "up_margin=150      #margin to cut drop image from upside\n",
    "right_margin=25    #margin to cut drop image from rightside\n",
    "left_margin=25     #margin to cut drop image from leftside"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f2515911",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Make folders\n",
    "NewFolder_left=ad+\"\\\\\"+\"Frames\\\\left\"\n",
    "try:\n",
    "    os.makedirs(NewFolder_left)\n",
    "except:\n",
    "    shutil.rmtree(NewFolder_left)\n",
    "    os.makedirs(NewFolder_left)\n",
    "    \n",
    "NewFolder_right=ad+\"\\\\\"+\"Frames\\\\right\"\n",
    "try:\n",
    "    os.makedirs(NewFolder_right)\n",
    "except:\n",
    "    shutil.rmtree(NewFolder_right)\n",
    "    os.makedirs(NewFolder_right)\n",
    "\n",
    "#Load and find reds\n",
    "pic1=cv2.imread(ad+\"\\\\Frames\\\\slope\\\\1.bmp\")\n",
    "pic2=cv2.imread(ad+\"\\\\Frames\\\\slope\\\\2.bmp\")\n",
    "red1_xs,red1_ys=find_reds(pic1)\n",
    "red2_xs,red2_ys=find_reds(pic2)\n",
    "\n",
    "#which red blongs to which drop\n",
    "x1_left=min(red1_xs)\n",
    "x1_right=max(red1_xs)\n",
    "y1_left= red1_ys[red1_xs==x1_left]\n",
    "y1_right= red1_ys[red1_xs==x1_right]\n",
    "\n",
    "x2_left=min(red2_xs)\n",
    "x2_right=max(red2_xs)\n",
    "y2_left= red2_ys[red2_xs==x2_left]\n",
    "y2_right= red2_ys[red2_xs==x2_right]\n",
    "\n",
    "#LEFT+++++++++++++++++++++++++++++++++++++\n",
    "#calculate the angle and yline\n",
    "dx=x2_left-x1_left\n",
    "dy=y2_left-y1_left\n",
    "gradian=np.arctan((dy)/(dx))\n",
    "angle_left=gradian*180/np.pi\n",
    "\n",
    "rotated1_left=rotate_image(pic1, angle_left[0])\n",
    "rotated2_left=rotate_image(pic2, angle_left[0])\n",
    "\n",
    "\n",
    "#which red blongs to which drop\n",
    "xs_1_left, ys_1_left=find_reds(rotated1_left)\n",
    "xs_2_left, ys_2_left=find_reds(rotated2_left)\n",
    "y_left=min(ys_1_left)\n",
    "x_end_left=max(xs_1_left[ys_1_left==y_left])\n",
    "x_start_left=min(xs_2_left[ys_2_left==y_left])\n",
    "\n",
    "#save visual\n",
    "rotated1_left[y_left-up_margin,:,:]=[0,0,255]\n",
    "rotated1_left[y_left,:,:]=[0,0,255]\n",
    "rotated1_left[:,x_start_left-left_margin,:]=[0,0,255]\n",
    "rotated1_left[:,x_end_left+right_margin,:]=[0,0,255]\n",
    "rotated2_left[y_left-up_margin,:,:]=[0,0,255]\n",
    "rotated2_left[y_left,:,:]=[0,0,255]\n",
    "rotated2_left[:,x_start_left-left_margin,:]=[0,0,255]\n",
    "rotated2_left[:,x_end_left+right_margin,:]=[0,0,255]\n",
    "\n",
    "cv2.imwrite(NewFolder_left+\"\\\\0rotated1.tif\", rotated1_left)\n",
    "cv2.imwrite(NewFolder_left+\"\\\\0rotated2.tif\", rotated2_left)\n",
    "#RIGHT+++++++++++++++++++++++++++++++++++++\n",
    "#calculate the angle and yline\n",
    "dx=x2_right-x1_right\n",
    "dy=y2_right-y1_right\n",
    "gradian=np.arctan((dy)/(dx))\n",
    "angle_right=gradian*180/np.pi\n",
    "\n",
    "rotated1_right=rotate_image(pic1, angle_right[0])\n",
    "rotated1_right = cv2.flip(rotated1_right, 1)\n",
    "rotated2_right=rotate_image(pic2, angle_right[0])\n",
    "rotated2_right = cv2.flip(rotated2_right, 1)\n",
    "\n",
    "#which red blongs to which drop\n",
    "xs_1_right, ys_1_right=find_reds(rotated1_right)\n",
    "xs_2_right, ys_2_right=find_reds(rotated2_right)\n",
    "y_right=min(ys_1_right)\n",
    "x_end_right=max(xs_1_right[ys_1_right==y_right])\n",
    "x_start_right=min(xs_2_right[ys_2_right==y_right]) \n",
    "\n",
    "#save visual\n",
    "rotated1_right[y_right-up_margin,:,:]=[0,0,255]\n",
    "rotated1_right[y_right,:,:]=[0,0,255]\n",
    "rotated1_right[:,x_start_right-left_margin,:]=[0,0,255]\n",
    "rotated1_right[:,x_end_right+right_margin,:]=[0,0,255]\n",
    "rotated2_right[y_right-up_margin,:,:]=[0,0,255]\n",
    "rotated2_right[y_right,:,:]=[0,0,255]\n",
    "rotated2_right[:,x_start_right-left_margin,:]=[0,0,255]\n",
    "rotated2_right[:,x_end_right+right_margin,:]=[0,0,255]\n",
    "\n",
    "cv2.imwrite(NewFolder_right+\"\\\\0rotated1.tif\", rotated1_right)\n",
    "cv2.imwrite(NewFolder_right+\"\\\\0rotated2.tif\", rotated2_right)\n",
    "#Temp pic analysis+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n",
    "\n",
    "\n",
    "FileName=sorted(os.listdir(ad+\"\\\\\"+\"Frames\"))\n",
    "FileNames=[]\n",
    "for i in range(len(FileName)):\n",
    "    try:\n",
    "        if FileName[i].split(\".\")[1]==\"tif\":\n",
    "            FileNames=FileNames+[FileName[i]]\n",
    "    except:\n",
    "        pass\n",
    "FileNames=natsort.natsorted(FileNames)\n",
    "\n",
    "x_left_list=[]\n",
    "x_right_list=[]\n",
    "angle_left_list=[]\n",
    "angle_right_list=[]\n",
    "I=[]\n",
    "file_names=[]\n",
    "for i in range(len(FileNames)):\n",
    "    pic_temp=cv2.imread(ad+\"\\\\Frames\\\\\"+FileNames[i])\n",
    "    pic_temp=morph(pic_temp, kernel_size=noise_kernel)\n",
    "    pic_temp=255-pic_temp\n",
    "\n",
    "    #Left angle and vel\n",
    "    pic_temp_left=rotate_image(pic_temp, angle_left[0])\n",
    "    pic_temp_left=pic_temp_left[y_left-up_margin:y_left,x_start_left-left_margin:x_end_left+right_margin,:]\n",
    "    X_left,Y_left,pic_temp2_left= find_anglepix(pic_temp_left, Thr, YLength)\n",
    "    X_updated_left=increase_res(pic_temp_left ,X_left, Y_left, IR_Thr, Dir='Right')\n",
    "    x_line_left, y_line_left=fit_line(X_updated_left,Y_left)\n",
    "    left_angle=angle_calc(x_line_left,y_line_left)\n",
    "\n",
    "    x_left_list=x_left_list+[np.mean(x_line_left)]\n",
    "    angle_left_list=angle_left_list+[left_angle]\n",
    "    cv2.imwrite(NewFolder_left+\"\\\\\"+FileNames[i], pic_temp2_left)\n",
    "\n",
    "\n",
    "    #Right angle and vel\n",
    "    pic_temp_right=rotate_image(pic_temp, angle_right[0])\n",
    "    pic_temp_right = cv2.flip(pic_temp_right, 1)\n",
    "    pic_temp_right=pic_temp_right[y_right-up_margin:y_right,x_start_right-left_margin:x_end_right+right_margin,:]\n",
    "    X_right,Y_right,pic_temp2_right= find_anglepix(pic_temp_right, Thr, YLength)\n",
    "    X_updated_right=increase_res(pic_temp_right ,X_right, Y_right, IR_Thr, Dir='Right')\n",
    "    x_line_right, y_line_right=fit_line(X_updated_right,Y_right)\n",
    "    right_angle=angle_calc(x_line_right,y_line_right)\n",
    "\n",
    "    x_right_list=x_right_list+[np.mean(x_line_right)]\n",
    "    angle_right_list=angle_right_list+[right_angle]\n",
    "    cv2.imwrite(NewFolder_right+\"\\\\\"+FileNames[i], pic_temp2_right)\n",
    "    \n",
    "    I=I+[i]\n",
    "    file_names=file_names+[int(FileNames[i].split(\".\")[0])]\n",
    "\n",
    "v_right_list=[]\n",
    "for i in range(len(x_right_list)-1):\n",
    "    v_right_list=v_right_list+[np.abs(x_right_list[i+1]-x_right_list[i])]\n",
    "    \n",
    "v_left_list=[]\n",
    "for i in range(len(x_left_list)-1):\n",
    "    v_left_list=v_left_list+[np.abs(x_left_list[i+1]-x_left_list[i])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e1ceac53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 3000x2000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 3000x2000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pixel_cm= 250 #how many pixel in a cm?\n",
    "fps=100\n",
    "\n",
    "x_right_list_cm=np.array(x_right_list)/pixel_cm\n",
    "x_left_list_cm=np.array(x_left_list)/pixel_cm\n",
    "x_right_list_cm=max(x_right_list_cm)-x_right_list_cm\n",
    "x_left_list_cm=max(x_left_list_cm)-x_left_list_cm\n",
    "\n",
    "plt.plot(x_right_list_cm, angle_right_list, color=\"black\", linewidth=4, label=\"right side angle\")\n",
    "plt.plot(x_left_list_cm, angle_left_list, color=\"red\", linewidth=4, label=\"left side angle\")\n",
    "\n",
    "plt.rc('xtick', labelsize=35) \n",
    "plt.rc('ytick', labelsize=35) \n",
    "font_size=35\n",
    "plt.xlabel('slide length (cm)',fontdict={'size':font_size})\n",
    "plt.ylabel('Contact angles (degree)',fontdict={'size':font_size})\n",
    "plt.legend(fontsize=font_size)\n",
    "plt.savefig(ad+\"\\\\Frames\\\\\"+\"results CAs.png\") \n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "v_right_list=[]\n",
    "for i in range(len(x_right_list_cm)-1):\n",
    "    v_right_list=v_right_list+[np.abs(x_right_list_cm[i+1]-x_right_list_cm[i])]\n",
    "    \n",
    "v_left_list=[]\n",
    "for i in range(len(x_left_list_cm)-1):\n",
    "    v_left_list=v_left_list+[np.abs(x_left_list_cm[i+1]-x_left_list_cm[i])]\n",
    "\n",
    "v_right_list=np.array(v_right_list)*fps\n",
    "v_left_list=np.array(v_left_list)*fps\n",
    "\n",
    "plt.plot(x_right_list_cm[:-1], v_right_list, color=\"black\", linewidth=4, label=\"right side velocity\")\n",
    "plt.plot(x_left_list_cm[:-1], v_left_list, color=\"red\", linewidth=4, label=\"left side velocity\")\n",
    "\n",
    "plt.rc('xtick', labelsize=35) \n",
    "plt.rc('ytick', labelsize=35) \n",
    "font_size=35\n",
    "plt.xlabel('slide length (cm)',fontdict={'size':font_size})\n",
    "plt.ylabel('Velocity (cm/s)',fontdict={'size':font_size})\n",
    "plt.legend(fontsize=font_size)\n",
    "plt.savefig(ad+\"\\\\Frames\\\\\"+\"results velocity.png\") \n",
    "plt.show()\n",
    "\n",
    "pd.DataFrame([I, file_names, x_right_list_cm, x_left_list_cm, angle_left_list, angle_right_list, v_left_list, v_right_list],index=[\"number\", \"file number\", \"x_right_list (cm)\", \"x_left_list (cm)\",\"angle left\", \"angle right\", \"velocity left (cm/s)\", \"velocity right (cm/s)\"]).T.to_excel(ad+\"\\\\Frames\\\\\"+\"results.xlsx\")"
   ]
  }
 ],
 "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}