{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import threading\n",
    "import time, os, json\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import multiprocessing as mp\n",
    "\n",
    "from scipy import stats, signal\n",
    "from situtils import FPSTimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO - write an Agent class and unify position/HD tracking for multiple agents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionTrackerBase(FPSTimes):\n",
    "    \n",
    "    default_cfg = {\n",
    "        \"single_agent\": True,\n",
    "        \"background_light\": \"background_light.png\",\n",
    "        \"background_dark\": \"background_dark.png\",\n",
    "        \"threshold_light\": 60,\n",
    "        \"threshold_dark\": 30,\n",
    "        \"min_blob_size\": 100,\n",
    "        \"subtract\": 1,\n",
    "        \"arena_x\": 522,\n",
    "        \"arena_y\": 372,\n",
    "        \"arena_radius\": 330,\n",
    "        \"floor_radius\": 287,\n",
    "        \"max_fps\": 50,\n",
    "        \"file_path\": \"positions.csv\",\n",
    "        \"contour_path\": \"contours.csv\",\n",
    "        \"floor_r_in_meters\": 0.46,\n",
    "        \"angle_compensation\": -90,\n",
    "        \"flip_x\": True,\n",
    "        \"flip_y\": False\n",
    "    }\n",
    "    \n",
    "    def __init__(self, status, video_stream, cfg):\n",
    "        super(PositionTrackerBase, self).__init__()\n",
    "        \n",
    "        self.status = status\n",
    "        self.cfg = cfg\n",
    "        self.video_stream = video_stream\n",
    "        self.bg_light = cv2.imread(cfg['background_light'], 1)\n",
    "        self.bg_dark  = cv2.imread(cfg['background_dark'], 1)\n",
    "        self.background = self.bg_light  # light by default\n",
    "        self.is_light = True\n",
    "        self.pixel_size = cfg['floor_r_in_meters'] / float(cfg['floor_radius'])\n",
    "        self.stopped = False\n",
    "        self.mask = np.zeros(shape=self.background.shape, dtype=\"uint8\")\n",
    "        cv2.circle(self.mask, (cfg['arena_x'], cfg['arena_y']), cfg['arena_radius'], (255,255,255), -1)\n",
    "\n",
    "    def reload_background(self):\n",
    "        self.bg_light = cv2.imread(self.cfg['background_light'], 1)\n",
    "        self.bg_dark  = cv2.imread(self.cfg['background_dark'], 1)\n",
    "        self.background = self.bg_light if self.is_light else self.bg_dark\n",
    "        print('Position tracker - background reloaded')\n",
    "\n",
    "    def switch_background(self):\n",
    "        self.background = self.bg_dark if self.is_light else self.bg_light \n",
    "        self.is_light = not self.is_light\n",
    "        \n",
    "    def px_to_meters(self, x, y):\n",
    "        x_m = float(self.cfg['arena_x'] - x) * self.pixel_size * (-1 if self.cfg['flip_x'] else 1)\n",
    "        y_m = float(self.cfg['arena_y'] - y) * self.pixel_size * (-1 if self.cfg['flip_y'] else 1)\n",
    "        return x_m, y_m\n",
    "\n",
    "    def meters_to_px(self, x, y):\n",
    "        x_m = self.cfg['arena_x'] - (x / self.pixel_size) * (-1 if self.cfg['flip_x'] else 1)\n",
    "        y_m = self.cfg['arena_y'] - (y / self.pixel_size) * (-1 if self.cfg['flip_y'] else 1)\n",
    "        return int(x_m), int(y_m)\n",
    "\n",
    "    def correct_angle(self, phi):\n",
    "        return (2*np.pi - phi) + np.deg2rad(self.cfg['angle_compensation'])\n",
    "\n",
    "    def is_inside(self, x, y, r):\n",
    "        for pos in self.positions_in_m:\n",
    "            if (pos[0] - x)**2 + (pos[1] - y)**2 <= r**2:\n",
    "                return True\n",
    "        return False\n",
    "    \n",
    "    def start(self):\n",
    "        self._th = threading.Thread(target=self.update, args=())\n",
    "        self._th.start()\n",
    "    \n",
    "    def stop(self):\n",
    "        self.stopped = True\n",
    "        self._th.join()\n",
    "        print('Position tracker stopped')\n",
    "        \n",
    "    def update(self):\n",
    "        next_frame = time.time() + 1.0/self.cfg['max_fps']\n",
    "        \n",
    "        while not self.stopped:\n",
    "            frame = self.video_stream.read()\n",
    "            if frame is None:\n",
    "                time.sleep(0.05)\n",
    "                continue\n",
    "                \n",
    "            if time.time() < next_frame:\n",
    "                time.sleep(0.001)\n",
    "                continue\n",
    "                \n",
    "            self.count()  # count FPS\n",
    "            self.detect_position(frame)\n",
    "            next_frame += 1.0/self.cfg['max_fps']\n",
    "\n",
    "            if self.status.value == 2 and self.positions_in_px is not None:\n",
    "                self.save_position()\n",
    "                self.save_contours()                  \n",
    "\n",
    "    # generic interface\n",
    "\n",
    "    def detect_position(self, frame):\n",
    "        return NotImplemented\n",
    "\n",
    "    def save_position(self):\n",
    "        return NotImplemented\n",
    "    \n",
    "    def save_contours(self):\n",
    "        return NotImplemented\n",
    "    \n",
    "    @property\n",
    "    def positions_in_px(self):\n",
    "        # a list of pairs [(Xi, Yi), ...] of actual positions for each agent tracked - in pixels\n",
    "        return NotImplemented\n",
    "    \n",
    "    @property\n",
    "    def positions_in_m(self):\n",
    "        # a list of pairs [(Xi, Yi), ...] of actual positions for each agent tracked - in meters\n",
    "        return NotImplemented\n",
    "    \n",
    "    @property\n",
    "    def contours(self):\n",
    "        return NotImplemented\n",
    "    \n",
    "    @property\n",
    "    def speeds(self):\n",
    "        return NotImplemented\n",
    "    \n",
    "    @property\n",
    "    def hds(self):\n",
    "        return NotImplemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionTrackerSingle(PositionTrackerBase):\n",
    "    \n",
    "    def __init__(self, status, video_stream, cfg):\n",
    "        super(PositionTrackerSingle, self).__init__(status, video_stream, cfg)\n",
    "        \n",
    "        # an array of [[t1, X1, Y1, speed1, HD1], [t2, X2, Y2, speed2, HD2], ...] of 'history_duration' length\n",
    "        # X, Y - in pixels, Speed - in m/s, head direction (HD) - in rad\n",
    "        self._positions_list = None  \n",
    "        self._contour = None\n",
    "        self._lr = None  # linear regression of the contour\n",
    "        \n",
    "        width = 50  # 50 points ~= 1 sec with at 50Hz - to smooth the trajectory\n",
    "        self.kernel = signal.gaussian(width, std=(width) / 7.2)\n",
    "        \n",
    "        with open(cfg['file_path'], 'w') as f:\n",
    "            f.write(\"time,x,y\\n\")\n",
    "        with open(cfg['contour_path'], 'w') as f:\n",
    "            f.write(\"x:y,...\\n\")\n",
    "            \n",
    "    def detect_position(self, frame):\n",
    "        masked_frame = cv2.bitwise_and(src1=frame, src2=self.mask)\n",
    "\n",
    "        # Substracts background from current frame or takes absdiff\n",
    "        if 'subtract' in self.cfg:\n",
    "            if self.cfg['subtract'] > 0:\n",
    "                subject = cv2.subtract(self.background, masked_frame)\n",
    "            else:\n",
    "                subject = cv2.subtract(self.background, masked_frame)\n",
    "        else:\n",
    "            subject = cv2.absdiff(masked_frame, self.background)\n",
    "\n",
    "        # Converts subject to grey scale\n",
    "        subject_gray = cv2.cvtColor(subject, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "        # Applies blur and thresholding to the subject\n",
    "        kernel_size = (25,25)\n",
    "        frame_blur = cv2.GaussianBlur(subject_gray, kernel_size, 0)\n",
    "        th = self.cfg['threshold_light'] if self.is_light else self.cfg['threshold_dark']\n",
    "        _, thresh = cv2.threshold(frame_blur, th, 255, cv2.THRESH_BINARY)\n",
    "\n",
    "        # Finds contours and selects the contour with the largest area\n",
    "        contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n",
    "\n",
    "        if len(contours) == 0:\n",
    "            return\n",
    "        contour = contours[np.argmax(list(map(cv2.contourArea, contours)))]\n",
    "        M = cv2.moments(contour)\n",
    "        if (M['m00'] == 0):\n",
    "            return\n",
    "\n",
    "        x, y = M['m10'] / M['m00'], M['m01'] / M['m00']\n",
    "        if self._positions_list is None:\n",
    "            self._positions_list = np.array([[time.time(), x, y, 0, 0]])\n",
    "        else:\n",
    "            t1 = time.time() - self.cfg['history_duration']\n",
    "            idx = np.argmin(np.abs(self._positions_list[:, 0] - t1))\n",
    "            last_hd = self._positions_list[-1][4]\n",
    "            self._positions_list = np.concatenate([self._positions_list[idx:], [np.array([time.time(), x, y, 0, last_hd])]])\n",
    "\n",
    "        # speed\n",
    "        if len(self._positions_list) > len(self.kernel):\n",
    "            x = (-self._positions_list[:, 1] + self.cfg['arena_x']) * self.pixel_size * (-1 if self.cfg['flip_x'] else 1)\n",
    "            y = (-self._positions_list[:, 2] + self.cfg['arena_y']) * self.pixel_size * (-1 if self.cfg['flip_y'] else 1)\n",
    "            \n",
    "            # to avoid boundary effects\n",
    "            x = np.concatenate([np.ones(int(len(self.kernel)/2) - 1) * x[0], x, np.ones(int(len(self.kernel)/2)) * x[-1]])\n",
    "            y = np.concatenate([np.ones(int(len(self.kernel)/2) - 1) * y[0], y, np.ones(int(len(self.kernel)/2)) * y[-1]])\n",
    "            \n",
    "            x_smooth = np.convolve(x, self.kernel, 'valid') / self.kernel.sum()  # valid mode to avoid boundary effects\n",
    "            y_smooth = np.convolve(y, self.kernel, 'valid') / self.kernel.sum()\n",
    "\n",
    "            dx = np.sqrt(np.square(np.diff(x_smooth)) + np.square(np.diff(y_smooth)))\n",
    "            dt = np.diff(self._positions_list[:, 0])\n",
    "            speed = np.concatenate([dx/dt, [dx[-1]/dt[-1]]])\n",
    "            self._positions_list[:, 3] = speed  # in m/s\n",
    "        \n",
    "        # head direction\n",
    "        recent_traj = self._positions_list[self._positions_list[:, 0] > time.time() - 0.25]\n",
    "        avg_speed = recent_traj[:, 3].mean()\n",
    "        if avg_speed > self.cfg['hd_update_speed'] and len(recent_traj) > 3:  # if animal runs basically\n",
    "            x, y = recent_traj[0][1], recent_traj[0][2]\n",
    "            vectors = [np.array([a[1], a[2]]) - np.array([x, y]) for a in recent_traj[1:]]\n",
    "            avg_direction = np.array(vectors).sum(axis=0) / len(vectors)\n",
    "\n",
    "            avg_angle = -np.arctan2(avg_direction[1], avg_direction[0])\n",
    "            self._positions_list[-1][4] = avg_angle  # in radians\n",
    "                \n",
    "        self._contour = contour  # in pixels\n",
    "        \n",
    "        #ctr_in_px = np.array([x for x in zip(contour[:, 0, 0], contour[:, 0, 1])])\n",
    "        #if ctr_in_px[:, 0].max() - ctr_in_px[:, 0].min() > ctr_in_px[:, 1].max() - ctr_in_px[:, 1].min():\n",
    "        #    slope, intercept, r_value, p_value, std_err = stats.linregress(ctr_in_px[:, 0], ctr_in_px[:, 1])\n",
    "        #    self.lr = {'slope': slope, 'intercept': intercept, 'r_value': r_value, 'p_value': p_value, 'std_err': std_err}\n",
    "        #else:\n",
    "        #    slope, intercept, r_value, p_value, std_err = stats.linregress(ctr_in_px[:, 1], ctr_in_px[:, 0])\n",
    "        #    self.lr = {'slope': 1 - slope, 'intercept': intercept, 'r_value': r_value, 'p_value': p_value, 'std_err': std_err}\n",
    "\n",
    "    def save_position(self):\n",
    "        if self.positions_in_px is None:\n",
    "            return\n",
    "        with open(self.cfg['file_path'], 'a') as f:\n",
    "            f.write(\",\".join([str(x) for x in (self.frame_times[-1], \\\n",
    "                   round(self.positions_in_m[0][0], 4), round(self.positions_in_m[0][1], 4))]) + \"\\n\") \n",
    "    \n",
    "    def save_contours(self):\n",
    "        if self.contours is None:\n",
    "            return\n",
    "        ctr_in_m = np.array([self.px_to_meters(x, y) for x, y in zip(self._contour[:, 0, 0], self._contour[:, 0, 1])])\n",
    "        data = [\"%.4f:%.4f\" % (x[0], x[1]) for x in ctr_in_m]\n",
    "        with open(self.cfg['contour_path'], 'a+') as f:    \n",
    "            f.write(\",\".join(data) + \"\\n\")\n",
    "    \n",
    "    @property\n",
    "    def positions_in_px(self):\n",
    "        return [self._positions_list[-1][1:].astype('int32')] if self._positions_list is not None else None\n",
    "    \n",
    "    @property\n",
    "    def positions_in_m(self):\n",
    "        if self._positions_list is None:\n",
    "            return None\n",
    "        x = (self.cfg['arena_x'] - self._positions_list[-1][1]) * self.pixel_size * (-1 if self.cfg['flip_x'] else 1)\n",
    "        y = (self.cfg['arena_y'] - self._positions_list[-1][2]) * self.pixel_size * (-1 if self.cfg['flip_y'] else 1)\n",
    "        return [np.array([x, y])]\n",
    "    \n",
    "    @property\n",
    "    def contours(self):\n",
    "        return [self._contour] if self._contour is not None else None\n",
    "    \n",
    "    @property\n",
    "    def speeds(self):\n",
    "        return [self._positions_list[-1][3]] if self._positions_list is not None else None\n",
    "    \n",
    "    @property\n",
    "    def hds(self):\n",
    "        return [np.degrees(self._positions_list[-1][4])] if self._positions_list is not None else None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PositionTrackerDouble(PositionTrackerBase):\n",
    "    \n",
    "    def __init__(self, status, video_stream, cfg):\n",
    "        super(PositionTrackerDouble, self).__init__(status, video_stream, cfg)\n",
    "\n",
    "        self._dist_array = []\n",
    "        self._positions_list_1, self._positions_list_2 = None, None\n",
    "        self._contour1, self._contour2 = [], []\n",
    "       \n",
    "        with open(cfg['file_path'], 'w') as f:\n",
    "            f.write(\"time,x1,y1,x2,y2\\n\")\n",
    "        with open(cfg['contour_path'], 'w') as f:\n",
    "            f.write(\"x:y,...\\n\")\n",
    "\n",
    "    def detect_position(self, frame):\n",
    "        masked_frame = cv2.bitwise_and(src1=frame, src2=self.mask)\n",
    "\n",
    "        # Substracts background from current frame or takes absdiff\n",
    "        if 'subtract' in self.cfg:\n",
    "            if self.cfg['subtract'] > 0:\n",
    "                subject = cv2.subtract(self.background, masked_frame)\n",
    "            else:\n",
    "                subject = cv2.subtract(self.background, masked_frame)\n",
    "        else:\n",
    "            subject = cv2.absdiff(masked_frame, self.background)\n",
    "\n",
    "        # Converts subject to grey scale\n",
    "        subject_gray = cv2.cvtColor(subject, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "        # Applies blur and thresholding to the subject\n",
    "        kernel_size = (25,25)\n",
    "        frame_blur = cv2.GaussianBlur(subject_gray, kernel_size, 0)\n",
    "        th = self.cfg['threshold_light'] if self.is_light else self.cfg['threshold_dark']\n",
    "        _, thresh = cv2.threshold(frame_blur, th, 255, cv2.THRESH_BINARY)\n",
    "\n",
    "        # Finds contours and selects the contour with the largest area\n",
    "        contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n",
    "\n",
    "        # filter by size\n",
    "        blobs = [cnt for cnt in contours if cv2.contourArea(cnt) > self.cfg['min_blob_size']]\n",
    "        if len(blobs) == 0:  # do nothing if nothing is identified\n",
    "            return\n",
    "        \n",
    "        sizes = [int(cv2.contourArea(blob)) for blob in blobs]\n",
    "        blobs = [blobs[i] for i in np.argsort(sizes)][:2]  # two largest blobs\n",
    "        \n",
    "        if len(blobs) == 1:  # when two objects are together\n",
    "            blobs.append(np.array(blobs[0]))\n",
    "        \n",
    "        #if np.random.rand() > 0.5:  # randomize for testing\n",
    "        #    blobs[0], blobs[1] = blobs[1], blobs[0]\n",
    "            \n",
    "        M1 = cv2.moments(blobs[0])\n",
    "        M2 = cv2.moments(blobs[1])\n",
    "        if M1['m00'] == 0 or M2['m00'] == 0:\n",
    "            return\n",
    "        \n",
    "        xy1 = np.array([M1['m10'] / M1['m00'], M1['m01'] / M1['m00']])  # single pair\n",
    "        xy2 = np.array([M2['m10'] / M2['m00'], M2['m01'] / M2['m00']])  # single pair\n",
    "\n",
    "        if self._positions_list_1 is None:  # first detected coordinates\n",
    "            self._positions_list_1 = np.array([xy1])  # array of XY pairs\n",
    "            self._positions_list_2 = np.array([xy2])  # array of XY pairs\n",
    "\n",
    "        else:\n",
    "            idx = 0 if len(self._positions_list_1) < 20 else 1  # append or shift position list, collecting position history\n",
    "\n",
    "            # compute distance matrix: current XY1 and XY2 to previous positions\n",
    "            dist_array = []\n",
    "            for point in (xy1, xy2):\n",
    "                for p_list in (self._positions_list_1, self._positions_list_2):\n",
    "                    distance = np.sqrt( ((p_list[:, 0] - point[0]).mean())**2 + \\\n",
    "                        ((p_list[:, 1] - point[1]).mean())**2 )\n",
    "                    dist_array.append(distance)\n",
    "\n",
    "            self._dist_array = dist_array\n",
    "\n",
    "            if np.argmin(np.array(dist_array)) < 1 or np.argmin(np.array(dist_array)) > 2: # 1 goes to 1, 2 to 2\n",
    "                self._positions_list_1 = np.concatenate([self._positions_list_1[idx:], [xy1]])\n",
    "                self._positions_list_2 = np.concatenate([self._positions_list_2[idx:], [xy2]])\n",
    "                self._contour1, self._contour2 = blobs[0], blobs[1]\n",
    "            else:  # swap\n",
    "                self._positions_list_1 = np.concatenate([self._positions_list_1[idx:], [xy2]])\n",
    "                self._positions_list_2 = np.concatenate([self._positions_list_2[idx:], [xy1]])\n",
    "                self._contour1, self._contour2 = blobs[1], blobs[0]\n",
    "\n",
    "    def save_position(self):\n",
    "        if self.positions_in_px is None:\n",
    "            return        \n",
    "        with open(self.cfg['file_path'], 'a') as f:  # save position\n",
    "            data = self.positions_in_m\n",
    "            f.write(\",\".join([str(x) for x in (self.frame_times[-1], \\\n",
    "                   round(data[0][0], 4), round(data[0][1], 4), round(data[1][0], 4), round(data[1][1], 4))]) + \"\\n\")         \n",
    "                    \n",
    "    def save_contours(self):\n",
    "        if self.contours is None:\n",
    "            return\n",
    "        ctr1_in_m = np.array([self.px_to_meters(x, y) for x, y in zip(self._contour1[:, 0, 0], self._contour1[:, 0, 1])])\n",
    "        ctr2_in_m = np.array([self.px_to_meters(x, y) for x, y in zip(self._contour2[:, 0, 0], self._contour2[:, 0, 1])])\n",
    "        data1 = [\"%.4f:%.4f\" % (x[0], x[1]) for x in ctr1_in_m]\n",
    "        data2 = [\"%.4f:%.4f\" % (x[0], x[1]) for x in ctr2_in_m]\n",
    "        with open(self.cfg['contour_path'], 'a+') as f:    \n",
    "            f.write(\",\".join(data1) + \";\" + \",\".join(data2) + \"\\n\") \n",
    "                \n",
    "    @property\n",
    "    def positions_in_px(self):\n",
    "        if self._positions_list_1 is None:\n",
    "            return None\n",
    "        x1, y1 = self._positions_list_1[-1].astype('int32')\n",
    "        x2, y2 = self._positions_list_2[-1].astype('int32')\n",
    "        return np.array([[x1, y1], [x2, y2]])\n",
    "    \n",
    "    @property\n",
    "    def positions_in_m(self):\n",
    "        if self._positions_list_1 is None:\n",
    "            return None\n",
    "        x1 = (self.cfg['arena_x'] - self._positions_list_1[-1][0]) * self.pixel_size * (-1 if self.cfg['flip_x'] else 1)\n",
    "        y1 = (self.cfg['arena_y'] - self._positions_list_1[-1][1]) * self.pixel_size * (-1 if self.cfg['flip_y'] else 1)\n",
    "        x2 = (self.cfg['arena_x'] - self._positions_list_2[-1][0]) * self.pixel_size * (-1 if self.cfg['flip_x'] else 1)\n",
    "        y2 = (self.cfg['arena_y'] - self._positions_list_2[-1][1]) * self.pixel_size * (-1 if self.cfg['flip_y'] else 1)\n",
    "        return np.array([[x1, y1], [x2, y2]])\n",
    "        \n",
    "    @property\n",
    "    def contours(self):  # always in pixels\n",
    "        return [self._contour1, self._contour2] if self._contour1 is not None else None\n",
    "    \n",
    "    @property\n",
    "    def speeds(self):\n",
    "        # Not Implemented\n",
    "        return [0, 0] if self.positions_in_px is not None else None\n",
    "    \n",
    "    @property\n",
    "    def hds(self):\n",
    "        # Not Implemented\n",
    "        return [0, 0] if self.positions_in_px is not None else None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing position detection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(os.path.join('..', 'profiles', 'default.json')) as json_file:\n",
    "    cfg = json.load(json_file)\n",
    "\n",
    "pt_cfg = cfg['position']\n",
    "pt_cfg['background_light'] = os.path.join('..', 'assets', 'background_light.png')\n",
    "pt_cfg['background_dark'] = os.path.join('..', 'assets', 'background_dark.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Webcam stream 1024.0:768.0 at 30.00 FPS started\n",
      "Camera released\n",
      "Position tracker stopped\n"
     ]
    }
   ],
   "source": [
    "#import nbimporter\n",
    "#from camera import WebcamStream\n",
    "\n",
    "# controller status: 1 - detecting, 2 - detecting + logging\n",
    "status = mp.Value('i', 1)\n",
    "\n",
    "# let's use a webcam stream\n",
    "vs = WebcamStream(cfg['camera'])\n",
    "vs.start()  # stream runs in a separate thread\n",
    "\n",
    "# init controller\n",
    "#pt = DoublePositionTracker(status, vs, pt_cfg)\n",
    "pt = PositionTrackerSingle(status, vs, pt_cfg)\n",
    "pt.start()\n",
    "kernel_size = (25,25)\n",
    "\n",
    "try:\n",
    "    while True:\n",
    "        frame = vs.read()\n",
    "        if frame is not None:\n",
    "            masked_frame = cv2.bitwise_and(src1=frame, src2=pt.mask)\n",
    "            frame_to_save = masked_frame.copy()\n",
    "            #masked_frame = cv2.absdiff(masked_frame, pt.background)\n",
    "            #masked_frame = cv2.subtract(pt.background, masked_frame)\n",
    "            #masked_frame = cv2.subtract(masked_frame, pt.background)\n",
    "            #masked_frame = cv2.cvtColor(masked_frame, cv2.COLOR_BGR2GRAY)\n",
    "            #masked_frame = cv2.GaussianBlur(masked_frame, kernel_size, 0)\n",
    "            \n",
    "            cv2.putText(masked_frame, 'Position: %.2f FPS' % pt.get_avg_fps(), \n",
    "                     (10, 80), cv2.FONT_HERSHEY_DUPLEX, .5, (255, 255, 255))        \n",
    "            \n",
    "            if pt.positions_in_px is not None:\n",
    "                color1 = (127, 255, 0)\n",
    "                #color2 = (0, 0, 255)\n",
    "                cv2.circle(masked_frame, (pt.positions_in_px[0][0], pt.positions_in_px[0][1]), 2, color1, -1)\n",
    "                #cv2.circle(masked_frame, (pt.xy2_in_px[0], pt.xy2_in_px[1]), 2, color2, -1)\n",
    "                \n",
    "                cv2.drawContours(masked_frame, [pt.contours[0]], 0, color1, 1, cv2.LINE_AA)\n",
    "                #cv2.drawContours(masked_frame, [pt.contour2], 0, color2, 1, cv2.LINE_AA)\n",
    "                \n",
    "                cv2.putText(masked_frame, 'Animal1: %.3f %.3f %d' % (pt.positions_in_m[0][0], pt.positions_in_m[0][1], \\\n",
    "                         cv2.contourArea(pt.contours[0])), (10, 40), cv2.FONT_HERSHEY_DUPLEX, 0.5, (255, 255, 255))\n",
    "                cv2.putText(masked_frame, 'History: %d' % (len(pt._positions_list)), \\\n",
    "                            (10, 60), cv2.FONT_HERSHEY_DUPLEX, 0.5, (255, 255, 255))\n",
    "            \n",
    "                # regression line\n",
    "                #if pt.lr is not None:\n",
    "                #    x1, x2 = pt.contour[:, 0, 0].min() - 10, pt.contour[:, 0, 0].max() + 10\n",
    "                #    y1, y2 = int(x1 * pt.lr['slope'] + pt.lr['intercept']), int(x2 * pt.lr['slope'] + pt.lr['intercept'])\n",
    "                #    cv2.line(frame, (x1, y1), (x2, y2), color, 1)\n",
    "            \n",
    "            cv2.putText(masked_frame, 'L' if pt.is_light else 'D', (10, 20), cv2.FONT_HERSHEY_DUPLEX, .5, (255, 255, 255))            \n",
    "            cv2.imshow('Webcam', masked_frame)\n",
    "\n",
    "        k = cv2.waitKey(33)\n",
    "        if k == ord('q'):\n",
    "            break\n",
    "            \n",
    "        if k == ord('s'):\n",
    "            status.value = 2 if status.value == 1 else 1\n",
    "\n",
    "        if k == ord('d'):\n",
    "            pt.switch_background()\n",
    "            \n",
    "        if k == ord('r'):\n",
    "            cv2.imwrite('frame.jpg', frame_to_save)\n",
    "                       \n",
    "finally:\n",
    "    cv2.destroyAllWindows()\n",
    "    vs.stop(), pt.stop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image sandbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "masked_frame = cv2.imread('frame.jpg')\n",
    "bg_light = cv2.imread(cfg['position']['background_light'], 1)\n",
    "subjects = cv2.subtract(bg_light, masked_frame)\n",
    "subjects_gray = cv2.cvtColor(subjects, cv2.COLOR_BGR2GRAY)\n",
    "\n",
    "kernel_size = (25,25)\n",
    "subjects_blur = cv2.GaussianBlur(subjects_gray, kernel_size, 0)\n",
    "th = cfg['position']['threshold_light']  # in light\n",
    "_, thresh = cv2.threshold(subjects_blur, th, 255, cv2.THRESH_BINARY)\n",
    "\n",
    "contours, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n",
    "\n",
    "contour = contours[np.argmax(list(map(cv2.contourArea, contours)))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x9684a90>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(masked_frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x996cc40>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(bg_light)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x99d1610>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(subjects)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "410.0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv2.contourArea(contours[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = np.array([12, 56, 5, 5])\n",
    "np.argmin(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0xa3e5dc0>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(contours[0][:, 0][:, 0], contours[0][:, 0][:, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 1, 2], dtype=int64)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.astype('int64')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 0], dtype=int64)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([3, 1, 2])\n",
    "idxs = np.argsort(x)\n",
    "idxs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[idxs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = cv2.imread('frame.jpg')\n",
    "#plt.imshow(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0], dtype=uint8)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "color = ('b','g','r')\n",
    "for channel, col in enumerate(color):\n",
    "    histr = cv2.calcHist([image],[channel],None,[256],[0,256])\n",
    "    plt.plot(histr, color = col)\n",
    "    plt.xlim([0,256])\n",
    "    plt.ylim([0, 1000])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contour test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = contour[0][0][0], contour[0][0][1]\n",
    "pt.px_to_meters(x, y), len(contour)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ctr_in_m = np.array([pt.px_to_meters(x, y) for x, y in zip(contour[:, 0, 0], contour[:, 0, 1])])\n",
    "ctr_in_px = np.array([x for x in zip(contour[:, 0, 0], contour[:, 0, 1])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from scipy import stats\n",
    "\n",
    "x = ctr_in_px[:, 0]\n",
    "y = ctr_in_px[:, 1]\n",
    "\n",
    "slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)\n",
    "x_line = np.linspace(x.min(), x.max(), 10)\n",
    "y_line = x_line * slope + intercept\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.plot(x_line, y_line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = 'D:\\\\runSIT\\\\sessions\\\\52_aSIT_2021-11-15_11-12-00\\\\contours.csv'\n",
    "with open(filename) as ff:\n",
    "    data = ff.readlines()\n",
    "\n",
    "headers = data[0]   # skip headers line\n",
    "contours = [[(float(x.split(':')[0]), float(x.split(':')[1])) for x in contour.split(',')] for contour in data[1:]]\n",
    "contours = [np.array(contour) for contour in contours]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x9ad4820>]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(contours[0][:, 0], contours[0][:, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}