Created FakeDetector and FakeGroundTruthDatareader, need to revise datareaders structure and layout(groundtruth) file format

samples/cli_main.py

@@ -0,0 +1,62 @@
+import sys
+import os
+
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(project_root)
+
+from src.gui_application.visualizer import Visualize
+from src.utils.data_reader import GroundtruthReader, FakeGroundtruthReader
+from src.utils.frame_data_reader import FrameDataReader
+from src.vehicle_detector.detector import Detector
+import datetime
+import argparse
+import os
+from PIL import Image
+
+import cv2 as cv
+import numpy as np
+
+def cli_argument_parser():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('-t', '--mode',
+                        help='Mode (\'image\', \'video\')',
+                        type=str,
+                        dest='mode',
+                        choices=['image', 'video'],
+                        required=True)
+    parser.add_argument('-v', '--video',
+                        help='Path to a video file',
+                        type=str,
+                        dest='video_path')
+    parser.add_argument('-i', '--image',
+                        help='Path to images',
+                        type=str,
+                        dest='images_path')
+    parser.add_argument('-g', '--groundtruth',
+                        help='Path to a file of groundtruth',
+                        type=str,
+                        dest='groundtruth_path',
+                        required=False)
+    parser.add_argument('-m', '--model',
+                        help='Path to a model',
+                        type=str,
+                        dest='model_path',
+                        required=True,
+                        default=None)
+
+
+    args = parser.parse_args()
+    return args
+
+#некоторое подобие main 
+def main():
+    args = cli_argument_parser()
+    reader = FrameDataReader.create( args.mode, (args.video_path or args.images_path) )
+    adapter = None
+    detector = Detector.create( "fake" )
+    visualizer = Visualize( reader, detector, FakeGroundtruthReader().read(args.groundtruth_path) )
+    visualizer.show()
+
+if __name__ == '__main__':
+    main()

src/gui_application/visualizer.py

