msight-vision 0.1.0__tar.gz

msight_vision-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: msight_vision
+Version: 0.1.0
+Summary: 2D detection module for the MSight roadside perception system
+Author-email: Rusheng Zhang <rushengz@umich.edu>
+License: MIT
+Project-URL: Homepage, https://github.com/michigan-traffic-lab/MSight_Vision
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: opencv-python
+Requires-Dist: matplotlib
+Requires-Dist: geopy
+Requires-Dist: filterpy
+Requires-Dist: ultralytics
+
+# MSight 2D Detection Library
+
+# Installation
+## 1. Install pre-requirment
+This library is based on Pytorch, please follow the [the Pytorch official website](https://pytorch.org/) to install the the correct Pytorch version that is compatible with you machine's CUDA configuration.
+
+## 2. MSight dependency
+### MSight Base
+This library is based on [msight_base](https://github.com/michigan-traffic-lab/MSight_base), please follow the guidance to install them.
+
+## MSight Edge (Optional)
+If you want to use the packed node of this library, you need to install [msight_edge](https://github.com/michigan-traffic-lab/MSight_Edge2), follow the instruction and install it.

msight_vision-0.1.0/README.md

@@ -0,0 +1,12 @@
+# MSight 2D Detection Library
+
+# Installation
+## 1. Install pre-requirment
+This library is based on Pytorch, please follow the [the Pytorch official website](https://pytorch.org/) to install the the correct Pytorch version that is compatible with you machine's CUDA configuration.
+
+## 2. MSight dependency
+### MSight Base
+This library is based on [msight_base](https://github.com/michigan-traffic-lab/MSight_base), please follow the guidance to install them.
+
+## MSight Edge (Optional)
+If you want to use the packed node of this library, you need to install [msight_edge](https://github.com/michigan-traffic-lab/MSight_Edge2), follow the instruction and install it.

msight_vision-0.1.0/cli/launch_2d_viewer.py

@@ -0,0 +1,10 @@
+from msight_vision.msight_core import DetectionResults2DViewerNode
+from msight_core.utils import get_node_config_from_args, get_default_arg_parser
+
+def main():
+    parser = get_default_arg_parser(description="Launch Detection Results 2D Viewer Node", node_class=DetectionResults2DViewerNode)
+    args = parser.parse_args()
+    detection_node = DetectionResults2DViewerNode(
+        configs=get_node_config_from_args(args)
+    )
+    detection_node.spin()

msight_vision-0.1.0/cli/launch_custom_fuser.py

@@ -0,0 +1,23 @@
+from msight_vision.msight_core import FuserNode
+from msight_core.utils import get_node_config_from_args, get_default_arg_parser
+import time
+
+def main():
+    parser = get_default_arg_parser(description="Launch Fuser Node", node_class=FuserNode)
+    parser.add_argument("--fusion-config", "-fc", type=str, required=True, help="Path to the configuration file")
+    parser.add_argument("--wait", "-w", type=int, default=0, help="Wait time before starting the node (in seconds)")
+    args = parser.parse_args()
+    if args.wait > 0:
+        print(f"Waiting for {args.wait} seconds before starting the node...")
+        time.sleep(args.wait)
+
+    configs = get_node_config_from_args(args)
+
+    detection_node = FuserNode(
+        configs,
+        args.fusion_config,
+    )
+    detection_node.spin()
+
+if __name__ == "__main__":
+    main()

msight_vision-0.1.0/cli/launch_finite_difference_state_estimator.py

@@ -0,0 +1,22 @@
+from msight_vision.msight_core import FiniteDifferenceStateEstimatorNode
+from msight_core.utils import get_node_config_from_args, get_default_arg_parser
+import time
+
+def main():
+    parser =  get_default_arg_parser(description="Launch Finite Difference State Estimator Node", node_class=FiniteDifferenceStateEstimatorNode)
+    parser.add_argument("--estimator-configs", "-ec", type=str, required=True, help="Path to the configuration file")
+    parser.add_argument("--wait", "-w", type=int, default=0, help="Wait time before starting the node (in seconds)")
+    args = parser.parse_args()
+
+    if args.wait > 0:
+        print(f"Waiting for {args.wait} seconds before starting the node...")
+        time.sleep(args.wait)
+    configs = get_node_config_from_args(args)
+    detection_node = FiniteDifferenceStateEstimatorNode(
+        configs,
+        args.estimator_configs,
+    )
+    detection_node.spin()
+
+if __name__ == "__main__":
+    main()

msight_vision-0.1.0/cli/launch_road_user_list_viewer.py

@@ -0,0 +1,23 @@
+from msight_vision.msight_core import RoadUserListViewerNode
+from msight_core.utils import get_node_config_from_args, get_default_arg_parser
+
+def main():
+    parser = get_default_arg_parser(description="Launch Road User List Viewer Node", node_class=RoadUserListViewerNode)
+    parser.add_argument("--basemap", type=str, required=True, help="Path to the basemap image")
+    parser.add_argument("--show-trajectory", action='store_true', help="Flag to show trajectory")
+    parser.add_argument("--show-heading", action='store_true', help="Flag to show heading")
+    args = parser.parse_args()
+    configs = get_node_config_from_args(args)
+    # sub_topic = get_topic(redis_client, "example_fused_results")
+
+    detection_node = RoadUserListViewerNode(
+        configs,
+        args.basemap,
+        args.show_trajectory,
+        # False,
+        args.show_heading,
+    )
+    detection_node.spin()
+
+if __name__ == "__main__":
+    main()

msight_vision-0.1.0/cli/launch_sort_tracker.py

@@ -0,0 +1,24 @@
+from msight_vision.msight_core import SortTrackerNode
+from msight_core.utils import get_node_config_from_args, get_default_arg_parser
+import time
+
+def main():
+    parser = get_default_arg_parser(description="Launch SORT Tracker Node", node_class=SortTrackerNode)
+    parser.add_argument("--tracking-configs", "-tc", type=str, required=True,
+                        help="Path to the configuration file")
+    parser.add_argument("--wait", "-w", type=int, default=0, help="Wait time before starting the node (in seconds)")
+    args = parser.parse_args()
+
+    if args.wait > 0:
+        print(f"Waiting for {args.wait} seconds before starting the node...")
+        time.sleep(args.wait)
+
+    configs = get_node_config_from_args(args)
+    detection_node = SortTrackerNode(
+        configs,
+        args.tracking_configs,
+    )
+    detection_node.spin()
+
+if __name__ == "__main__":
+    main()

msight_vision-0.1.0/cli/launch_yolo_onestage_detection.py

@@ -0,0 +1,22 @@
+from msight_vision.msight_core import YoloOneStageDetectionNode
+from msight_core.utils import get_node_config_from_args, get_default_arg_parser
+import time
+
+def main():
+    parser = get_default_arg_parser(description="Launch YOLO One-Stage Detection Node", node_class=YoloOneStageDetectionNode)
+    parser.add_argument("--det-configs", "-dc", type=str, required=True, help="Path to the configuration file")
+    parser.add_argument("--wait", "-w", type=int, default=0, help="Wait time before starting the node (in seconds)")
+    args = parser.parse_args()
+
+    if args.wait > 0:
+        print(f"Waiting for {args.wait} seconds before starting the node...")
+        time.sleep(args.wait)
+    configs = get_node_config_from_args(args)
+    detection_node = YoloOneStageDetectionNode(
+        configs,
+        args.det_configs,
+    )
+    detection_node.spin()
+
+if __name__ == "__main__":
+    main()

msight_vision-0.1.0/msight_vision/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import version
+from .detector_yolo import YoloDetector, Yolo26Detector
+from .localizer import HashLocalizer
+from .tracker import SortTracker
+from .warper import ClassicWarper, ClassicWarperWithExternalUpdate
+from .fuser import FuserBase
+from .state_estimator import FiniteDifferenceStateEstimator
+__version__ = version("msight_vision")

msight_vision-0.1.0/msight_vision/base.py

@@ -0,0 +1,99 @@
+from msight_base import DetectionResultBase, DetectedObjectBase, RoadUserPoint
+import numpy as np
+from typing import List, Dict
+
+class DetectedObject2D(DetectedObjectBase):
+    """Detected object for 2D images."""
+
+    def __init__(self, box: list, class_id: int, score: float, pixel_bottom_center: List[float], obj_id: str = None, lat: float = None, lon: float = None, x: float = None, y: float = None):
+        """
+        Initialize the detected object.
+        :param box: bounding box coordinates (x1, y1, x2, y2)
+        :param class_id: class ID of the detected object
+        :param score: confidence score of the detection
+        :param obj_id: unique ID of the detected object (optional)
+        :param lat: latitude of the detected object (optional)
+        :param lon: longitude of the detected object (optional)
+        :param x: x coordinate in the coordination of interest like utm of the detected object (optional)
+        :param y: y coordinate in the coordination of intererst like utm of the detected object (optional)
+        """
+        super().__init__()
+        self.box = box
+        self.class_id = class_id
+        self.score = score
+        self.pixel_bottom_center = pixel_bottom_center
+        self.obj_id = obj_id
+        self.lat = lat
+        self.lon = lon
+        self.x = x
+        self.y = y
+
+    def to_dict(self):
+        """
+        Convert the detected object to a dictionary.
+        :return: dictionary representation of the detected object
+        """
+        return {
+            "box": self.box,
+            "class_id": self.class_id,
+            "score": self.score,
+            "obj_id": self.obj_id,
+            "lat": self.lat,
+            "lon": self.lon,
+            "x": self.x,
+            "y": self.y,
+            "pixel_bottom_center": self.pixel_bottom_center,
+        }
+    
+    @staticmethod
+    def from_dict(data: dict):
+        """
+        Create a DetectedObject2D instance from a dictionary.
+        :param data: dictionary representation of the detected object
+        :return: DetectedObject2D instance
+        """
+        return DetectedObject2D(
+            box=data["box"],
+            class_id=data["class_id"],
+            score=data["score"],
+            obj_id=data.get("obj_id"),
+            lat=data.get("lat") or None,
+            lon=data.get("lon") or None,
+            x=data.get("x") or None,
+            y=data.get("y") or None,
+            pixel_bottom_center=data.get("pixel_bottom_center") or None,
+        )
+
+    def __repr__(self):
+        return f"DetectedObject2D(box={self.box}, class_id={self.class_id}, score={self.score}, obj_id={self.obj_id}, lat={self.lat}, lon={self.lon}, x={self.x}, y={self.y})" 
+
+class DetectionResult2D(DetectionResultBase):
+    """Detection result for 2D images."""
+
+    def __init__(self, object_list: List[DetectedObject2D], timestamp: int, sensor_type: str):
+        """
+        Initialize the detection result.
+        :param detected_objects: list of detected objects
+        """
+        super().__init__(object_list, timestamp, sensor_type)
+
+class ImageDetector2DBase:
+    def detect(self, image: np.ndarray) -> DetectionResult2D:
+        """
+        Detector base, a detector detects objects in the image.
+        :param image: input image
+        :return: list of detected objects
+        """
+        raise NotImplementedError("detect method not implemented")
+    
+class TrackerBase:
+    def __init__(self):
+        pass
+
+    def track(self, list) ->Dict[str, RoadUserPoint]:
+        """
+        Track the detected objects in the image.
+        :param detection_result: DetectionResult2D instance
+        :return: updated DetectionResult2D instance with tracking information
+        """
+        raise NotImplementedError("track method not implemented")

msight_vision-0.1.0/msight_vision/detector_yolo.py

@@ -0,0 +1,87 @@
+from numpy import ndarray
+from msight_vision.base import DetectionResult2D, DetectedObject2D
+from .base import ImageDetector2DBase
+from ultralytics import YOLO
+from pathlib import Path
+
+class YoloDetector(ImageDetector2DBase):
+    """YOLOv5 detector for 2D images."""
+
+    def __init__(self, model_path: Path, device: str = "cpu", confthre: float = 0.25, nmsthre: float = 0.45, fp16: bool = False, class_agnostic_nms: bool = False):
+        """
+        Initialize the YOLO detector.
+        :param model_path: path to the YOLO model
+        :param device: device to run the model on (e.g., 'cpu', 'cuda')
+        """
+        super().__init__()
+        self.model = YOLO(str(model_path))
+        self.device = device
+        self.confthre = confthre
+        self.nmsthre = nmsthre
+        self.fp16 = fp16
+        self.class_agnostic_nms = class_agnostic_nms
+        
+
+    def convert_yolo_result_to_detection_result(self, yolo_output_results, timestamp, sensor_type):
+        """
+        Convert YOLO output results to DetectionResult2D.
+        :param yolo_output_results: YOLO output results
+        :param timestamp: timestamp of the image
+        :param sensor_type: type of the sensor
+        :return: DetectionResult2D instance
+        """
+        # Convert YOLO output to DetectionResult2D
+        bboxes = yolo_output_results[0].boxes.xyxy.cpu().numpy()
+        confs = yolo_output_results[0].boxes.conf.cpu().numpy()
+        class_ids = yolo_output_results[0].boxes.cls.cpu().numpy()
+        
+        detected_objects = []
+        for i in range(len(bboxes)):
+            box = bboxes[i]
+            class_id = int(class_ids[i])
+            score = float(confs[i])
+            # calculate the center coordinates of the bounding box
+            center_x = float((box[0] + box[2]) / 2)
+            center_y = float((box[1] + box[3]) / 2)
+            # print(class_id)
+            detected_object = DetectedObject2D(
+                box=[float(box[0]), float(box[1]), float(box[2]), float(box[3])],
+                class_id=class_id,
+                score=score,
+                pixel_bottom_center=[center_x, center_y],
+            )
+            detected_objects.append(detected_object)
+        
+        detection_result = DetectionResult2D(
+            detected_objects,
+            timestamp,
+            sensor_type,
+        )
+        
+        return detection_result
+    
+    def detect(self, image: ndarray, timestamp, sensor_type) -> DetectionResult2D:
+        yolo_output_results = self.model(image, device=self.device, conf=self.confthre, iou=self.nmsthre, half=self.fp16, verbose=False, agnostic_nms=self.class_agnostic_nms)
+        ## Convert results to DetectionResult2D
+        detection_result = self.convert_yolo_result_to_detection_result(
+            yolo_output_results,
+            timestamp,
+            sensor_type,
+        )
+        return detection_result
+    
+class Yolo26Detector(YoloDetector):
+    """YOLOv2.6 detector for 2D images."""
+    def __init__(self, model_path: Path, device: str = "cpu", confthre: float = 0.25, nmsthre: float = 0.45, fp16: bool = False, class_agnostic_nms: bool = False, end2end: bool = False):
+        super().__init__(model_path, device, confthre, nmsthre, fp16, class_agnostic_nms)
+
+        self.end2end = end2end
+    def detect(self, image: ndarray, timestamp, sensor_type) -> DetectionResult2D:
+        yolo_output_results = self.model(image, device=self.device, conf=self.confthre, iou=self.nmsthre, half=self.fp16, verbose=False, agnostic_nms=self.class_agnostic_nms, end2end=self.end2end)
+        ## Convert results to DetectionResult2D
+        detection_result = self.convert_yolo_result_to_detection_result(
+            yolo_output_results,
+            timestamp,
+            sensor_type,
+        )
+        return detection_result