blobtrack 0.1.2__py3-none-any.whl

blobtrack/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

blobtrack/app.py

@@ -0,0 +1,668 @@
+import cv2
+import numpy as np
+import dearpygui.dearpygui as dpg
+import argparse
+import time
+
+SIZE_PRESETS = [16, 32, 64, 128, 256, 512]
+FILTERS = ["None", "Invert", "Blur", "Pixelate", "Thermal", "Edge"]
+SHAPES = ["Square", "Circle", "None"] 
+
+SPEED_PRESETS = [ ("1x", 1), ("1.25x", 1.25), ("1.50x", 1.50), ("1.75x", 1.75), ("2x", 2.0)]
+
+RESOLUTION_PRESETS = [("Native", 1.0), ("75%", 0.75), ("50%", 0.5), ("25%", 0.25)]
+
+COLOR_PRESETS = [
+    ("Green",   (0, 255, 0)),
+    ("Red",     (0, 0, 255)),
+    ("Blue",    (255, 0, 0)),
+    ("Yellow",  (0, 255, 255)),
+    ("Cyan",    (255, 255, 0)),
+    ("Magenta", (255, 0, 255)),
+]
+
+VIDEO_TEXTURE_TAG = "video_texture"
+VIDEO_IMAGE_TAG = "video_image"
+
+MAX_TEXTURE_DIM = 1920
+SIDEBAR_WIDTH = 300
+
+SELECTED_BTN_COLOR = (70, 130, 220, 255)
+DEFAULT_BTN_COLOR = (45, 45, 48, 255)
+
+
+def apply_box_filter(roi, filter_name):
+    if roi.size == 0:
+        return roi
+    if filter_name == "Invert":
+        return cv2.bitwise_not(roi)
+    if filter_name == "Blur":
+        return cv2.GaussianBlur(roi, (15, 15), 0)
+    if filter_name == "Pixelate":
+        h, w = roi.shape[:2]
+        small = cv2.resize(roi, (max(w // 10, 1), max(h // 10, 1)), interpolation=cv2.INTER_LINEAR)
+        return cv2.resize(small, (w, h), interpolation=cv2.INTER_NEAREST)
+    if filter_name == "Thermal":
+        gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
+        return cv2.applyColorMap(gray, cv2.COLORMAP_JET)
+    if filter_name == "Edge":
+        gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
+        edges = cv2.Canny(gray, 80, 160)
+        return cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+    return roi
+
+
+def compute_display_size(w, h, max_dim=780):
+    """Only used as a fallback before the real video_panel size is known."""
+    scale = min(max_dim / w, max_dim / h, 1.0)
+    return max(int(w * scale), 1), max(int(h * scale), 1)
+
+
+class BlobTrackerApp:
+    def __init__(self, source=None):
+        self.cap = None
+        self.is_file = isinstance(source, str)
+        self.frame_w, self.frame_h = 640, 480
+        self.tex_w, self.tex_h = compute_display_size(640, 480, MAX_TEXTURE_DIM)
+        self.disp_w, self.disp_h = self.tex_w, self.tex_h
+        self.fps = 30
+        self.total_frames = None
+        self.paused = False
+        self.fullscreen = False
+        self.current_texture_tag = VIDEO_TEXTURE_TAG
+        self.texture_counter = 0
+
+        self.backsub = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=25, detectShadows=True)
+
+        self.writer = None
+        self.recording = False
+        self.record_start_time = None
+        self.record_start_frame = 0
+        self._record_speed = None
+
+        self.shape_sel = "Square"
+        self.filter_sel = "None"
+        self.shape_color_sel = "Green"
+        self.line_color_sel = "Green"
+        self.playback_speed_sel = "1x"
+        self.res_scale_sel = "Native"
+        self.custom_colors = {"boxclr_btn": (0, 255, 0), "lineclr_btn": (0, 255, 0)}  # BGR
+
+        self._next_frame_due = None
+        self._last_applied_scale = None
+        self._rgba_buf = None
+        self._tex_buf = None
+        self._alloc_texture_buffers()
+
+        if source is not None:
+            self._open_source(source, first_time=True)
+
+    def _alloc_texture_buffers(self):
+        self._rgba_buf = np.empty((self.tex_h, self.tex_w, 4), dtype=np.uint8)
+        self._tex_buf = np.empty((self.tex_h, self.tex_w, 4), dtype=np.float32)
+
+    def _open_source(self, source, first_time=False):
+        if source is None:
+            return
+        if self.cap:
+            self.cap.release()
+        self.cap = cv2.VideoCapture(source)
+        self.is_file = isinstance(source, str)
+        if not self.cap.isOpened():
+            print(f"Could not open source: {source}")
+            return
+
+        if dpg.does_item_exist("placeholder_text"):
+            dpg.hide_item("placeholder_text")
+        self.frame_w = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH)) or 640
+        self.frame_h = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) or 480
+        self.fps = self.cap.get(cv2.CAP_PROP_FPS) or 30
+        self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT)) if self.is_file else None
+        self.backsub = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=25, detectShadows=True)
+        self._next_frame_due = None
+
+        self.tex_w, self.tex_h = self._compute_tex_dims(self._current_res_scale())
+        self._alloc_texture_buffers()
+        self._last_applied_scale = self._current_res_scale()
+
+        if not first_time:
+            self._rebuild_texture()
+
+    def _rebuild_texture(self):
+        old_tag = self.current_texture_tag
+        new_tag = f"video_texture_{self.texture_counter}"
+        self.texture_counter += 1
+
+        blank = np.zeros((self.tex_h, self.tex_w, 4), dtype=np.float32)
+        with dpg.texture_registry():
+            dpg.add_dynamic_texture(self.tex_w, self.tex_h, blank.flatten(), tag=new_tag)
+
+        dpg.configure_item(VIDEO_IMAGE_TAG, texture_tag=new_tag, width=self.disp_w, height=self.disp_h)
+        self.current_texture_tag = new_tag
+
+        if old_tag and dpg.does_item_exist(old_tag):
+            dpg.delete_item(old_tag)
+
+    def _make_button_group(self, options, selected_attr, tag_prefix, columns=3):
+        """A grid of buttons that behave like a single-select group, highlighting the active one."""
+        for i, opt in enumerate(options):
+            if i % columns == 0 and i > 0:
+                pass  
+        with dpg.table(header_row=False, tag=f"{tag_prefix}_table"):
+            for _ in range(columns):
+                dpg.add_table_column()
+            for i in range(0, len(options), columns):
+                with dpg.table_row():
+                    for opt in options[i:i + columns]:
+                        tag = f"{tag_prefix}_{opt}"
+                        dpg.add_button(label=opt, tag=tag, width=-1,
+                                       callback=self._make_select_callback(selected_attr, tag_prefix, options))
+        self._refresh_button_group(selected_attr, tag_prefix, options)
+
+    def _make_select_callback(self, selected_attr, tag_prefix, options):
+        def callback(sender, app_data, user_data):
+            label = dpg.get_item_configuration(sender)["label"]
+            setattr(self, selected_attr, label)
+            self._refresh_button_group(selected_attr, tag_prefix, options)
+        return callback
+
+    def _refresh_button_group(self, selected_attr, tag_prefix, options):
+        current = getattr(self, selected_attr)
+        for opt in options:
+            tag = f"{tag_prefix}_{opt}"
+            if not dpg.does_item_exist(tag):
+                continue
+            with dpg.theme() as t:
+                with dpg.theme_component(dpg.mvButton):
+                    color = SELECTED_BTN_COLOR if opt == current else DEFAULT_BTN_COLOR
+                    dpg.add_theme_color(dpg.mvThemeCol_Button, color)
+            dpg.bind_item_theme(tag, t)
+
+    def _color_button_group(self, tag_prefix, selected_attr):
+        names = [c[0] for c in COLOR_PRESETS] + ["Custom"]
+
+        popup_tag = f"{tag_prefix}_popup"
+        with dpg.window(tag=popup_tag, show=False, modal=True, no_title_bar=False,
+                         label="Pick a color", width=280, height=330, no_resize=True):
+            dpg.add_color_picker(
+                tag=f"{tag_prefix}_picker", default_value=(0, 255, 0, 255), no_alpha=True,
+                width=250,
+                callback=lambda s, a: self._on_custom_color_picked(tag_prefix, selected_attr, a)
+            )
+            dpg.add_button(label="Done", width=-1, callback=lambda: dpg.hide_item(popup_tag))
+
+        with dpg.table(header_row=False, tag=f"{tag_prefix}_table"):
+            for _ in range(3):
+                dpg.add_table_column()
+            for i in range(0, len(names), 3):
+                with dpg.table_row():
+                    for name in names[i:i + 3]:
+                        tag = f"{tag_prefix}_{name}"
+                        if name == "Custom":
+                            dpg.add_button(label="Custom", tag=tag, width=-1,
+                                           callback=lambda: dpg.show_item(popup_tag))
+                        else:
+                            dpg.add_button(label=name, tag=tag, width=-1,
+                                           callback=self._make_select_callback(selected_attr, tag_prefix, names))
+        self._refresh_color_group(tag_prefix, selected_attr)
+
+    def _on_custom_color_picked(self, tag_prefix, selected_attr, rgba_float):
+        r, g, b = int(rgba_float[0] * 255), int(rgba_float[1] * 255), int(rgba_float[2] * 255)
+        self.custom_colors[tag_prefix] = (b, g, r)  
+        setattr(self, selected_attr, "Custom")
+        self._refresh_color_group(tag_prefix, selected_attr)
+
+    def _refresh_color_group(self, tag_prefix, selected_attr):
+        current = getattr(self, selected_attr)
+        preset_map = dict(COLOR_PRESETS)
+        names = list(preset_map.keys()) + ["Custom"]
+        for name in names:
+            tag = f"{tag_prefix}_{name}"
+            if not dpg.does_item_exist(tag):
+                continue
+            with dpg.theme() as t:
+                with dpg.theme_component(dpg.mvButton):
+                    color = SELECTED_BTN_COLOR if name == current else DEFAULT_BTN_COLOR
+                    dpg.add_theme_color(dpg.mvThemeCol_Button, color)
+            dpg.bind_item_theme(tag, t)
+
+    def _current_speed(self):
+        return dict(SPEED_PRESETS).get(self.playback_speed_sel, 1.0)
+
+    def _current_res_scale(self):
+        return dict(RESOLUTION_PRESETS).get(self.res_scale_sel, 1.0)
+
+    def _compute_tex_dims(self, scale):
+        if scale >= 0.999:
+            return compute_display_size(self.frame_w, self.frame_h, MAX_TEXTURE_DIM)
+        return max(int(self.frame_w * scale), 1), max(int(self.frame_h * scale), 1)
+
+    def _set_speed_buttons_enabled(self, enabled):
+        for label, _ in SPEED_PRESETS:
+            tag = f"speed_btn_{label}"
+            if not dpg.does_item_exist(tag):
+                continue
+            if enabled:
+                dpg.enable_item(tag)
+            else:
+                dpg.disable_item(tag)
+
+    def toggle_record(self):
+        if not self.recording:
+            dpg.show_item("save_dialog")
+        else:
+            self._stop_recording()
+
+    def save_recording_callback(self, sender, app_data):
+        path = app_data["file_path_name"]
+        if not path:
+            return
+        if not path.lower().endswith(".mp4"):
+            path += ".mp4"
+
+        if self.is_file and self.cap:
+            self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+            self._next_frame_due = None
+
+        if self.paused:
+            self.paused = False
+            if dpg.does_item_exist("pause_btn"):
+                dpg.configure_item("pause_btn", label="Pause")
+
+        speed = self._current_speed()
+        effective_fps = self.fps * speed
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        self.writer = cv2.VideoWriter(path, fourcc, effective_fps, (self.frame_w, self.frame_h))
+        self.recording = True
+        self._record_speed = speed
+        self.record_start_time = time.time()
+        self.record_start_frame = 0
+        dpg.configure_item("record_btn", label="Stop Recording")
+        self._set_speed_buttons_enabled(False)
+        print(f"Recording started -> {path} (export fps {effective_fps:.2f}, {speed}x speed)")
+
+    def _stop_recording(self):
+        if self.writer:
+            self.writer.release()
+        self.writer = None
+        self.recording = False
+        self._record_speed = None
+        if dpg.does_item_exist("record_btn"):
+            dpg.configure_item("record_btn", label="Record")
+        if dpg.does_item_exist("progress_bar"):
+            dpg.set_value("progress_bar", 0.0)
+            dpg.set_value("progress_text", "")
+        self._set_speed_buttons_enabled(True)
+        print("Recording stopped and saved.")
+
+    def toggle_pause(self):
+        self.paused = not self.paused
+        dpg.configure_item("pause_btn", label="Play" if self.paused else "Pause")
+        self._next_frame_due = None
+
+    def toggle_fullscreen(self):
+        self.fullscreen = not self.fullscreen
+        dpg.toggle_viewport_fullscreen()
+
+        if self.fullscreen:
+            dpg.hide_item("sidebar")
+        else:
+            dpg.show_item("sidebar")
+
+        dpg.set_frame_callback(dpg.get_frame_count() + 5, lambda: self.resize_video_display())
+
+    def resize_video_display(self):
+        if not dpg.does_item_exist("video_panel"):
+            return
+        w, h = dpg.get_item_rect_size("video_panel")
+        if w <= 10 or h <= 10:
+            return
+
+        target_w, target_h = int(w), int(h)
+        if target_w != self.disp_w or target_h != self.disp_h:
+            self.disp_w, self.disp_h = target_w, target_h
+            dpg.configure_item(VIDEO_IMAGE_TAG, width=target_w, height=target_h)
+            if dpg.does_item_exist("placeholder_text"):
+                tw = dpg.get_text_size("Load a video to begin")
+                tw = tw[0] if tw else 180
+                dpg.set_item_pos("placeholder_text", [max((target_w - tw) // 2, 0), target_h // 2])
+
+    def load_video_callback(self, sender, app_data):
+        path = app_data["file_path_name"]
+        if path:
+            self._stop_recording()
+            self._open_source(path)
+
+    def update(self):
+        if self.cap is None or not self.cap.isOpened():
+            return
+        if self.paused:
+            return
+
+        current_scale = self._current_res_scale()
+        if current_scale != self._last_applied_scale:
+            self.tex_w, self.tex_h = self._compute_tex_dims(current_scale)
+            self._alloc_texture_buffers()
+            self._rebuild_texture()
+            self.backsub = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=25, detectShadows=True)
+            self._last_applied_scale = current_scale
+
+        now = time.perf_counter()
+        frame_interval = 0
+        if self.is_file:
+            speed = self._current_speed()
+            if speed <= 0:
+                speed = 1.0
+            frame_interval = (1.0 / self.fps) / speed if self.fps > 0 else 0
+
+            if self._next_frame_due is None:
+                self._next_frame_due = now
+
+            if now < self._next_frame_due:
+                return  
+
+           
+            if not self.recording and frame_interval > 0:
+                behind = now - self._next_frame_due
+                skip_count = min(int(behind / frame_interval), 10)  # sanity cap
+                for _ in range(skip_count):
+                    if not self.cap.grab():
+                        break
+                self._next_frame_due += skip_count * frame_interval
+
+        ret, frame = self.cap.read()
+        if not ret:
+            if self.is_file:
+                if self.recording:
+                    self._stop_recording()
+                    print("Reached end of clip — recording auto-stopped.")
+                self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                self._next_frame_due = None
+                return
+            else:
+                return
+
+        if self.is_file:
+            self._next_frame_due += frame_interval
+            if self._next_frame_due < now - frame_interval:
+                self._next_frame_due = now + frame_interval
+
+        if self.recording or (self.tex_w == self.frame_w and self.tex_h == self.frame_h):
+            proc_frame = frame
+        else:
+            proc_frame = cv2.resize(frame, (self.tex_w, self.tex_h), interpolation=cv2.INTER_AREA)
+        proc_h, proc_w = proc_frame.shape[:2]
+        frame_area = proc_w * proc_h
+
+        res_scale = proc_w / self.frame_w if self.frame_w else 1.0
+
+        min_area = dpg.get_value("min_area") * (res_scale ** 2)
+        max_blobs = dpg.get_value("max_blobs")
+        shape_size = max(2, round(SIZE_PRESETS[dpg.get_value("box_size_idx")] * res_scale))
+        box_thickness = max(1, round(dpg.get_value("box_thk") * res_scale))
+        connect_lines = dpg.get_value("connect")
+        connect_neighbors = dpg.get_value("connect_neighbors")
+        line_thickness = max(1, round(dpg.get_value("line_thk") * res_scale))
+        font_scale = dpg.get_value("font_size") * res_scale
+
+        preset_map = dict(COLOR_PRESETS)
+        shape_color = (self.custom_colors["boxclr_btn"] if self.shape_color_sel == "Custom"
+                       else preset_map[self.shape_color_sel])
+        line_color = (self.custom_colors["lineclr_btn"] if self.line_color_sel == "Custom"
+                      else preset_map[self.line_color_sel])
+
+        mask = self.backsub.apply(proc_frame)
+        _, mask = cv2.threshold(mask, 200, 255, cv2.THRESH_BINARY)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, None, iterations=2)
+        mask = cv2.dilate(mask, None, iterations=2)
+
+        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        blobs = [c for c in contours if cv2.contourArea(c) >= min_area]
+        blobs = sorted(blobs, key=cv2.contourArea, reverse=True)[:max_blobs]
+
+        centroids = []
+        for c in blobs:
+            x, y, w, h = cv2.boundingRect(c)
+            cx, cy = x + w // 2, y + h // 2
+            centroids.append((cx, cy))
+
+            half = shape_size // 2
+            x1, y1 = max(cx - half, 0), max(cy - half, 0)
+            x2, y2 = min(cx + half, proc_w), min(cy + half, proc_h)
+
+            if self.filter_sel != "None" and x2 > x1 and y2 > y1:
+                roi = proc_frame[y1:y2, x1:x2]
+                proc_frame[y1:y2, x1:x2] = apply_box_filter(roi, self.filter_sel)
+
+            if self.shape_sel == "Circle":
+                cv2.circle(proc_frame, (cx, cy), half, shape_color, box_thickness)
+            elif self.shape_sel == "Square":
+                cv2.rectangle(proc_frame, (x1, y1), (x2, y2), shape_color, box_thickness)
+
+            score = cv2.contourArea(c) / frame_area
+            cv2.putText(proc_frame, f"{score:.4f}", (x1, y1 - 6),
+                        cv2.FONT_HERSHEY_SIMPLEX, font_scale, shape_color, 1, cv2.LINE_AA)
+
+        if connect_lines and len(centroids) > 1:
+            pts = np.array(centroids, dtype=np.float32)
+            n = len(pts)
+            k = max(1, min(int(connect_neighbors), n - 1))
+            diffs = pts[:, None, :] - pts[None, :, :]
+            dist_sq = np.sum(diffs * diffs, axis=2)
+            np.fill_diagonal(dist_sq, np.inf)
+            finite = dist_sq[np.isfinite(dist_sq)]
+            max_dist = float(np.sqrt(finite.max())) if finite.size else 1.0
+            max_dist = max(max_dist, 1e-6)
+
+            drawn = set()
+            for i in range(n):
+                nearest = np.argpartition(dist_sq[i], k)[:k]
+                for j in nearest:
+                    j = int(j)
+                    pair = (i, j) if i < j else (j, i)
+                    if pair in drawn:
+                        continue
+                    drawn.add(pair)
+                    dist = float(np.sqrt(dist_sq[i, j]))
+                    fade = 1.0 - 0.7 * min(dist / max_dist, 1.0)  
+                    faded_color = tuple(int(c * fade) for c in line_color)
+                    cv2.line(proc_frame, centroids[i], centroids[j], faded_color, line_thickness)
+
+        if self.recording:
+            self.writer.write(proc_frame)
+
+        if self.recording:
+            elapsed = time.time() - self.record_start_time
+            if self.is_file and self.total_frames:
+                cur_frame = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))
+                frames_done = max(cur_frame - self.record_start_frame, 0)
+                pct = min(frames_done / self.total_frames, 1.0)
+                dpg.set_value("progress_bar", pct)
+                dpg.set_value("progress_text", f"Recording {pct*100:.0f}%")
+            else:
+                dpg.set_value("progress_bar", 0.0)
+                dpg.set_value("progress_text", f"Recording {elapsed:.1f}s")
+
+        if proc_w == self.tex_w and proc_h == self.tex_h:
+            display_frame = proc_frame
+        else:
+            upscaling = self.tex_w > proc_w or self.tex_h > proc_h
+            interp = cv2.INTER_LINEAR if upscaling else cv2.INTER_AREA
+            display_frame = cv2.resize(proc_frame, (self.tex_w, self.tex_h), interpolation=interp)
+        cv2.cvtColor(display_frame, cv2.COLOR_BGR2RGBA, dst=self._rgba_buf)
+        np.divide(self._rgba_buf, 255.0, out=self._tex_buf, casting="unsafe")
+        dpg.set_value(self.current_texture_tag, self._tex_buf.ravel())
+
+    def run(self):
+        dpg.create_context()
+
+        with dpg.theme() as global_theme:
+            
+            with dpg.theme_component(dpg.mvAll):
+                dpg.add_theme_color(dpg.mvThemeCol_WindowBg, (30, 30, 30, 255))
+                dpg.add_theme_color(dpg.mvThemeCol_ChildBg, (30, 30, 30, 255))
+                dpg.add_theme_color(dpg.mvThemeCol_Text, (230, 230, 230, 255))
+                dpg.add_theme_color(dpg.mvThemeCol_Button, DEFAULT_BTN_COLOR)
+                dpg.add_theme_color(dpg.mvThemeCol_FrameBg, (45, 45, 48, 255))
+                dpg.add_theme_style(dpg.mvStyleVar_FrameRounding, 6)
+                dpg.add_theme_style(dpg.mvStyleVar_WindowRounding, 0)
+        dpg.bind_theme(global_theme)
+        
+        with dpg.theme() as main_window_theme:
+            with dpg.theme_component(dpg.mvAll):
+                dpg.add_theme_style(dpg.mvStyleVar_WindowPadding, 0, 0)
+                dpg.add_theme_style(dpg.mvStyleVar_ItemSpacing, 0, 0)
+                dpg.add_theme_style(dpg.mvStyleVar_ChildBorderSize, 0)
+                
+        with dpg.theme() as sidebar_theme:
+            with dpg.theme_component(dpg.mvChildWindow):
+                dpg.add_theme_style(dpg.mvStyleVar_WindowPadding, 16, 8)
+
+        with dpg.texture_registry():
+            initial = np.zeros((self.tex_h, self.tex_w, 3), dtype=np.uint8)
+            initial_rgba = cv2.cvtColor(initial, cv2.COLOR_BGR2RGBA).astype(np.float32) / 255.0
+            dpg.add_dynamic_texture(self.tex_w, self.tex_h, initial_rgba.flatten(), tag=VIDEO_TEXTURE_TAG)
+
+        with dpg.file_dialog(directory_selector=False, show=False, callback=self.load_video_callback,
+                              tag="file_dialog", width=600, height=400):
+            dpg.add_file_extension(".mp4,.avi,.mov,.mkv", color=(0, 255, 0, 255))
+            dpg.add_file_extension(".*")
+            
+        with dpg.file_dialog(directory_selector=False, show=False, callback=self.save_recording_callback,
+                      tag="save_dialog", width=600, height=400, default_filename="recording",
+                      modal=True):
+            dpg.add_file_extension(".mp4", color=(0, 255, 0, 255))
+
+        with dpg.window(tag="main_window", no_scrollbar=True):
+            dpg.bind_item_theme("main_window", main_window_theme)
+            with dpg.group(horizontal=True):
+                with dpg.child_window(width=SIDEBAR_WIDTH, autosize_y=True, tag="sidebar", border=False):
+                    with dpg.group(horizontal=True):
+                        dpg.add_spacer(width=16)
+                        with dpg.child_window(width=SIDEBAR_WIDTH - 32, autosize_y=True, tag="sidebar_inner", border=False, no_scrollbar=True):
+                            dpg.add_spacer(height=10)
+
+                            dpg.add_text("Minimum Area")
+                            dpg.add_slider_int(tag="min_area", default_value=500, min_value=0, max_value=10000, width=-1)
+
+                            dpg.add_text("Max Blobs")
+                            dpg.add_slider_int(tag="max_blobs", default_value=20, min_value=1, max_value=100, width=-1)
+
+                            dpg.add_text(" Shape")
+                            self._make_button_group(SHAPES, "shape_sel", "shape_btn", columns=3)
+
+                            dpg.add_text("Bounding Size")
+                            dpg.add_slider_int(tag="box_size_idx", default_value=1, min_value=0,
+                                                max_value=len(SIZE_PRESETS) - 1, width=-1)
+
+                            dpg.add_text("Bounding Thickness")
+                            dpg.add_slider_int(tag="box_thk", default_value=2, min_value=1, max_value=20, width=-1)
+
+                            dpg.add_spacer(height=8)
+                            dpg.add_checkbox(label="Connection Lines", tag="connect", default_value=False)
+
+                            dpg.add_text("Nearest Neighbors")
+                            dpg.add_slider_int(tag="connect_neighbors", default_value=2, min_value=1, max_value=6, width=-1)
+
+                            dpg.add_text("Connection Line Thickness")
+                            dpg.add_slider_int(tag="line_thk", default_value=1, min_value=1, max_value=10, width=-1)
+
+                            dpg.add_text("Bounding Box Filter")
+                            self._make_button_group(FILTERS, "filter_sel", "filter_btn", columns=3)
+
+                            dpg.add_text("Font Size")
+                            dpg.add_slider_float(tag="font_size", default_value=0.5, min_value=0.2, max_value=1.5, width=-1)
+
+                            dpg.add_text("Bounding Box Color")
+                            self._color_button_group("boxclr_btn", "shape_color_sel")
+
+                            dpg.add_text("Connection Line Color")
+                            self._color_button_group("lineclr_btn", "line_color_sel")
+
+                            dpg.add_spacer(height=8)
+                            dpg.add_text("Playback Speed")
+                            self._make_button_group([label for label, _ in SPEED_PRESETS],
+                                                     "playback_speed_sel", "speed_btn", columns=4)
+
+                            dpg.add_spacer(height=8)
+                            dpg.add_text("Live Resolution")
+                            self._make_button_group([label for label, _ in RESOLUTION_PRESETS],
+                                                     "res_scale_sel", "res_btn", columns=4)
+
+                            dpg.add_spacer(height=15)
+                            dpg.add_progress_bar(tag="progress_bar", default_value=0.0, width=-1)
+                            dpg.add_text("", tag="progress_text")
+
+                            dpg.add_spacer(height=10)
+                            dpg.add_text("Export")
+                            dpg.add_button(label="Record", tag="record_btn", width=-1, callback=lambda: self.toggle_record())
+
+                            dpg.add_spacer(height=20)
+                            dpg.add_text("@rileriaaa", color=(120, 120, 120, 255))
+
+
+                with dpg.theme() as panel_theme:
+                    with dpg.theme_component(dpg.mvChildWindow):
+                        dpg.add_theme_style(dpg.mvStyleVar_WindowPadding, 0, 0)
+                        dpg.add_theme_style(dpg.mvStyleVar_ChildBorderSize, 0)
+
+                with dpg.child_window(tag="video_panel", border=False, no_scrollbar=True):
+                    dpg.add_image(VIDEO_TEXTURE_TAG, tag=VIDEO_IMAGE_TAG,
+                                  width=self.disp_w, height=self.disp_h)
+                    dpg.add_text("Load a video to begin", tag="placeholder_text",
+                  color=(150, 150, 150, 255), show=(self.cap is None))
+
+                    with dpg.group(horizontal=True, horizontal_spacing=10, pos=[15, 15]):
+                        dpg.add_button(label="Load", tag="icon_load", width=40, height=40,
+                                        callback=lambda: dpg.show_item("file_dialog"))
+                        dpg.add_button(label="Pause", tag="pause_btn", width=40, height=40,
+                                        callback=lambda: self.toggle_pause())
+                        dpg.add_button(label="Full", tag="icon_fullscreen", width=40, height=40,
+                                        callback=lambda: self.toggle_fullscreen())
+                dpg.bind_item_theme("video_panel", panel_theme)
+
+                with dpg.theme() as icon_theme:
+                    with dpg.theme_component(dpg.mvButton):
+                        dpg.add_theme_color(dpg.mvThemeCol_Button, (20, 20, 20, 180))
+                        dpg.add_theme_color(dpg.mvThemeCol_ButtonHovered, (60, 60, 60, 200))
+                        dpg.add_theme_color(dpg.mvThemeCol_Border, (255, 255, 255, 200))
+                        dpg.add_theme_style(dpg.mvStyleVar_FrameRounding, 20)
+                        dpg.add_theme_style(dpg.mvStyleVar_FrameBorderSize, 1)
+                for tag in ("icon_load", "pause_btn", "icon_fullscreen"):
+                    dpg.bind_item_theme(tag, icon_theme)
+
+        viewport_w = SIDEBAR_WIDTH + self.disp_w + 100
+        viewport_h = max(self.disp_h + 140, 800)
+        dpg.create_viewport(title="BlobTrack", width=viewport_w, height=viewport_h)
+        dpg.setup_dearpygui()
+        dpg.show_viewport()
+        dpg.set_primary_window("main_window", True)
+        dpg.set_viewport_resize_callback(lambda s, a: self.resize_video_display())
+
+        while dpg.is_dearpygui_running():
+            self.resize_video_display()
+            self.update()
+            dpg.render_dearpygui_frame()
+
+        self._stop_recording()
+        if self.cap:
+            self.cap.release()
+        dpg.destroy_context()
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="blobtrack")
+    parser.add_argument("--source", default=None,
+                         help="Video path or camera index (optional — omit to start empty and use Load Video)")
+    args = parser.parse_args()
+    if args.source is None:
+        src = None
+    else:
+        src = int(args.source) if args.source.isdigit() else args.source
+
+    app = BlobTrackerApp(src)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

