Task 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b86986b8",
   "metadata": {},
   "source": [
    "## Task 1 \n",
    "#### Classifies road lanes as being occupied or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "deed60a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4.7.0'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Importing libraries\n",
    "import cv2\n",
    "import os\n",
    "import io\n",
    "import glob\n",
    "import csv\n",
    "import numpy as np\n",
    "from ultralytics import YOLO\n",
    "model = YOLO(\"yolov8x.pt\") # x means Huge size of YOLO\n",
    "cv2.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6392e268",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Required files paths \n",
    "Train_Mode = False\n",
    "\n",
    "if Train_Mode:\n",
    "    images = r'D:\\Uni_Buc\\Uni_Buc_semester_2\\Computer Vision\\CV 2023\\CV-2023-Project2\\train\\Task1\\*.jpg'\n",
    "    text_files = r'D:\\Uni_Buc\\Uni_Buc_semester_2\\Computer Vision\\CV 2023\\CV-2023-Project2\\train\\Task1\\*.txt'\n",
    "else:\n",
    "    images = r'D:\\Uni_Buc\\Uni_Buc_semester_2\\Computer Vision\\CV 2023\\CV-2023-Project2\\test\\Task1\\*.jpg'\n",
    "    text_files = r'D:\\Uni_Buc\\Uni_Buc_semester_2\\Computer Vision\\CV 2023\\CV-2023-Project2\\test\\Task1\\*.txt'\n",
    "    \n",
    "images_paths = sorted(glob.glob(images), key=lambda i: (os.path.splitext(os.path.basename(i))[0]))\n",
    "txt_paths = sorted(glob.glob(text_files), key=lambda i: (os.path.splitext(os.path.basename(i))[0]))\n",
    "\n",
    "results_paths = r'D:\\Uni_Buc\\Uni_Buc_semester_2\\Computer Vision\\CV 2023\\CV-2023-Project2\\\\Lara_Tomeh_507\\Task1'\n",
    "ground_truth_paths = r'D:\\Uni_Buc\\Uni_Buc_semester_2\\Computer Vision\\CV 2023\\CV-2023-Project2\\\\train\\Task1\\ground-truth'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8bf0cbf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the text files\n",
    "def read_lanes():\n",
    "    number_of_lanes = []\n",
    "    lanes_ids = []\n",
    "    for i, txt in enumerate(txt_paths):\n",
    "        with open(txt) as f:\n",
    "            total_lanes = int(f.readline().split(' ')[0])\n",
    "            number_of_lanes.append(total_lanes)\n",
    "\n",
    "            ids = []\n",
    "            for _ in range(total_lanes):\n",
    "                line = f.readline().split()\n",
    "                lane_id = int(line[0])\n",
    "                ids.append(lane_id)\n",
    "            lanes_ids.append(ids)\n",
    "\n",
    "    return number_of_lanes, lanes_ids\n",
    "\n",
    "number_of_lanes, lanes_ids = read_lanes()\n",
    "\n",
    "# Create the predicted lanes dictionary\n",
    "predicted_lanes = {}\n",
    "for i, image_path in enumerate(images, start=1):\n",
    "    predicted_lanes[i] = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e1859a71",
   "metadata": {},
   "outputs": [],
   "source": [
    "def detect_lanes(images, number_of_lanes, lanes_ids, txt_paths, results_paths):\n",
    "    \n",
    "    predicted_lanes = {i+1: [] for i in range(len(images))}           # Initialize predicted_lanes dictionary\n",
    "    \n",
    "    # for loop to read all images in the path\n",
    "    for i, image in enumerate(images):\n",
    "        print(f'Detecting image {i+1}/{len(images)}')\n",
    "        \n",
    "        # Opjects detection using YOLO model\n",
    "        objects = model.predict(image, classes=[1, 2, 3, 5, 6, 7, 8])  # Select which classes to predict\n",
    "        detections = objects[0]\n",
    "        \n",
    "        # Define the polygonal ROI for each lane \n",
    "        # After several experiments, they were determined due to the close proximity of the paths to each other.\"\n",
    "        roi_points_lane1 = np.array([(270, 463), (460, 440), (126, 133), (116,205)], np.int32)\n",
    "        roi_points_lane2 = np.array([(460, 437), (588, 417), (101, 58), (89, 96)], np.int32)\n",
    "#         roi_points_lane3 = np.array([(586, 417), (713, 398), (93, 2), (72, 24)], np.int32)\n",
    "        roi_points_lane3 = np.array([(99, 55), (581, 414), (759, 391), (175, 41)], np.int32)\n",
    "        roi_points_lane4u = np.array([(1145,359), (1913,279), (1896,204), (1113,264)], np.int32)\n",
    "#         roi_points_lane4d = np.array([(1157,373), (1917,298), (1915,280), (1144,359)], np.int32)\n",
    "        roi_points_lane4upup = np.array([(1843, 177), (1062, 182), (1068, 261), (1837, 235)], np.int32)\n",
    "        roi_points_lane4 = np.array([(1912, 265), (1912, 338), (1194, 420), (1118, 365)], np.int32)\n",
    "        roi_points_lane5 = np.array([(1913, 362), (1180, 438), (1161, 409), (1914, 320)], np.int32)\n",
    "        roi_points_lane6 = np.array([(1913, 364), (1912, 402), (1228, 461), (1213, 434)], np.int32)\n",
    "        roi_points_lane7 = np.array([(1161, 581), (1648, 874), (1917, 874), (1914, 676), (1442, 483)], np.int32)\n",
    "        roi_points_lane8 = np.array([(1391, 880), (1006, 619), (1179, 595), (1650, 880)], np.int32)\n",
    "        roi_points_lane9 = np.array([(1385, 876), (1000, 611), (795, 645), (1035, 877)], np.int32)\n",
    "\n",
    "        # Initialize counters for cars in each lane\n",
    "        car_count_lane1 = 0\n",
    "        car_count_lane2 = 0\n",
    "        car_count_lane3 = 0\n",
    "        car_count_lane4 = 0\n",
    "        car_count_lane5 = 0\n",
    "        car_count_lane6 = 0\n",
    "        car_count_lane7 = 0\n",
    "        car_count_lane8 = 0\n",
    "        car_count_lane9 = 0\n",
    "        \n",
    "        # Iterate through all detections\n",
    "        for detection in detections:\n",
    "            cords = detection.boxes.xyxy[0].tolist()\n",
    "            xmin = cords[0]\n",
    "            ymin = cords[1]\n",
    "            xmax = cords[2]\n",
    "            ymax = cords[3]\n",
    "            conf = detection.boxes.conf\n",
    "            centroid_x = int((xmin + xmax) / 2) # centre point x coordinates\n",
    "            centroid_y = int((ymin + ymax) / 2) # centre point y coordinates\n",
    "\n",
    "            # Define the points as tuples\n",
    "            point1 = (xmin, ymin)\n",
    "            point2 = (xmin, ymax)\n",
    "            point3 = (xmax, ymax)\n",
    "            point4 = (xmax, ymin)\n",
    "\n",
    "            # Check if the points are inside each ROI and assign the car to the corresponding lane\n",
    "#         ----------------------------LANE 1---------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane1, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane1, point2, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (0, 255, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (0, 255, 0), -1)\n",
    "                car_count_lane1 += 1\n",
    "        #         --------------------------LANE 2-----------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane2, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane2, point3, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane1, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane3, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 0, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 0, 0), -1)\n",
    "                car_count_lane2 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane2, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane2, point3, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane2, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane3, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 0, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 0, 0), -1)\n",
    "                car_count_lane2 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane3, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane2, point3, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane1, point2, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 0, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 0, 0), -1)\n",
    "                car_count_lane2 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane2, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane2, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 0, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 0, 0), -1)\n",
    "                car_count_lane2 += 1\n",
    "        #         ------------------LANE 3-------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane3, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane3, point2, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (0, 0, 255), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (0, 0, 255), -1)\n",
    "                car_count_lane3 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane3, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane2, point2, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (0, 0, 255), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (0, 0, 255), -1)\n",
    "                car_count_lane3 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane3, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane3, point3, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane2, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane4, point4, False) > 0\n",
    "\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (0, 0, 255), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (0, 0, 255), -1)\n",
    "                car_count_lane3 += 1\n",
    "        #         --------------------------------LANE 4-----------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane4, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane4, point3, False) > 0\n",
    "#                 and cv2.pointPolygonTest(roi_points_lane5, point2, False) > 0\n",
    "#                 and cv2.pointPolygonTest(roi_points_lane5, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 255, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 255, 0), -1)\n",
    "                car_count_lane4 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane4u, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane4u, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 255, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 255, 0), -1)\n",
    "                car_count_lane4 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane4upup, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane4upup, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 255, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 255, 0), -1)\n",
    "                car_count_lane4 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane4upup, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane4upup, point4, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane6, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 255, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 255, 0), -1)\n",
    "                car_count_lane4 += 1\n",
    "        #         -------------------------------LANE 5------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane5, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane5, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (0, 255, 255), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (0, 255, 255), -1)\n",
    "                car_count_lane5 += 1\n",
    " #         -----------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane4u, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane4u, point4, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane6, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (0, 255, 255), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (0, 255, 255), -1)\n",
    "                car_count_lane5 += 1\n",
    "        #         ------------------------------LANE 6-------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane6, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane6, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 0, 255), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 0, 255), -1)\n",
    "                car_count_lane6 += 1\n",
    "#         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane5, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane6, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 0, 255), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 0, 255), -1)\n",
    "                car_count_lane6 += 1\n",
    "                #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane6, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 0, 255), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 0, 255), -1)\n",
    "                car_count_lane6 += 1\n",
    "        #         -----------------------------LANE 7--------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane7, point4, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane7, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (255, 255, 255), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (255, 255, 255), -1)\n",
    "                car_count_lane7 += 1\n",
    "        #         ------------------------LANE 8-------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane8, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point2, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "         #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane8, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane8, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "         #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane9, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point3, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "         #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane8, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane9, point2, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "         #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane8, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane9, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane7, point3, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane7, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "         #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane8, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point3, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane7, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane9, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane9, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point3, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane9, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane9, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane7, point3, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane7, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane8, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane8, point3, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane7, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "        #         -------------------------------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane8, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane9, point2, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane7, point4, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (128, 0, 128), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (128, 0, 128), -1)\n",
    "                car_count_lane8 += 1\n",
    "        #         ----------------------LANE 9---------------------------------------------------\n",
    "            if (\n",
    "                cv2.pointPolygonTest(roi_points_lane9, point1, False) > 0\n",
    "                and cv2.pointPolygonTest(roi_points_lane9, point2, False) > 0\n",
    "            ):\n",
    "                cv2.rectangle(image, (int(xmin), int(ymin)), (int(xmax), int(ymax)), (0, 0, 0), 2)\n",
    "                cv2.circle(image, (centroid_x, centroid_y), 5, (0, 0, 0), -1)\n",
    "                car_count_lane9 += 1\n",
    "\n",
    "        # Store the result in the predicted_lanes dictionary    \n",
    "        if car_count_lane1 >= 1:\n",
    "            result = 1\n",
    "        else:\n",
    "            result = 0 \n",
    "        predicted_lanes[i+1].append(result)\n",
    "        if car_count_lane2 >= 1:\n",
    "            result = 1\n",
    "        else:\n",
    "            result = 0\n",
    "        predicted_lanes[i+1].append(result)\n",
    "        if car_count_lane3 >= 1:\n",
    "            result = 1\n",
    "        else:\n",
    "            result = 0 \n",
    "        predicted_lanes[i+1].append(result)\n",
    "        if car_count_lane4 >= 1:\n",
    "            result = 1\n",
    "        else:\n",
    "            result = 0 \n",
    "        predicted_lanes[i+1].append(result)\n",
    "        if car_count_lane5 >= 1:\n",
    "            result = 1\n",
    "        else:\n",
    "            result = 0 \n",
    "        predicted_lanes[i+1].append(result)    \n",
    "        if car_count_lane6 >= 1:\n",
    "            result = 1\n",
    "        else:\n",
    "            result = 0 \n",
    "        predicted_lanes[i+1].append(result)\n",
    "        if car_count_lane7 >= 1:\n",
    "            result = 1\n",
    "        else:\n",
    "            result = 0 \n",
    "        predicted_lanes[i+1].append(result)\n",
    "        if car_count_lane8 >= 1:\n",
    "            result = 1\n",
    "        else:\n",
    "            result = 0 \n",
    "        predicted_lanes[i+1].append(result)\n",
    "        if car_count_lane9 >= 1:\n",
    "            result = 1\n",
    "        else:\n",
    "            result = 0\n",
    "        predicted_lanes[i+1].append(result)\n",
    "\n",
    "        # Define the colors for each lane\n",
    "        lane_colors = [\n",
    "            (0, 255, 0),      # Green color for Lane 1\n",
    "            (255, 0, 0),      # Blue color for Lane 2\n",
    "            (0, 0, 255),      # Red color for Lane 3\n",
    "            (255, 255, 0),    # Cyan color for Lane 4\n",
    "            (0, 255, 255),    # ....\n",
    "            (255, 0, 255),    # ....\n",
    "            (255, 255, 255),  # ....\n",
    "            (128, 0, 128),    # ....\n",
    "            (0, 0, 0)         # ....\n",
    "        ]\n",
    "\n",
    "#         # Draw lanes boundaries\n",
    "#         cv2.polylines(image, [roi_points_lane1], False, lane_colors[0], 1)\n",
    "#         cv2.polylines(image, [roi_points_lane2], False, lane_colors[1], 1)\n",
    "#         cv2.polylines(image, [roi_points_lane3], False, lane_colors[2], 1)\n",
    "#         cv2.polylines(image, [roi_points_lane4], False, lane_colors[3], 1)\n",
    "#         cv2.polylines(image, [roi_points_lane5], False, lane_colors[4], 1)\n",
    "#         cv2.polylines(image, [roi_points_lane6], False, lane_colors[5], 1)\n",
    "#         cv2.polylines(image, [roi_points_lane7], False, lane_colors[6], 1)\n",
    "#         cv2.polylines(image, [roi_points_lane8], False, lane_colors[7], 1)\n",
    "#         cv2.polylines(image, [roi_points_lane9], False, lane_colors[8], 1)\n",
    "\n",
    "            \n",
    "        # Display the color for each lane\n",
    "        cv2.putText(image, f\"Lane 1\", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)\n",
    "        cv2.putText(image, f\"Lane 2\", (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 0), 2)\n",
    "        cv2.putText(image, f\"Lane 3\", (10, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)\n",
    "        cv2.putText(image, f\"Lane 4\", (10, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 2)\n",
    "        cv2.putText(image, f\"Lane 5\", (10, 150), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)\n",
    "        cv2.putText(image, f\"Lane 6\", (10, 180), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 0, 255), 2)\n",
    "        cv2.putText(image, f\"Lane 7\", (10, 210), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)\n",
    "        cv2.putText(image, f\"Lane 8\", (10, 240), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (128, 0, 128), 2)\n",
    "        cv2.putText(image, f\"Lane 9\", (10, 270), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2)        \n",
    "        \n",
    "        # Create the results file if it doesn't exist and write the results to a new text file\n",
    "\n",
    "        if not os.path.exists(results_paths):\n",
    "            os.makedirs(results_paths)\n",
    "#         original_txt_filename = os.path.basename(txt_paths[i])\n",
    "#         predicted_txt_filename = os.path.splitext(original_txt_filename)[0] + \"_predicted.txt\"\n",
    "#         predicted_txt_path = os.path.join(results_paths, predicted_txt_filename)\n",
    "\n",
    "        original_txt_filename = os.path.basename(txt_paths[i])\n",
    "        original_txt_filename_without_query = original_txt_filename.replace(\"query\", \"\")\n",
    "        predicted_txt_filename = os.path.splitext(original_txt_filename_without_query)[0] + \"predicted.txt\"\n",
    "        predicted_txt_path = os.path.join(results_paths, predicted_txt_filename)\n",
    "\n",
    "        with open(predicted_txt_path, \"w\") as f:\n",
    "            f.write(f\"{number_of_lanes[i]}\\n\")\n",
    "            for lane_id in lanes_ids[i]:\n",
    "                if lane_id == 1:\n",
    "                    f.write(f\"{lane_id} {predicted_lanes[i+1][0]}\\n\")\n",
    "                if lane_id == 2:\n",
    "                    f.write(f\"{lane_id} {predicted_lanes[i+1][1]}\\n\")\n",
    "                if lane_id == 3:\n",
    "                    f.write(f\"{lane_id} {predicted_lanes[i+1][2]}\\n\")\n",
    "                if lane_id == 4:\n",
    "                    f.write(f\"{lane_id} {predicted_lanes[i+1][3]}\\n\")\n",
    "                if lane_id == 5:\n",
    "                    f.write(f\"{lane_id} {predicted_lanes[i+1][4]}\\n\")\n",
    "                if lane_id == 6:\n",
    "                    f.write(f\"{lane_id} {predicted_lanes[i+1][5]}\\n\")                \n",
    "                if lane_id == 7:\n",
    "                    f.write(f\"{lane_id} {predicted_lanes[i+1][6]}\\n\")\n",
    "                if lane_id == 8:\n",
    "                    f.write(f\"{lane_id} {predicted_lanes[i+1][7]}\\n\")\n",
    "                if lane_id == 9:\n",
    "                    f.write(f\"{lane_id} {predicted_lanes[i+1][8]}\\n\")\n",
    "         \n",
    "        print(f\"Saved results for image {i+1} to predicted text path\")\n",
    "        print(f\"image {i+1} lanes occupancy:\")\n",
    "        print(predicted_lanes[i+1])\n",
    "        \n",
    "        # Resize the image for display\n",
    "        resized_image = cv2.resize(image, (1500, 800))\n",
    "        # Display the image with detection results\n",
    "        cv2.imshow(f\"Image {i+1}\", resized_image)\n",
    "        cv2.waitKey(0)\n",
    "        cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4fbee969",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 1/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "0: 320x640 2 cars, 2096.7ms\n",
      "Speed: 9.1ms preprocess, 2096.7ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 1 to predicted text path\n",
      "image 1 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 2/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 (no detections), 1222.2ms\n",
      "Speed: 5.8ms preprocess, 1222.2ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 2 to predicted text path\n",
      "image 2 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 3/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 2 cars, 1199.7ms\n",
      "Speed: 0.0ms preprocess, 1199.7ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 3 to predicted text path\n",
      "image 3 lanes occupancy:\n",
      "[0, 0, 0, 0, 1, 0, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 4/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 4 cars, 1969.6ms\n",
      "Speed: 8.5ms preprocess, 1969.6ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 4 to predicted text path\n",
      "image 4 lanes occupancy:\n",
      "[0, 1, 0, 0, 0, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 5/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 5 cars, 1269.7ms\n",
      "Speed: 44.9ms preprocess, 1269.7ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 5 to predicted text path\n",
      "image 5 lanes occupancy:\n",
      "[0, 1, 0, 0, 0, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 6/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 3 cars, 1 truck, 1316.4ms\n",
      "Speed: 15.1ms preprocess, 1316.4ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 6 to predicted text path\n",
      "image 6 lanes occupancy:\n",
      "[0, 1, 0, 0, 0, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 7/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 7 cars, 1 bus, 3 trucks, 1252.4ms\n",
      "Speed: 16.5ms preprocess, 1252.4ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 7 to predicted text path\n",
      "image 7 lanes occupancy:\n",
      "[0, 0, 0, 1, 1, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 8/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 6 cars, 1 bus, 2 trucks, 1870.5ms\n",
      "Speed: 18.1ms preprocess, 1870.5ms inference, 3.9ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 8 to predicted text path\n",
      "image 8 lanes occupancy:\n",
      "[0, 0, 0, 1, 1, 1, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 9/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 8 cars, 1 bus, 2 trucks, 1267.7ms\n",
      "Speed: 23.6ms preprocess, 1267.7ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 9 to predicted text path\n",
      "image 9 lanes occupancy:\n",
      "[0, 0, 0, 1, 1, 1, 1, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 10/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 1 car, 1222.5ms\n",
      "Speed: 14.5ms preprocess, 1222.5ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 10 to predicted text path\n",
      "image 10 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 11/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 5 cars, 2087.9ms\n",
      "Speed: 6.3ms preprocess, 2087.9ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 11 to predicted text path\n",
      "image 11 lanes occupancy:\n",
      "[0, 0, 1, 0, 0, 1, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 12/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 4 cars, 2103.3ms\n",
      "Speed: 10.8ms preprocess, 2103.3ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 12 to predicted text path\n",
      "image 12 lanes occupancy:\n",
      "[0, 0, 1, 0, 0, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 13/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 5 cars, 1 bus, 1 truck, 2011.4ms\n",
      "Speed: 7.3ms preprocess, 2011.4ms inference, 3.1ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 13 to predicted text path\n",
      "image 13 lanes occupancy:\n",
      "[0, 0, 0, 1, 1, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 14/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 6 cars, 1 bus, 1 truck, 2120.2ms\n",
      "Speed: 17.2ms preprocess, 2120.2ms inference, 15.6ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 14 to predicted text path\n",
      "image 14 lanes occupancy:\n",
      "[0, 1, 1, 1, 1, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 15/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 9 cars, 1 bus, 1 truck, 1972.2ms\n",
      "Speed: 20.0ms preprocess, 1972.2ms inference, 2.7ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 15 to predicted text path\n",
      "image 15 lanes occupancy:\n",
      "[0, 1, 1, 0, 0, 0, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 16/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 2 cars, 2026.8ms\n",
      "Speed: 4.8ms preprocess, 2026.8ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 16 to predicted text path\n",
      "image 16 lanes occupancy:\n",
      "[0, 1, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 17/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 3 cars, 1274.9ms\n",
      "Speed: 14.8ms preprocess, 1274.9ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 17 to predicted text path\n",
      "image 17 lanes occupancy:\n",
      "[0, 0, 0, 0, 1, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 18/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 5 cars, 1992.8ms\n",
      "Speed: 11.1ms preprocess, 1992.8ms inference, 14.8ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 18 to predicted text path\n",
      "image 18 lanes occupancy:\n",
      "[0, 0, 0, 0, 1, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 19/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 4 cars, 1425.0ms\n",
      "Speed: 13.0ms preprocess, 1425.0ms inference, 1.9ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 19 to predicted text path\n",
      "image 19 lanes occupancy:\n",
      "[1, 0, 0, 0, 0, 0, 1, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 20/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 4 cars, 1 truck, 1944.0ms\n",
      "Speed: 8.6ms preprocess, 1944.0ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 20 to predicted text path\n",
      "image 20 lanes occupancy:\n",
      "[1, 0, 0, 0, 0, 0, 1, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 21/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 2 cars, 1 truck, 1334.8ms\n",
      "Speed: 3.7ms preprocess, 1334.8ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 21 to predicted text path\n",
      "image 21 lanes occupancy:\n",
      "[0, 0, 0, 0, 1, 0, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 22/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 1 car, 1522.4ms\n",
      "Speed: 5.1ms preprocess, 1522.4ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 22 to predicted text path\n",
      "image 22 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 1, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 23/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 2 cars, 1303.5ms\n",
      "Speed: 1.5ms preprocess, 1303.5ms inference, 15.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 23 to predicted text path\n",
      "image 23 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 24/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 2 cars, 2023.1ms\n",
      "Speed: 12.1ms preprocess, 2023.1ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 24 to predicted text path\n",
      "image 24 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 25/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 16 cars, 2 trucks, 1179.6ms\n",
      "Speed: 5.2ms preprocess, 1179.6ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 25 to predicted text path\n",
      "image 25 lanes occupancy:\n",
      "[0, 1, 1, 0, 0, 1, 1, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 26/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 16 cars, 3 trucks, 1288.9ms\n",
      "Speed: 14.0ms preprocess, 1288.9ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 26 to predicted text path\n",
      "image 26 lanes occupancy:\n",
      "[1, 1, 1, 1, 1, 1, 1, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 27/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 13 cars, 1 bus, 6 trucks, 1938.9ms\n",
      "Speed: 9.1ms preprocess, 1938.9ms inference, 7.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 27 to predicted text path\n",
      "image 27 lanes occupancy:\n",
      "[1, 1, 1, 1, 0, 1, 1, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 28/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 9 cars, 2 buss, 1 truck, 2096.8ms\n",
      "Speed: 9.8ms preprocess, 2096.8ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 28 to predicted text path\n",
      "image 28 lanes occupancy:\n",
      "[1, 0, 0, 0, 1, 1, 1, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 29/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 11 cars, 1 bus, 1908.6ms\n",
      "Speed: 5.8ms preprocess, 1908.6ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 29 to predicted text path\n",
      "image 29 lanes occupancy:\n",
      "[0, 0, 0, 0, 1, 1, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 30/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 12 cars, 1 bus, 2110.7ms\n",
      "Speed: 31.0ms preprocess, 2110.7ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 30 to predicted text path\n",
      "image 30 lanes occupancy:\n",
      "[1, 0, 0, 0, 1, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 31/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 10 cars, 3 trucks, 1998.9ms\n",
      "Speed: 31.6ms preprocess, 1998.9ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 31 to predicted text path\n",
      "image 31 lanes occupancy:\n",
      "[1, 1, 0, 1, 0, 0, 1, 0, 1]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 32/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 10 cars, 2 trucks, 1986.3ms\n",
      "Speed: 1.8ms preprocess, 1986.3ms inference, 3.4ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 32 to predicted text path\n",
      "image 32 lanes occupancy:\n",
      "[1, 0, 0, 1, 0, 0, 0, 0, 1]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 33/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 7 cars, 3 trucks, 1355.5ms\n",
      "Speed: 16.1ms preprocess, 1355.5ms inference, 3.5ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 33 to predicted text path\n",
      "image 33 lanes occupancy:\n",
      "[0, 0, 0, 1, 1, 1, 0, 0, 1]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 34/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 7 cars, 2 trucks, 1232.0ms\n",
      "Speed: 8.0ms preprocess, 1232.0ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 34 to predicted text path\n",
      "image 34 lanes occupancy:\n",
      "[0, 0, 0, 1, 1, 1, 0, 0, 1]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 35/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 2 cars, 2 trucks, 1244.5ms\n",
      "Speed: 6.0ms preprocess, 1244.5ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 35 to predicted text path\n",
      "image 35 lanes occupancy:\n",
      "[1, 0, 0, 1, 1, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 36/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 3 cars, 3 trucks, 1313.2ms\n",
      "Speed: 13.4ms preprocess, 1313.2ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 36 to predicted text path\n",
      "image 36 lanes occupancy:\n",
      "[1, 0, 0, 0, 0, 1, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 37/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 1 car, 1247.4ms\n",
      "Speed: 13.6ms preprocess, 1247.4ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 37 to predicted text path\n",
      "image 37 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 38/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 1 car, 1299.1ms\n",
      "Speed: 11.5ms preprocess, 1299.1ms inference, 15.6ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 38 to predicted text path\n",
      "image 38 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 39/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 1 car, 1 truck, 1289.0ms\n",
      "Speed: 7.2ms preprocess, 1289.0ms inference, 13.4ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 39 to predicted text path\n",
      "image 39 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 40/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 4 cars, 1239.5ms\n",
      "Speed: 9.1ms preprocess, 1239.5ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 40 to predicted text path\n",
      "image 40 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 0, 1, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 41/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 2 cars, 1 truck, 1199.9ms\n",
      "Speed: 3.3ms preprocess, 1199.9ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 41 to predicted text path\n",
      "image 41 lanes occupancy:\n",
      "[0, 1, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 42/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 3 cars, 1289.8ms\n",
      "Speed: 11.0ms preprocess, 1289.8ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 42 to predicted text path\n",
      "image 42 lanes occupancy:\n",
      "[1, 1, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 43/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 7 cars, 1435.2ms\n",
      "Speed: 1.1ms preprocess, 1435.2ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 43 to predicted text path\n",
      "image 43 lanes occupancy:\n",
      "[0, 1, 0, 0, 0, 0, 0, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 44/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 7 cars, 1910.5ms\n",
      "Speed: 15.6ms preprocess, 1910.5ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 44 to predicted text path\n",
      "image 44 lanes occupancy:\n",
      "[0, 1, 0, 0, 0, 0, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 45/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 3 cars, 1 truck, 1316.0ms\n",
      "Speed: 9.1ms preprocess, 1316.0ms inference, 3.5ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 45 to predicted text path\n",
      "image 45 lanes occupancy:\n",
      "[0, 0, 0, 0, 0, 1, 1, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 46/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 6 cars, 1298.5ms\n",
      "Speed: 10.1ms preprocess, 1298.5ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 46 to predicted text path\n",
      "image 46 lanes occupancy:\n",
      "[0, 1, 0, 0, 0, 1, 1, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 47/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 4 cars, 1 truck, 1353.2ms\n",
      "Speed: 11.4ms preprocess, 1353.2ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 47 to predicted text path\n",
      "image 47 lanes occupancy:\n",
      "[0, 0, 0, 0, 1, 1, 1, 0, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 48/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 4 cars, 1301.0ms\n",
      "Speed: 5.0ms preprocess, 1301.0ms inference, 9.9ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 48 to predicted text path\n",
      "image 48 lanes occupancy:\n",
      "[0, 0, 0, 0, 1, 1, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 49/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 4 cars, 2069.3ms\n",
      "Speed: 9.2ms preprocess, 2069.3ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 49 to predicted text path\n",
      "image 49 lanes occupancy:\n",
      "[0, 0, 0, 0, 1, 1, 0, 1, 0]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detecting image 50/50\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "0: 320x640 4 cars, 1315.8ms\n",
      "Speed: 12.2ms preprocess, 1315.8ms inference, 0.0ms postprocess per image at shape (1, 3, 640, 640)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved results for image 50 to predicted text path\n",
      "image 50 lanes occupancy:\n",
      "[0, 0, 0, 0, 1, 1, 0, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "# Load and process each image in the folder\n",
    "images = []\n",
    "for image_path in images_paths:\n",
    "    image = cv2.imread(image_path)\n",
    "    images.append(image)\n",
    "\n",
    "# Call the compare_lanes function\n",
    "detect_lanes(images, number_of_lanes, lanes_ids, txt_paths, results_paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "752a7c76",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert a text file to CSV in memory\n",
    "def convert_to_csv(file_path):\n",
    "    with open(file_path, 'r') as text_file:\n",
    "        csv_data = io.StringIO()\n",
    "        writer = csv.writer(csv_data)\n",
    "        for line in text_file:\n",
    "            writer.writerow([line.strip()])\n",
    "        csv_data.seek(0)  # Reset the stream position to the beginning\n",
    "        return csv_data\n",
    "\n",
    "# Compare two CSV files and return True if they match\n",
    "def compare_csv_files(file1_data, file2_data):\n",
    "    file1_reader = csv.reader(file1_data)\n",
    "    file2_reader = csv.reader(file2_data)\n",
    "    return all(row1 == row2 for row1, row2 in zip(file1_reader, file2_reader))\n",
    "\n",
    "# Compare all files in the folders\n",
    "def compare_folders(folder1_path, folder2_path):\n",
    "    # Get the list of files in each folder\n",
    "    files1 = os.listdir(results_paths)\n",
    "    files2 = os.listdir(ground_truth_paths)\n",
    "    \n",
    "    # Check if the number of files is the same\n",
    "    if len(files1) != len(files2):\n",
    "        print(\"The number of files in the folders is different.\")\n",
    "        return\n",
    "    \n",
    "    num_matched_files = 0\n",
    "    num_unmatched_files = 0\n",
    "    unmatched_files = []  # List to store the names of unmatched files\n",
    "\n",
    "    # Compare each file in the folders\n",
    "    for file1, file2 in zip(files1, files2):\n",
    "        file1_path = os.path.join(results_paths, file1)\n",
    "        file2_path = os.path.join(ground_truth_paths, file2)\n",
    "        \n",
    "        # Convert files to CSV in memory\n",
    "        file1_data = convert_to_csv(file1_path)\n",
    "        file2_data = convert_to_csv(file2_path)\n",
    "        \n",
    "        # Compare CSV files\n",
    "        if compare_csv_files(file1_data, file2_data):\n",
    "            num_matched_files += 1\n",
    "        else:\n",
    "            num_unmatched_files += 1\n",
    "            unmatched_files.append(file1)  # Add the unmatched file name to the list\n",
    "    \n",
    "    # Print the number of matched and unmatched files\n",
    "    print(\"Number of matched files:\", num_matched_files)\n",
    "    print(\"Number of unmatched files:\", num_unmatched_files)\n",
    "    \n",
    "    # Print the names of unmatched files\n",
    "    print(\"Unmatched files:\", unmatched_files)\n",
    "    \n",
    "    # Calculate the score\n",
    "    score = num_matched_files * 0.04\n",
    "    print(\"Score:\", score)\n",
    "\n",
    "# Call the function to compare the folders\n",
    "compare_folders(results_paths, ground_truth_paths)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d835bfd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd51b72f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}