@@ -0,0 +1,42 @@
+import cv2 as cv
+from ..utils.frame_data_reader import FrameDataReader
+from ..utils.data_reader import GroundtruthReader, FakeGroundtruthReader
+from ..vehicle_detector.fake_detector import FakeDetector
+import random
+class Visualize:
+    def __init__(self, datareader:FrameDataReader, detector:FakeDetector, gt_data:list):
+        self.datareader = datareader
+        self.detector = detector
+        self.gt_layout = gt_data
+    def show(self):
+        try:
+            frame_idx = 0
+            for image in self.datareader:
+                if image is None:
+                    break
+
+                for box in self.detector.detect(image):
+                    self.__draw_box(image, box, (255, 0, 0))
+
+                if self.gt_layout:
+                    for box in self.__get_groundtruth_bboxes(frame_idx):
+                        self.__draw_box(image, box, (0, 255, 0))
+
+                frame_idx+=1
+                if cv.waitKey(25) & 0xFF == ord('q'):
+                    break      
+        except Exception as e:
+            print(f"An error occurred: {e}")
+        finally:
+            cv.destroyAllWindows()
+
+    def __draw_box(self, image, box, color):
+        label, x1, y1, x2, y2 = box
+        cv.rectangle(image, (x1, y1), (x2, y2), color, 2)
+        cv.putText(image, label, (x1, y1 - 10), cv.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+        cv.imshow("Image", image)
+
+    def __get_groundtruth_bboxes(self, frame_idx):
+        return [item[1:] for item in self.gt_layout if item[0] == frame_idx]
+
+

src/utils/data_reader.py

@@ -1,7 +1,6 @@
 import csv
-
-
-class GroundtruthReader:
+import random
+class GroundtruthReader():
     @staticmethod
     def read(file_path):
         """
@@ -20,8 +19,8 @@ def read(file_path):
                         continue
 
                     frame_id, class_name, x1, y1, x2, y2 = row
-                    row_data = (int(frame_id), str(class_name), float(x1), float(y1),
-                                float(x2), float(y2))
+                    row_data = (int(frame_id), str(class_name), int(x1), int(y1),
+                                int(x2), int(y2))
                     parsed_data.append(row_data)
 
         except FileNotFoundError:
@@ -31,6 +30,69 @@ def read(file_path):
 
         return parsed_data
 
+class FakeGroundtruthReader(GroundtruthReader):
+    def __init__(self,
+                 max_frames = 1000,
+                 obj_classes = None,
+                 img_size = (1920, 1080),
+                 seed = None):
+        """
+        Initializing the synthetic data generator
+
+        :param max_frames: The maximum number of frames to generate
+        :param obj_classes:  List of object classes
+        :param img_size: Image size (width, height)
+        :param seed: Seed for reproducibility
+        """
+        super().__init__()
+        self.max_frames = max_frames
+        self.obj_classes = obj_classes or ['car', 'truck', 'bus']
+        self.img_width, self.img_height = img_size
+        self.seed = seed
+
+        if seed is not None:
+            random.seed(seed)
+
+    def read(self, file_path = None):
+        """
+        Parsing CSV file with groundtruths.
+
+        :param file_path: The path to the file with groundtruths.
+        :return: list[tuples] of parsed data by rows.
+        """
+        data = []
+
+        num_frames = random.randint(self.max_frames // 2, self.max_frames)
+
+        for frame_id in range(num_frames):
+            if random.random() < 0.2:
+                continue
+
+            num_objects = random.randint(1, 5)
+
+            for _ in range(num_objects):
+                x1, y1, w, h = self.__generate_bbox()
+                x2 = x1 + w
+                y2 = y1 + h
+
+                data.append((
+                    frame_id,
+                    random.choice(self.obj_classes),
+                    round(x1, 2),
+                    round(y1, 2),
+                    round(x2, 2),
+                    round(y2, 2)
+                ))
+
+        return data
+
+    def __generate_bbox(self):
+        """Генерация случайного bounding box."""
+        x = int(random.uniform(0, self.img_width - 50))
+        y = int(random.uniform(0, self.img_height - 50))
+        w = int(random.uniform(50, self.img_width - x))
+        h = int(random.uniform(50, self.img_height - y))
+        return (x, y, h, w)
 
 class DetectionReader:
     @staticmethod

src/utils/frame_data_reader.py

@@ -0,0 +1,69 @@
+import cv2 as cv
+import os
+from abc import ABC, abstractmethod
+
+class FrameDataReader(ABC):
+    @abstractmethod
+    def __iter__(self):
+        pass
+
+    @abstractmethod
+    def __next__(self):
+        pass
+
+    @staticmethod
+    def create(mode, dir_path):
+        if mode == "video":
+            return VideoDataReader(dir_path)
+        elif mode == "image":
+            return ImgDataReader(dir_path)
+        else:
+            raise ValueError(f"Unsupported mode: {mode}")
+
+class VideoDataReader(FrameDataReader):
+
+    def __init__(self, video_path):
+        self.video_path = video_path
+        self.cap = cv.VideoCapture(video_path)
+        if not self.cap.isOpened():
+            raise ValueError(f"Cannot open video file: {video_path}")
+
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.cap.isOpened():
+            ret, frame = self.cap.read()
+            if ret:
+                return frame
+            else:
+                self.cap.release()
+                raise StopIteration
+        else:
+            raise StopIteration
+
+class ImgDataReader(FrameDataReader):
+    def __init__(self, dir_path):
+        self.index = 0
+        self.directory_path = dir_path
+        if not os.path.exists(dir_path):
+            raise ValueError(f"Directory does not exist: {dir_path}")
+        self.image_files = [
+            os.path.join(dir_path, f) for f in os.listdir(dir_path)
+            if f.lower().endswith((".png", ".jpg", ".jpeg", ".bmp", ".tiff"))
+        ] 
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.index < len(self.image_files):
+            img_path = self.image_files[self.index]
+            self.index += 1
+            img = cv.imread(img_path)
+            if img is None:
+                raise ValueError(f"Cannot read image file: {img_path}")
+            return img
+        else:
+            raise StopIteration

src/vehicle_detector/detector.py

@@ -0,0 +1,47 @@
+import cv2 as cv
+import random
+from abc import ABC, abstractmethod
+class Detector(ABC):
+    @abstractmethod
+    def detect(image):
+        pass
+    @staticmethod
+    def create(mode):
+        if mode == "vehicle":
+            return VehicleDetector()
+        elif mode == "fake":
+            return FakeDetector()
+        else:
+            raise ValueError(f"Unsupported mode: {mode}")
+
+class VehicleDetector(Detector):
+    def __init__(self):
+        pass
+    def detect(image):
+        pass
+class FakeDetector(Detector):
+    def __init__(self, seed = None):
+        if seed is not None:
+            random.seed(seed)
+
+    @staticmethod
+    def detect(image):
+        if image is None or image.size == 0:
+            return []
+        height, width = image.shape[:2]
+        bboxes = []
+        num_boxes = random.randint(0, 7)
+
+        for _ in range(num_boxes):
+            if width < 2 or height < 2:
+                continue
+            cl = random.choice(["car", "bus", "truck"])
+            x1 = random.randint(0, width - 2)
+            x2 = random.randint(x1 + 1, width - 1)
+
+            y1 = random.randint(0, height - 2)
+            y2 = random.randint(y1 + 1, height - 1)
+
+            bboxes.append((cl, x1, y1, x2, y2))
+
+        return bboxes