Upload 2 files

helper.py

@@ -207,3 +207,17 @@ def make_table_from_dict(obj: dict, selected_key: str) -> list:
             table.append({"name": k, "value": v, "selected": False})
 
     return table
+
+
+def make_table_from_dict_multiselect(
+    obj: dict, selected_vals: list[int]
+) -> list:
+    table = []
+    for k, v in obj.items():
+        if v in selected_vals:
+            # print(k, v, selected_key)
+            table.append({"name": k, "value": v, "selected": True})
+        else:
+            table.append({"name": k, "value": v, "selected": False})
+
+    return table

webapp.py

@@ -5,6 +5,7 @@ import cv2
 import numpy as np
 from pathlib import Path
 import torch
+from zoneinfo import ZoneInfo
 from starlette.middleware import Middleware
 from starlette.responses import StreamingResponse, Response
 from starlette.requests import Request
@@ -19,7 +20,9 @@ from ultralytics_solutions_modified import object_counter, speed_estimation
 from vidgear.gears import CamGear
 from vidgear.gears.asyncio import WebGear
 from vidgear.gears.asyncio.helper import reducer
-from helper import draw_text, try_site, make_table_from_dict
+from helper import (
+    draw_text, make_table_from_dict_multiselect, make_table_from_dict, try_site
+)
 
 
 HERE = Path(__file__).parent
@@ -31,7 +34,7 @@ RETRY_TIMEOUT_MILSEC = 15000  # milisecond
 # Create and configure logger
 # logger = logging.getLogger(__name__).addHandler(logging.NullHandler())
 logging.basicConfig(
-    format='%(asctime)s %(name)-8s->%(module)-20s->%(funcName)-20s:%(lineno)-4s::%(levelname)-8s %(message)s',
+    format='%(asctime)s %(name)-8s->%(module)-20s->%(funcName)-20s:%(lineno)-4s::%(levelname)-8s %(message)s',  # noqa
     level=logging.INFO
 )
 
@@ -55,6 +58,7 @@ class DemoCase:
             "y8huge": "./data/models/yolov8x.pt",
         }
         self.model_choice_default: str = "y8small"
+        self.model_choice: str = self.model_choice_default
         # predefined youtube live stream urls
         self.url_dict: dict = {
             "Peace Bridge US": "https://youtu.be/9En2186vo5g",
@@ -67,26 +71,46 @@ class DemoCase:
             "Port Everglades-2": "https://youtu.be/Nhuu1QsW5LI",
             "Port Everglades-3": "https://youtu.be/Lpm-C_Gz6yM",
         }
+        self.obj_dict: dict = {
+            "person": 0,
+            "bicycle": 1,
+            "car": 2,
+            "motorcycle": 3,
+            "airplane": 4,
+            "bus": 5,
+            "train": 6,
+            "truck": 7,
+            "boat": 8,
+            "traffic light": 9,
+            "fire hydrant": 10,
+            "stop sign": 11,
+            "parking meter": 12
+        }
         self.cam_loc_default: str = "Peace Bridge US"
-        # run time parameters that are from user input
-        self.model_choice: str = self.model_choice_default
         self.cam_loc: str = self.cam_loc_default
-        self.roi_height: str = int(FRAME_HEIGHT / 2)
-        self.roi_thickness_half: str = 30
-        self.frame_reduction: int = 50
-        self.obj_class_id: list[int] = [2, 3, 5, 7]
-        # define some logic flow control booleans
-        self._is_running: bool = False
-        self._is_tracking: bool = False
-        # self._model_changed: bool = True
-        # self._cam_loc_changed: bool = True
-        # self._roi_height_changed: bool = True
-        # self._obj_class_id_changed: bool = False
+        self.frame_reduction: int = 35
+        
+        # run time parameters that are from user input
+        self.roi_height_default: int = int(FRAME_HEIGHT / 2)
+        self.roi_height: int = self.roi_height_default
+        self.roi_thickness_half_default: int = 30
+        self.roi_thickness_half: int = self.roi_thickness_half_default
+        self.obj_class_id_default: list[int] = [2, 3, 5, 7]
+        self.obj_class_id: list[int] = self.obj_class_id_default
+        self.conf_threshold: float = 0.25
+        self.iou_threshold: float = 0.7
+        self.use_FP16: bool = False
+        self.use_stream_buffer: bool = True
         self.stream0: CamGear = None
         self.stream1: CamGear = None
         self.counter = None
         self.speed_obj = None
 
