generate_newbie_task.py

+import numpy as np
+import cv2
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+import bros
+from bros.lib.logger import LogReader
+from bros.algorithms.geometry import homography_project
+
+if __name__ == "__main__":
+    image_folder = Path("IMG/")
+    vision_log = LogReader("encoded_vision_log.pkl")
+    homography_path = Path("/home/snakeone/eforce/bros/data/hom_mat.npy")
+
+    H = np.load(homography_path)
+
+    for i, (t, (msg, data)) in enumerate(vision_log):
+        if i < 500:
+            continue
+
+        image_path = image_folder / f"img{i-400}.jpg"
+
+        if not image_path.exists():
+            print(f"image does't exist")
+            continue
+
+        image = cv2.write(image_path)
+        plt.imshow(image)
+        bboxes = data["bboxes"]
+
+        width = bboxes[:,2] - bboxes[:,0]
+        bbox_centers = bboxes[:,[2,3]]
+        bbox_centers[:,0] -= width/2
+        world_points = homography_project(H, bbox_centers)
+
+        for x1, y1, x2, y2, conf, cls in bboxes:
+            plt.plot([x1, x2, x2, x1, x1], [y1, y1, y2, y2, y1], label=cls)
+
+        plt.show()
+
+        plt.plot(world_points[:,0], world_points[:,1], "o")
+        plt.show()
+        break

logger.py → helpers.py

 import pickle
-from copy import deepcopy
+
+
 class LogReader():
     def __init__(self, log_path):
         self.log_path = log_path
         self.log_gen = self.make_log_gen(log_path)
-
         self.msg_count = -1
         self.first = next(self.log_gen)
         self.prev = next(self.log_gen)
         self.curr = next(self.log_gen)
-
-        print(self.prev[0], self.curr[0])
-
         self.deltas = []
 
     def get_by_timestamp(self, timestamp):
         """
         returns msg with timestamp <= timestamp
         """
-        prev_t, prev_msg = self.prev
-
         if self.curr is None:
             raise StopIteration
-        curr_t, curr_msg = self.curr
 
-        while curr_t <= timestamp:
+        curr_t, _ = self.curr
 
-            # get next
+        while curr_t <= timestamp:
             next(self)
-            prev_t, prev_msg = self.prev
 
             if self.curr is None:
                 return self.prev
 
-            curr_t, curr_msg = self.curr
+            curr_t, _ = self.curr
 
         return self.prev
 
     def __next__(self):
-        ret = deepcopy(self.prev)
+        ret = self.prev
 
         if self.curr is not None:
             self.deltas.append((self.curr[0], self.curr[0] - self.prev[0]))
@@ -65,58 +58,16 @@ class LogReader():
             while True:
                 try:
                     yield pickle.load(f)
-                except:
+                except EOFError:
+                    break
+                except pickle.UnpicklingError:
                     break
 
     def reset_gen(self):
         self.log_gen = self.make_log_gen(self.log_path)
-
         # -1 to compensate for first message
         self.msg_count = -1
         self.first = next(self.log_gen)
         self.prev = next(self.log_gen)
         self.curr = next(self.log_gen)
         self.deltas = []
-
-
-class LogGenWrapper():
-    def __init__(self, log_gen):
-        self.log_gen = log_gen
-
-        self.prev = next(self.log_gen)
-
-        self.empty = False
-
-    def __next__(self):
-        curr = deepcopy(self.prev)
-
-        if self.empty is False:
-            try:
-                self.prev = next(self.log_gen)
-            except StopIteration:
-                self.empty = True
-        elif self.empty is True:
-            raise StopIteration
-        return curr
-
-    def __iter__(self):
-        return self
-
-    def get_by_timestamp(self, timestamp):
-        prev_t, _ = self.prev
-
-        if prev_t >= timestamp:
-            return self.prev
-
-        next_t, next_val = next(self.log_gen)
-        # self.prev = (next_t, next_val)
-
-        while next_t < timestamp:
-            self.prev = (next_t, next_val)
-            next_t, next_val = next(self.log_gen)
-
-        temp = self.prev
-        self.prev = (next_t, next_val)
-
-        return temp
-

newbies.ipynb

@@ -8,19 +8,7 @@
     }
    },
    "source": [
-    "# Newbies task season 2022/2023"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {
-    "pycharm": {
-     "name": "#%% md\n"
-    }
-   },
-   "source": [
-    "All Driverless code is accessible on eForce Gitlab - eForce Driverless https://eforce1.feld.cvut.cz/gitlab/eforce-driveless?page=2\n",
-    "However newbies don't currently have access to Gitlab.  All necessary code is in this branch\n"
+    "# Newbies task season 2023/2024"
    ]
   },
   {