blobtrack-0.1.2.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: blobtrack
+Version: 0.1.2
+Summary: Real-time motion blob tracker with a Dear PyGui interface
+Project-URL: Homepage, https://rilerialabs.onrender.com/
+Project-URL: Repository, https://github.com/rileriaaa/blobtrack
+Author: rileriaaa
+License: MIT
+Keywords: computer-vision,dearpygui,motion-tracking,opencv
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.8
+Requires-Dist: dearpygui>=1.10
+Requires-Dist: numpy>=1.20
+Requires-Dist: opencv-python>=4.5
+Description-Content-Type: text/markdown
+
+# BlobTrack
+
+A real-time motion blob tracker built with Dear PyGui and OpenCV. Load any video file (or a live camera feed), and BlobTrack detects moving objects via background subtraction, then overlays customizable bounding shapes, labels, and network-style connection lines between detected blobs.
+
+![Python](https://img.shields.io/badge/python-3.8+-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+## Features
+
+- **Live motion detection** using MOG2 background subtraction
+- **Customizable overlays** — square/circle/no outline, adjustable size, thickness, and color per blob
+- **Bounding box filters** — apply Invert, Blur, Pixelate, Thermal, or Edge effects inside each detected region
+- **Mesh connection lines** — link each blob to its *k* nearest neighbors with distance-based fade, for a network/web visualization
+- **Adjustable playback speed** (1x–2x) for file sources
+- **Live Resolution scaling** (Native/75%/50%/25%) to trade preview quality for performance without affecting export quality
+- **Video export/recording** — save the processed feed (with all overlays) to `.mp4`, always at full native resolution regardless of preview settings
+- **Fullscreen toggle** and a responsive video panel that resizes cleanly with the window
+
+## Installation
+
+Install as an isolated CLI tool with [pipx](https://pypa.github.io/pipx/) (recommended):
+
+```bash
+pipx install blobtrack
+```
+
+Or with pip into your own environment:
+
+```bash
+pip install blobtrack
+```
+
+## Usage
+
+Run with no arguments and use the **Load** button to pick a video file:
+
+```bash
+blobtrack
+```
+
+Or pass a video path or camera index directly:
+
+```bash
+blobtrack --source path/to/video.mp4
+blobtrack --source 0   # webcam
+```
+
+## Controls
+
+| Control | Description |
+|---|---|
+| **Minimum Area** | Filters out blobs smaller than this pixel area |
+| **Max Blobs** | Caps how many blobs are tracked per frame |
+| **Shape** | Bounding shape drawn around each blob (Square / Circle / None) |
+| **Bounding Size / Thickness** | Size and stroke width of the bounding shape |
+| **Connection Lines** | Toggles mesh-style lines between nearby blobs |
+| **Nearest Neighbors** | How many neighbors each blob connects to |
+| **Bounding Box Filter** | Visual effect applied inside each bounding box |
+| **Font Size** | Size of the confidence-score label per blob |
+| **Bounding Box / Connection Line Color** | Preset colors or a custom color picker |
+| **Playback Speed** | Preview and export playback rate (locked during recording) |
+| **Live Resolution** | Preview processing resolution (export always stays native) |
+| **Record** | Opens a save dialog to choose where to export the processed feed, then starts/stops recording |
+
+Floating buttons on the video panel: **Load** (open a file), **Pause/Play**, **Full** (fullscreen toggle).
+
+## How it works
+
+Each frame runs through OpenCV's `BackgroundSubtractorMOG2` to isolate moving regions, followed by thresholding, morphological opening, and dilation to clean up the mask. Contours are extracted, filtered by minimum area, and the largest N are kept as tracked blobs. Overlays are drawn directly onto the frame before it's uploaded to a Dear PyGui dynamic texture for display — and, if recording, written to disk via `cv2.VideoWriter` at full native resolution independent of what's shown in the live preview.
+
+## Notes
+
+- Recording locks the Playback Speed selector since the export FPS is fixed at recording start.
+- Reaching the end of a file loop automatically stops any active recording and restarts playback from frame 0.
+
+---
+
+Built by [@rileriaaa](https://github.com/rileriaaa)

blobtrack-0.1.2.dist-info/RECORD

@@ -0,0 +1,6 @@
+blobtrack/__init__.py,sha256=Pru0BlFBASFCFo7McHdohtKkUtgMPDwbGfyUZlE2_Vw,21
+blobtrack/app.py,sha256=Fe-8pw_o02D4klccya3gA23N6Ua6fM3zV_lvGUk9Lmw,30370
+blobtrack-0.1.2.dist-info/METADATA,sha256=_uNnMqmJtg-abNBvrvrb3HdLFx01Y3F9YoaUSH6BBZg,4301
+blobtrack-0.1.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+blobtrack-0.1.2.dist-info/entry_points.txt,sha256=6y8uyN5cMl936R-Sdc1rh0pmlPeXKfx731X7yumnDiY,49
+blobtrack-0.1.2.dist-info/RECORD,,

blobtrack-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

blobtrack-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+blobtrack = blobtrack.app:main