+        # define some logic flow control booleans
+        self._is_running: bool = False
+        self._is_tracking: bool = False
+        self._roi_changed: bool = False
+
     def load_model(
         self,
         model_choice: str = "y8small",
@@ -123,10 +147,10 @@ class DemoCase:
             )
 
         # setup some configs
-        self.conf_threshold: float = conf_threshold if conf_threshold > 0.0 else 0.25   # noqa
-        self.iou_threshold: float = iou_threshold if iou_threshold > 0.0 else 0.7   # noqa
-        self.use_FP16: bool = use_FP16
-        self.use_stream_buffer: bool = use_stream_buffer
+        self.conf_threshold = conf_threshold if conf_threshold > 0.0 else 0.25   # noqa
+        self.iou_threshold = iou_threshold if iou_threshold > 0.0 else 0.7
+        self.use_FP16 = use_FP16
+        self.use_stream_buffer = use_stream_buffer
         logging.info(
             f"{self.model_choice}: conf={self.conf_threshold:.2f} | "
             f"iou={self.iou_threshold:.2f} | FP16={self.use_FP16} | "
@@ -144,9 +168,9 @@ class DemoCase:
         if (bool(cam_loc_key) is False or bool(cam_loc_val) is False):
             self.cam_loc = self.cam_loc_default
             logging.warning(
-                f"input cam_loc_key, cam_loc_val pair invalid, use default "
-                f"{{{self.cam_loc_default}: "
-                f"{self.url_dict[self.cam_loc_default]}}}"
+                f'input cam_loc_key, cam_loc_val pair invalid, use default '
+                f'{{{self.cam_loc_default}: '
+                f'{self.url_dict[self.cam_loc_default]}}}'
             )
         elif cam_loc_key not in self.url_dict:
             if try_site(self.url_dict[self.cam_loc]):
@@ -171,8 +195,40 @@ class DemoCase:
             f'use {{{self.cam_loc}: {self.url_dict[self.cam_loc]}}} as source'
         )
 
-    def set_roi_height(self, roi_height: int = 360):
-        if (roi_height < 0 or roi_height > self.FRAME_HEIGHT):
+    def select_obj_class_id(
+        self,
+        obj_names: list[str] = [
+            "person", "bicycle", "car", "motorcycle", "airplane", "bus",
+            "train", "truck", "boat", "traffic light", "fire hydrant",
+            "stop sign", "parking meter"
+        ]
+    ) -> None:
+        """
+            select object class id list based on the input obj_names str list
+        """
+        if (bool(obj_names) is False):
+            self.obj_class_id = self.obj_class_id_default
+            logging.warning(
+                f'input obj_names invalid, use default id {self.obj_class_id_default}'
+            )
+        else:
+            obj_class_id = []
+            for name in obj_names:
+                if name in list(self.obj_dict.keys()):
+                    obj_class_id.append(self.obj_dict[name])
+            if (len(obj_class_id) == 0):
+                self.obj_class_id = self.obj_class_id_default
+                logging.warning(
+                    f'input obj_names invalid, use default id '
+                    f'{self.obj_class_id_default}'
+                )
+            else:
+                self.obj_class_id = obj_class_id
+                logging.info(f'object class id set as {self.obj_class_id}')
+
+    # def set_roi(self, roi_height: int = 360, roi_thickness_half: int = 30):
+    def set_roi(self, roi_height: int = 360):
+        if (roi_height < 120 or roi_height > 600):
             self.roi_height = int(self.FRAME_HEIGHT / 2)
             logging.warning(
                 f'roi_height invalid, use default {int(self.FRAME_HEIGHT / 2)}'
@@ -181,12 +237,33 @@ class DemoCase:
             self.roi_height = roi_height
             logging.info(f'roi_height is set at {self.roi_height}')
 
-    def set_frame_reduction(self, frame_reduction: int = 50):
+        self.roi_thickness_half = self.roi_thickness_half_default
+
+        '''
+        if (
+            roi_thickness_half > 0 and
+            roi_thickness_half < int(self.FRAME_HEIGHT / 2)
+        ):
+            if (self.roi_height + roi_thickness_half > self.FRAME_HEIGHT):
+                self.roi_thickness_half = self.FRAME_HEIGHT - self.roi_height
+            elif (self.roi_height - roi_thickness_half < 0):
+                self.roi_thickness_half = self.roi_height
+            else:
+                self.roi_thickness_half = roi_thickness_half
+            logging.info(
+                f'roi_thickness_half is set at {self.roi_thickness_half}'
+            )
+        else:
+            self.roi_thickness_half = self.roi_thickness_half_default
+            logging.warning('roi_half_thickness invalid, use default 30')
+        '''
+
+    def set_frame_reduction(self, frame_reduction: int = 35):
         if (frame_reduction < 0 or frame_reduction > 100):
-            self.frame_reduction = 50
+            self.frame_reduction = 35
             logging.warning(
                 f'frame_reduction:{frame_reduction} invalid, '
-                f'use default value 50'
+                f'use default value 35'
             )
         else:
             self.frame_reduction = frame_reduction
@@ -222,8 +299,10 @@ class DemoCase:
                         # do something with your OpenCV frame here
                         draw_text(
                             img=frame,
-                            text=datetime.now().strftime("%m/%d/%Y %H:%M:%S"),
-                            pos=(int(self.FRAME_WIDTH - 400), 50),
+                            text=datetime.now(
+                                tz=ZoneInfo("America/Los_Angeles")
+                            ).strftime("%m/%d/%Y %H:%M:%S") + " PDT",
+                            pos=(int(self.FRAME_WIDTH - 500), 50),
                             font=cv2.FONT_HERSHEY_SIMPLEX,
                             font_scale=1,
                             font_thickness=2,
@@ -231,7 +310,7 @@ class DemoCase:
                             text_color=(0, 255, 255),
                             text_color_bg=(0, 0, 0),
                         )
-                        # reducer frame size for more performance, percentage int
+                        # reducer frame size for performance, percentage int
                         frame = await reducer(
                             frame, percentage=self.frame_reduction
                         )
@@ -245,11 +324,15 @@ class DemoCase:
 
                     if self.stream0 is not None:
                         self.stream0.stop()
+                        while self.stream0.read() is not None:
+                            continue
                         self.stream0 = None
                     self._is_running = False
                 except asyncio.CancelledError:
                     if self.stream0 is not None:
                         self.stream0.stop()
+                        while self.stream0.read() is not None:
+                            continue
                         self.stream0 = None
                     self._is_running = False
                     logging.warning(
@@ -308,8 +391,8 @@ class DemoCase:
                         logging=True
                     ).start()
 
-                if self._is_tracking:
-                    if self.counter is None:
+                if (self._is_tracking and self.stream1 is not None):
+                    if self.counter is None or self._roi_changed:
                         # setup object counter & speed estimator
                         region_points = [
                             (5, -self.roi_thickness_half + self.roi_height),
@@ -318,7 +401,7 @@ class DemoCase:
                                 self.FRAME_WIDTH - 5,
                                 self.roi_thickness_half + self.roi_height
                             ),
-                            (  
+                            (
                                 self.FRAME_WIDTH - 5,
                                 -self.roi_thickness_half + self.roi_height
                             ),
@@ -332,8 +415,9 @@ class DemoCase:
                             draw_boxes=False,
                             draw_reg_pts=True,
                         )
+                        self._roi_changed = False
 
-                    if self.speed_obj is None:
+                    if self.speed_obj is None or self._roi_changed:
                         # Init speed estimator
                         line_points = [
                             (5, self.roi_height),
@@ -345,9 +429,46 @@ class DemoCase:
                             names=self.model.names,
                             view_img=False
                         )
+                        self._roi_changed = False
 
                 try:
                     while (self.stream1 is not None and self._is_running):
+                        if self._roi_changed:
+                            # setup object counter & speed estimator
+                            region_points = [
+                                (5, -self.roi_thickness_half + self.roi_height),
+                                (5,  self.roi_thickness_half + self.roi_height),
+                                (
+                                    self.FRAME_WIDTH - 5,
+                                    self.roi_thickness_half + self.roi_height
+                                ),
+                                (
+                                    self.FRAME_WIDTH - 5,
+                                    -self.roi_thickness_half + self.roi_height
+                                ),
+                            ]
+                            self.counter = object_counter.ObjectCounter()
+                            self.counter.set_args(
+                                view_img=False,
+                                reg_pts=region_points,
+                                classes_names=self.model.names,
+                                draw_tracks=False,
+                                draw_boxes=False,
+                                draw_reg_pts=True,
+                            )
+                            # Init speed estimator
+                            line_points = [
+                                (5, self.roi_height),
+                                (self.FRAME_WIDTH - 5, self.roi_height)
+                            ]
+                            self.speed_obj = speed_estimation.SpeedEstimator()
+                            self.speed_obj.set_args(
+                                reg_pts=line_points,
+                                names=self.model.names,
+                                view_img=False
+                            )
+                            self._roi_changed = False
+
                         # read frame from provided source
                         frame = self.stream1.read()
                         if frame is None:
@@ -359,8 +480,10 @@ class DemoCase:
                         # do something with your OpenCV frame here
                         draw_text(
                             img=frame,
-                            text=datetime.now().strftime("%m/%d/%Y %H:%M:%S"),
-                            pos=(self.FRAME_WIDTH - 400, 50),
+                            text=datetime.now(
+                                tz=ZoneInfo("America/Los_Angeles")
+                            ).strftime("%m/%d/%Y %H:%M:%S") + " PDT",
+                            pos=(self.FRAME_WIDTH - 500, 50),
                             font=cv2.FONT_HERSHEY_SIMPLEX,
                             font_scale=1,
                             font_thickness=2,
@@ -370,7 +493,12 @@ class DemoCase:
                         )
 
                         frame_tagged = frame
-                        if self._is_tracking:
+                        if (
+                            self._is_tracking and self.model is not None
+                            and self.speed_obj is not None
+                            and self.counter is not None
+                            and self._roi_changed is False
+                        ):
                             # YOLOv8 tracking, persisting tracks between frames
                             results = self.model.track(
                                 source=frame,
@@ -408,6 +536,8 @@ class DemoCase:
 
                     if self.stream1 is not None:
                         self.stream1.stop()
+                        while self.stream1.read() is not None:
+                            continue
                         self.stream1 = None
                     self._is_tracking = False
                     self._is_running = False
@@ -415,12 +545,30 @@ class DemoCase:
                 except asyncio.CancelledError:
                     if self.stream1 is not None:
                         self.stream1.stop()
+                        while self.stream1.read() is not None:
+                            continue
                         self.stream1 = None
                     self._is_tracking = False
                     self._is_running = False
                     logging.warning(
                         "client disconnected in frame1_producer"
                     )
+                    frame = (np.random.standard_normal([
+                        self.FRAME_HEIGHT, self.FRAME_WIDTH, 3
+                    ]) * 255).astype(np.uint8)
+                    frame = await reducer(
+                        frame, percentage=self.frame_reduction
+                    )
+                    img_encoded = cv2.imencode(".jpg", frame)[1].tobytes()
+                    logging.info(
+                        f"_is_running is {self._is_running} in frame0_producer"
+                    )
+                    yield (
+                        b"--frame\r\nContent-Type:video/jpeg2000\r\n\r\n" +
+                        img_encoded + b"\r\n"
+                    )
+                    await asyncio.sleep(0.00001)
+
             else:
                 if self._is_running is True:
                     pass
@@ -496,6 +644,29 @@ class DemoCase:
         await asyncio.sleep(0.01)
         return response
 
+    async def objects(self, request: HtmxRequest) -> Response:
+        # assert (htmx := request.scope["htmx"])
+        if len(self.obj_dict) == 0:
+            template = "partials/ack.html"
+            table_contents = ["object list unavailable!"]
+            context = {"request": request, "table": table_contents}
+            response = templates.TemplateResponse(
+                template, context, status_code=200
+            )
+            # response.headers['Hx-Retarget'] = '#set-model-ack'
+        else:
+            template = "partials/object_list.html"
+            table_contents = make_table_from_dict_multiselect(
+                self.obj_dict, self.obj_class_id
+            )
+            context = {"request": request, "table": table_contents}
+            response = templates.TemplateResponse(
+                template, context, status_code=200
+            )
+
+        await asyncio.sleep(0.001)
+        return response
+
     async def geturl(self, request: HtmxRequest) -> Response:
         # assert (htmx := request.scope["htmx"])
         if len(self.url_dict) == 0:
@@ -745,6 +916,92 @@ class DemoCase:
         await asyncio.sleep(0.01)
         return response
 
+    async def selectobjects(self, request: HtmxRequest) -> Response:
+        # assert (htmx := request.scope["htmx"])
+        template = "partials/ack.html"
+        try:
+            req_json = await request.json()
+        except RuntimeError:
+            table_contents = ["receive channel unavailable!"]
+            context = {"request": request, "table": table_contents}
+            response = templates.TemplateResponse(
+                template, context, status_code=200
+            )
+            await asyncio.sleep(0.01)
+            return response
+
+        if ("payload" in req_json and "object_id" in req_json["payload"]):
+            logging.info(f"requested_ids: {req_json['payload']}")
+            req_ids = req_json["payload"]["object_id"]
+            if len(req_ids) > 0:
+                self.obj_class_id = [
+                    int(id) for id in req_ids
+                    if int(id) in self.obj_dict.values()
+                ]
+                if len(self.obj_class_id) > 0:
+                    table_contents = [
+                        f"{len(self.obj_class_id)} object types selected"
+                    ]
+                else:
+                    self.obj_class_id = self.obj_class_id_default
+                    table_contents = [
+                        "invalid objects selection, use default object types"
+                    ]
+        else:
+            table_contents = ["invalid POST request! need at least one object type"]
+
+        context = {"request": request, "table": table_contents}
+        response = templates.TemplateResponse(
+            template, context, status_code=200
+        )
+
+        await asyncio.sleep(0.01)
+        return response
+
+    async def setroi(self, request: HtmxRequest) -> Response:
+        # assert (htmx := request.scope["htmx"])
+        template = "partials/ack.html"
+        try:
+            req_json = await request.json()
+        except RuntimeError:
+            table_contents = ["receive channel unavailable!"]
+            context = {"request": request, "table": table_contents}
+            response = templates.TemplateResponse(
+                template, context, status_code=200
+            )
+            await asyncio.sleep(0.01)
+            return response
+
+        if ("payload" in req_json and "roi_height" in req_json["payload"]):
+            logging.info(f"{req_json['payload']}")
+            req_height = (int)(req_json["payload"]["roi_height"])
+            if (
+                req_height >= 120 and req_height <= 600 and
+                req_height < self.FRAME_HEIGHT
+            ):
+                self.roi_height = self.FRAME_HEIGHT - req_height
+                table_contents = [
+                    f"roi_height set at "
+                    f"{self.FRAME_HEIGHT - self.roi_height}px"
+                ]
+            else:
+                self.roi_height = self.roi_height_default
+                table_contents = [
+                    f"invalid roi_height request, use default"
+                    f"{self.FRAME_HEIGHT - self.roi_height_default}px"
+                ]
+            self._roi_changed = True
+        else:
+            table_contents = ["invalid POST request! need a valid roi_height"]
+
+        context = {"request": request, "table": table_contents}
+        response = templates.TemplateResponse(
+            template, context, status_code=200
+        )
+
+        await asyncio.sleep(0.01)
+        return response
+
     async def streamswitch(self, request: HtmxRequest) -> Response:
         # assert (htmx := request.scope["htmx"])
         template = "partials/ack.html"
@@ -815,10 +1072,10 @@ class DemoCase:
                 status_code = 201
                 # setup object counter & speed estimator
                 region_points = [
-                    (5, -self.roi_thickness_half + self.roi_height),
-                    (5,  self.roi_thickness_half + self.roi_height),
-                    (self.FRAME_WIDTH - 5, self.roi_thickness_half + self.roi_height),
-                    (self.FRAME_WIDTH - 5, -self.roi_thickness_half + self.roi_height),
+                    (5, -20 + self.roi_height),
+                    (5,  20 + self.roi_height),
+                    (self.FRAME_WIDTH - 5, 20 + self.roi_height),
+                    (self.FRAME_WIDTH - 5, -20 + self.roi_height),
                 ]
                 self.counter = object_counter.ObjectCounter()
                 self.counter.set_args(
@@ -861,7 +1118,9 @@ class DemoCase:
                 if await request.is_disconnected():
                     yield {
                             "event": "evt_in_counts",
-                            "id": datetime.now().strftime("%m/%d/%Y %H:%M:%S"),
+                            "id": datetime.now(
+                                tz=ZoneInfo("America/Los_Angeles")
+                            ).strftime("%m/%d/%Y %H:%M:%S"),
                             "retry": RETRY_TIMEOUT_MILSEC,
                             "data": "..."
                     }
@@ -874,7 +1133,9 @@ class DemoCase:
                         if (self.counter is not None and incounts_msg):
                             yield {
                                     "event": "evt_in_counts",
-                                    "id": datetime.now().strftime("%m/%d/%Y %H:%M:%S"),
+                                    "id": datetime.now(
+                                        tz=ZoneInfo("America/Los_Angeles")
+                                    ).strftime("%m/%d/%Y %H:%M:%S"),
                                     "retry": RETRY_TIMEOUT_MILSEC,
                                     "data": f"{self.counter.in_counts}"
                             }
@@ -882,7 +1143,9 @@ class DemoCase:
                         if _stop_sse is False:
                             yield {
                                     "event": "evt_in_counts",
-                                    "id": datetime.now().strftime("%m/%d/%Y %H:%M:%S"),
+                                    "id": datetime.now(
+                                        tz=ZoneInfo("America/Los_Angeles")
+                                    ).strftime("%m/%d/%Y %H:%M:%S"),
                                     "retry": RETRY_TIMEOUT_MILSEC,
                                     "data": "---"
                             }
@@ -898,7 +1161,9 @@ class DemoCase:
                 if await request.is_disconnected():
                     yield {
                             "event": "evt_out_counts",
-                            "id": datetime.now().strftime("%m/%d/%Y %H:%M:%S"),
+                            "id": datetime.now(
+                                tz=ZoneInfo("America/Los_Angeles")
+                            ).strftime("%m/%d/%Y %H:%M:%S"),
                             "retry": RETRY_TIMEOUT_MILSEC,
                             "data": "..."
                     }
@@ -911,62 +1176,46 @@ class DemoCase:
                         if (self.counter is not None and outcounts_msg):
                             yield {
                                     "event": "evt_out_counts",
-                                    "id": datetime.now().strftime("%m/%d/%Y %H:%M:%S"),
+                                    "id": datetime.now(
+                                        tz=ZoneInfo("America/Los_Angeles")
+                                    ).strftime("%m/%d/%Y %H:%M:%S"),
                                     "retry": RETRY_TIMEOUT_MILSEC,
                                     "data": f"{self.counter.out_counts}"
                             }
                     else:
                         if _stop_sse is False:
                             yield {
-                                    "event": "evt_out_counts",
-                                    "id": datetime.now().strftime("%m/%d/%Y %H:%M:%S"),
-                                    "retry": RETRY_TIMEOUT_MILSEC,
-                                    "data": "---"
+                                "event": "evt_out_counts",
+                                "id": datetime.now(
+                                    tz=ZoneInfo("America/Los_Angeles")
+                                ).strftime("%m/%d/%Y %H:%M:%S"),
+                                "retry": RETRY_TIMEOUT_MILSEC,
+                                "data": "---"
                             }
                             _stop_sse = True
                 await asyncio.sleep(EVT_STREAM_DELAY_SEC)
         return EventSourceResponse(event_generator())
 
 
+# is_huggingface = False
+# define the host url and port for webgear server
+# HOST_WEBGEAR, PORT_WEBGEAR = "localhost", 8080
+
 # instantiate a demo case
 demo_case = DemoCase(YOLO_VERBOSE=False)
-demo_case.set_frame_reduction(frame_reduction=30)
-demo_case.load_model()
-# setup object counter & speed estimator
-region_points = [
-    (5, -demo_case.roi_thickness_half + demo_case.roi_height),
-    (5,  demo_case.roi_thickness_half + demo_case.roi_height),
-    (
-        demo_case.FRAME_WIDTH - 5,
-        demo_case.roi_thickness_half + demo_case.roi_height
-    ),
-    (
-        demo_case.FRAME_WIDTH - 5,
-        -demo_case.roi_thickness_half + demo_case.roi_height
-    ),
-]
-demo_case.counter = object_counter.ObjectCounter()
-demo_case.counter.set_args(
-    view_img=False,
-    reg_pts=region_points,
-    classes_names=demo_case.model.names,
-    draw_tracks=False,
-    draw_boxes=False,
-    draw_reg_pts=True,
+demo_case.set_frame_reduction(frame_reduction=35)
+demo_case.load_model(
+    model_choice="y8small",
+    conf_threshold=0.1,
+    iou_threshold=0.6,
+    use_FP16=False,
+    use_stream_buffer=True
 )
-# Init speed estimator
-line_points = [
-    (5, demo_case.roi_height),
-    (demo_case.FRAME_WIDTH - 5, demo_case.roi_height)
-]
-demo_case.speed_obj = speed_estimation.SpeedEstimator()
-demo_case.speed_obj.set_args(
-    reg_pts=line_points,
-    names=demo_case.model.names,
-    view_img=False
-)
-logging.info([f"{x}" for x in list(demo_case.url_dict.keys())])
-logging.info([f"{x}" for x in list(demo_case.model_dict.keys())])
+logging.info(f"url_dict: {demo_case.url_dict}")
+logging.info(f"model_dict: {demo_case.model_dict}")
+logging.info(f"obj_dict: {demo_case.obj_dict}")
+logging.info(f"obj_class_id: {demo_case.obj_class_id}")
+# logging.info(f"model.names: {demo_case.model.names}")
 
 # setup webgear server
 options = {
@@ -976,16 +1225,17 @@ options = {
     "jpeg_compression_fastdct": True,
     "jpeg_compression_fastupsample": True,
 }
+
 web = WebGear(
     logging=True, **options
 )
 # config webgear server
-web.config["generator"] = demo_case.frame0_producer
+web.config["generator"] = demo_case.frame1_producer
 web.config["middleware"] = [Middleware(HtmxMiddleware)]
 web.routes.append(Mount("/static", static, name="static"))
-web.routes.append(
-    Route("/video1", endpoint=demo_case.custom_video_response)
-)
+# web.routes.append(
+#     Route("/video1", endpoint=demo_case.custom_video_response)
+# )
 routes_dict = {
     "models": (demo_case.models, ["GET"]),
     "getmodel": (demo_case.getmodel, ["GET"]),
@@ -994,6 +1244,9 @@ routes_dict = {
     "addurl": (demo_case.addurl, ["POST"]),
     "geturl": (demo_case.geturl, ["GET"]),
     "seturl": (demo_case.seturl, ["POST"]),
+    "objects": (demo_case.objects, ["GET"]),
+    "selectobjects": (demo_case.selectobjects, ["POST"]),
+    "setroi": (demo_case.setroi, ["POST"]),
     "streamswitch": (demo_case.streamswitch, ["POST"]),
     "trackingswitch": (demo_case.trackingswitch, ["POST"]),
 }
@@ -1011,3 +1264,14 @@ web.routes.append(Route(
     endpoint=demo_case.sse_outcounts,
     name="sseoutcounts"
 ))
+
+# if is_huggingface is False:
+#     # run this app on Uvicorn server at address http://localhost:8080/
+#     uvicorn.run(
+#         web(), host=HOST_WEBGEAR, port=PORT_WEBGEAR, log_level="info"
+#     )
+#     # close app safely
+#     web.shutdown()
+#
+# or launch it using cli --
+# uvicorn webapp:web --host "localhost" --port 8080 --reload