alphadeep-capture 0.1.0__py3-none-any.whl

alphadeep_capture/camera.py

@@ -0,0 +1,60 @@
+import cv2
+import threading
+import time
+import numpy as np
+
+class CameraStream:
+    def __init__(self, cam_id, name):
+        self.cam_id = cam_id
+        self.name = name
+        self.cap = cv2.VideoCapture(cam_id)
+        # Attempt to set v4l2 backend if on linux, but default works too.
+        self.frame = None
+        self.running = True
+        self.lock = threading.Lock()
+        
+        self.thread = threading.Thread(target=self._update, daemon=True)
+        self.thread.start()
+
+    def _update(self):
+        while self.running:
+            if self.cap.isOpened():
+                ret, frame = self.cap.read()
+                if ret:
+                    # Convert BGR to RGB for PyGame
+                    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    with self.lock:
+                        self.frame = frame_rgb
+                else:
+                    time.sleep(0.1)
+            else:
+                time.sleep(0.1)
+
+    def get_frame(self):
+        with self.lock:
+            if self.frame is not None:
+                return self.frame.copy()
+            return None
+
+    def release(self):
+        self.running = False
+        self.thread.join(timeout=1.0)
+        if self.cap.isOpened():
+            self.cap.release()
+
+class CameraManager:
+    def __init__(self, config_cameras):
+        self.streams = []
+        for cam in config_cameras:
+            # Only up to 4 cameras
+            if len(self.streams) >= 4:
+                break
+            stream = CameraStream(cam['id'], cam.get('name', f"Camera {cam['id']}"))
+            self.streams.append(stream)
+
+    def get_frames(self):
+        return [stream.get_frame() for stream in self.streams]
+
+    def release(self):
+        for stream in self.streams:
+            stream.release()

alphadeep_capture/config.py

@@ -0,0 +1,54 @@
+import os
+import yaml
+from pathlib import Path
+
+DEFAULT_CONFIG = {
+    "cameras": [
+        {"id": 0, "name": "Camera 1"},
+        {"id": 1, "name": "Camera 2"},
+        {"id": 2, "name": "Camera 3"},
+        {"id": 3, "name": "Camera 4"}
+    ],
+    "fps": 30,
+    "samples_dir": str(Path.home() / "alphadeep_samples"),
+    "alphadeep_session": "",
+    "alphadeep_adapter": "zero_adapter",
+    "alphadeep_task": "",
+    "alphadeep_api_key": "",
+    "alphadeep_classes": [],
+    "alphadeep_workers": 4,
+    "autocapture": {
+        "length": 2.0,
+        "period": 0.5
+    },
+    "debug": False
+}
+
+def get_config_path() -> Path:
+    xdg_config_home = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
+    config_dir = Path(xdg_config_home) / "alphadeep" / "capture"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir / "config.yaml"
+
+def load_config() -> dict:
+    config_path = get_config_path()
+    if config_path.exists():
+        with open(config_path, "r") as f:
+            try:
+                user_config = yaml.safe_load(f)
+                if user_config:
+                    # Merge with default config
+                    merged = DEFAULT_CONFIG.copy()
+                    merged.update(user_config)
+                    return merged
+            except yaml.YAMLError as e:
+                print(f"Error loading config: {e}")
+                
+    # If not exists or error, save and return default
+    save_config(DEFAULT_CONFIG)
+    return DEFAULT_CONFIG.copy()
+
+def save_config(config: dict):
+    config_path = get_config_path()
+    with open(config_path, "w") as f:
+        yaml.safe_dump(config, f)

alphadeep_capture/main.py

@@ -0,0 +1,520 @@
+import os
+import time
+import datetime
+import base64
+from pathlib import Path
+import pygame
+import cv2
+import numpy as np
+
+import threading
+import requests
+import concurrent.futures
+
+from .config import load_config, save_config
+from .camera import CameraManager
+from .ui import Button, ConfirmDialog, CommentDialog, DetectionDialog, MessageDialog
+
+# Colors
+BG_COLOR = (30, 30, 30)
+PANEL_COLOR = (45, 45, 45)
+TEXT_COLOR = (240, 240, 240)
+BTN_BG = (60, 60, 60)
+BTN_HOVER = (90, 90, 90)
+BTN_ACTIVE = (0, 120, 215)
+ACCENT_COLOR = (138, 43, 226) # Purple-ish
+
+def draw_gradient_text(surface, text, font, rect, color1, color2):
+    # Simple gradient approach
+    text_surf = font.render(text, True, (255, 255, 255))
+    gradient = pygame.Surface(text_surf.get_size())
+    w = gradient.get_width()
+    if w == 0:
+        return
+    for x in range(w):
+        c = (
+            int(color1[0] + (color2[0] - color1[0]) * x / w),
+            int(color1[1] + (color2[1] - color1[1]) * x / w),
+            int(color1[2] + (color2[2] - color1[2]) * x / w),
+        )
+        pygame.draw.line(gradient, c, (x, 0), (x, gradient.get_height()))
+    text_surf.blit(gradient, (0, 0), special_flags=pygame.BLEND_RGB_MULT)
+    surface.blit(text_surf, rect)
+
+
+class AlphaDeepCaptureApp:
+    def __init__(self):
+        pygame.init()
+        self.config = load_config()
+        
+        self.screen_width = 1600
+        self.screen_height = 1000
+        self.screen = pygame.display.set_mode(
+            (self.screen_width, self.screen_height), 
+            pygame.RESIZABLE)
+        pygame.display.set_caption("AlphaDeep Capture")
+        
+        self.clock = pygame.time.Clock()
+        self.fps = self.config.get("fps", 30)
+        
+        self.cam_manager = CameraManager(self.config.get("cameras", []))
+        
+        self.font_large = pygame.font.SysFont("Inter, Roboto, Arial", 42, bold=True)
+        self.font_medium = pygame.font.SysFont("Inter, Roboto, Arial", 31)
+        self.font_small = pygame.font.SysFont("Inter, Roboto, Arial", 21)
+        
+        self.current_sample_dir = None
+        self.image_count = 0
+        
+        self.auto_capture_active = False
+        self.auto_capture_end_time = 0
+        self.last_auto_capture_time = 0
+        self.auto_capture_period = 0
+        
+        self.active_dialog = None
+        
+        self.logo_img = None
+        self.pending_detections = None
+        self.pending_message = None
+        
+        for path in [Path("logo.png"), Path(__file__).parent / "logo.png"]:
+            if path.exists():
+                try:
+                    self.logo_img = pygame.image.load(str(path)).convert_alpha()
+                    pygame.display.set_icon(self.logo_img)
+                    break
+                except Exception as e:
+                    print(f"Failed to load logo: {e}")
+                    
+        self.buttons = {}
+        self.create_buttons()
+        
+    def create_buttons(self):
+        self.buttons['new_sample'] = Button(0, 0, 10, 10, "New Sample", self.font_medium, BTN_BG, TEXT_COLOR, BTN_HOVER)
+        self.buttons['capture'] = Button(0, 0, 10, 10, "Capture", self.font_medium, BTN_BG, TEXT_COLOR, BTN_HOVER)
+        self.buttons['auto_capture'] = Button(0, 0, 10, 10, "Auto Capture", self.font_medium, BTN_BG, TEXT_COLOR, BTN_ACTIVE)
+        self.buttons['preview'] = Button(0, 0, 10, 10, "Preview Sample", self.font_medium, BTN_BG, TEXT_COLOR, BTN_HOVER)
+        self.buttons['analyze'] = Button(0, 0, 10, 10, "Analyze", self.font_medium, BTN_BG, TEXT_COLOR, BTN_HOVER)
+        self.buttons['comment'] = Button(0, 0, 10, 10, "Comment", self.font_medium, BTN_BG, TEXT_COLOR, BTN_HOVER)
+
+    def layout_buttons(self, panel_rect, start_y):
+        padding = 20
+        btn_width = panel_rect.width - padding * 2
+        btn_height = 60
+        
+        order = ['new_sample', 'capture', 'auto_capture', 'preview', 'analyze', 'comment']
+        for i, key in enumerate(order):
+            y = start_y + i * (btn_height + 15)
+            self.buttons[key].rect = pygame.Rect(panel_rect.x + padding, y, btn_width, btn_height)
+
+    def handle_events(self):
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                return False
+            elif event.type == pygame.VIDEORESIZE:
+                self.screen_width = event.w
+                self.screen_height = event.h
+            elif event.type == pygame.KEYDOWN:
+                if (event.key == pygame.K_f or event.key == pygame.K_F11) and not self.active_dialog:
+                    pygame.display.toggle_fullscreen()
+            
+            if self.active_dialog:
+                self.active_dialog.handle_event(event)
+                if self.active_dialog.resolved:
+                    self.handle_dialog_result(self.active_dialog)
+                    self.active_dialog = None
+                continue
+            
+            # Check for pending detections from thread
+            if self.pending_detections is not None:
+                if self.pending_detections:
+                    self.active_dialog = DetectionDialog(
+                        int(self.screen_width * 0.8), int(self.screen_height * 0.8),
+                        self.pending_detections, self.font_medium, self.font_small,
+                        title_prefix="Detection Results"
+                    )
+                    self.active_dialog.type = 'detection'
+                self.pending_detections = None
+                continue
+                
+            if self.pending_message is not None:
+                title, msg = self.pending_message
+                self.active_dialog = MessageDialog(
+                    500, 150, title, msg, self.font_medium, self.font_small
+                )
+                self.active_dialog.type = 'message'
+                self.pending_message = None
+                continue
+            
+            for key, btn in self.buttons.items():
+                if btn.handle_event(event):
+                    self.on_button_click(key)
+        
+        if not self.active_dialog:
+            mouse_pos = pygame.mouse.get_pos()
+            for btn in self.buttons.values():
+                btn.update(mouse_pos)
+            
+        return True
+
+    def on_button_click(self, key):
+        if key == 'new_sample':
+            self.new_sample()
+        elif key == 'capture':
+            self.capture_sample()
+        elif key == 'auto_capture':
+            self.start_auto_capture()
+        elif key == 'preview':
+            self.preview_sample()
+        elif key == 'analyze':
+            self.analyze()
+        elif key == 'comment':
+            self.add_comment()
+
+    def handle_dialog_result(self, dialog):
+        if dialog.type == 'comment':
+            if dialog.result is not None:
+                with open(self.current_sample_dir / "comment.txt", "w") as f:
+                    f.write(dialog.result + "\n")
+
+    def get_base_dir(self):
+        d = Path(self.config.get("samples_dir", str(Path.home() / "alphadeep_samples")))
+        d.mkdir(parents=True, exist_ok=True)
+        return d
+
+    def new_sample(self):
+        base = self.get_base_dir()
+        ts = datetime.datetime.now().isoformat().replace(':', '-')
+        self.current_sample_dir = base / f"sample_{ts}"
+        self.current_sample_dir.mkdir(parents=True, exist_ok=True)
+        self.image_count = 0
+        print(f"Created new sample at {self.current_sample_dir}")
+
+    def capture_sample(self):
+        if not self.current_sample_dir:
+            self.new_sample()
+            
+        frames = self.cam_manager.get_frames()
+        captured = 0
+        now_str = datetime.datetime.now().isoformat().replace(":", "-")
+        for i, frame in enumerate(frames):
+            if frame is not None:
+                # frame is RGB, cv2 needs BGR for saving
+                frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+                filepath = self.current_sample_dir / f"cam{i}_{now_str}.jpg"
+                cv2.imwrite(str(filepath), frame_bgr)
+                captured += 1
+                
+        self.image_count += captured
+        print(f"Captured {captured} frames.")
+
+    def start_auto_capture(self):
+        if not self.current_sample_dir:
+            print("No active sample. Please create a new sample first.")
+            return
+            
+        ac_config = self.config.get("autocapture", {})
+        length = float(ac_config.get("length", 2.0))
+        self.auto_capture_period = float(ac_config.get("period", 0.5))
+        
+        self.auto_capture_end_time = time.time() + length
+        self.last_auto_capture_time = 0 # Force immediate first capture
+        self.auto_capture_active = True
+        
+        self.buttons['capture'].is_disabled = True
+        self.buttons['auto_capture'].is_disabled = True
+
+    def preview_sample(self):
+        if not self.current_sample_dir:
+            print("No active sample to preview.")
+            return
+            
+        image_paths = [str(p) for p in self.current_sample_dir.glob("*.jpg")]
+        if not image_paths:
+            print("No images found in current sample.")
+            return
+            
+        detections = []
+        for p in image_paths:
+            img = cv2.imread(p)
+            if img is not None:
+                img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                surf = pygame.surfarray.make_surface(np.rot90(img_rgb))
+                surf = pygame.transform.flip(surf, True, False)
+                detections.append((surf, []))
+                
+        if detections:
+            self.active_dialog = DetectionDialog(
+                int(self.screen_width * 0.8), int(self.screen_height * 0.8),
+                detections, self.font_medium, self.font_small, title_prefix="Preview"
+            )
+            self.active_dialog.type = 'preview'
+
+    def analyze(self):
+        if self.buttons['analyze'].is_disabled:
+            return
+            
+        if not self.current_sample_dir:
+            print("No sample to analyze.")
+            return
+            
+        image_paths = [str(p) for p in self.current_sample_dir.glob("*.jpg")]
+        if not image_paths:
+            print("No images found in current sample.")
+            return
+            
+        self.buttons['analyze'].text = "Please wait..."
+        self.buttons['analyze'].is_disabled = True
+            
+        print(f"Starting analysis of {len(image_paths)} images...")
+        t = threading.Thread(target=self._analyze_thread_func, args=(image_paths,), daemon=True)
+        t.start()
+        
+    def _analyze_thread_func(self, image_paths):
+        try:
+            session = self.config.get("alphadeep_session", "")
+            adapter = self.config.get("alphadeep_adapter", "zero_adapter")
+            task = self.config.get("alphadeep_task", "")
+            api_key = self.config.get("alphadeep_api_key", "")
+            classes = self.config.get("alphadeep_classes", [])
+            workers = self.config.get("alphadeep_workers", 4)
+            debug = self.config.get("debug", False)
+            
+            if not session or not task or not api_key:
+                print("API configuration missing. Please set alphadeep_session, alphadeep_task, and alphadeep_api_key in config.yaml.")
+                return
+                
+            if debug:
+                print(f"[DEBUG] Analyze triggered for {len(image_paths)} images.")
+                print(f"[DEBUG] Session: {session}, Task: {task}, Classes: {classes}")
+            
+            url = f"https://agent.alphadeep.ai/api/v1/serve/{session}/{adapter}?task={task}"
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            def process_image(p):
+                img = cv2.imread(p)
+                if img is None:
+                    return None
+                    
+                img_resized = cv2.resize(img, (448, 448))
+                _, buffer = cv2.imencode('.jpg', img_resized)
+                b64 = base64.b64encode(buffer).decode('utf-8')
+                
+                payload = {
+                    "image": b64,
+                    "classes": classes
+                }
+                
+                try:
+                    resp = requests.post(url, json=payload, headers=headers, timeout=5)
+                    
+                    if debug:
+                        print(f"[DEBUG] API Response for {p}: Status {resp.status_code}")
+                        print(f"[DEBUG] Body: {resp.text}")
+                        
+                    if resp.status_code == 200:
+                        data = resp.json()
+                        
+                        if isinstance(data, list) and len(data) > 0:
+                            result_dict = data[0]
+                        elif isinstance(data, dict):
+                            result_dict = data
+                        else:
+                            result_dict = {}
+                            
+                        objects = result_dict.get("objects", [])
+                        if objects:
+                            img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                            surf = pygame.surfarray.make_surface(np.rot90(img_rgb))
+                            surf = pygame.transform.flip(surf, True, False)
+                            return (surf, objects)
+                    elif resp.status_code == 429:
+                        return 429
+                    else:
+                        print(f"API returned non-200 status code: {resp.status_code} for {p}")
+                except Exception as e:
+                    print(f"API Error for {p}: {e}")
+                return None
+
+            detections = []
+            hit_limit = False
+            
+            # Avoid ValueError by ensuring max_workers > 0
+            max_workers = max(1, min(workers, len(image_paths)))
+            
+            with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+                # executor.map maintains the original order of image_paths
+                results = executor.map(process_image, image_paths)
+                for res in results:
+                    if res == 429:
+                        hit_limit = True
+                    elif res is not None:
+                        detections.append(res)
+                        
+            if hit_limit:
+                self.pending_message = ("Limit Reached", "Alphadeep token limit reached.")
+                return
+
+            self.pending_detections = detections
+        finally:
+            self.buttons['analyze'].text = "Analyze"
+            self.buttons['analyze'].is_disabled = False
+
+    def add_comment(self):
+        if not self.current_sample_dir:
+            print("No active sample.")
+            return
+            
+        initial_text = ""
+        comment_file = self.current_sample_dir / "comment.txt"
+        if comment_file.exists():
+            with open(comment_file, "r") as f:
+                initial_text = f.read().strip()
+                
+        self.active_dialog = CommentDialog(
+            500, 200, "Comment", initial_text,
+            self.font_medium, self.font_small
+        )
+        self.active_dialog.type = 'comment'
+
+    def draw(self):
+        self.screen.fill(BG_COLOR)
+        
+        # 80/20 Split
+        left_width = int(self.screen_width * 0.8)
+        right_width = self.screen_width - left_width
+        
+        # Draw Camera Grid
+        self.draw_camera_grid(pygame.Rect(0, 0, left_width, self.screen_height))
+        
+        # Draw Right Panel
+        panel_rect = pygame.Rect(left_width, 0, right_width, self.screen_height)
+        pygame.draw.rect(self.screen, PANEL_COLOR, panel_rect)
+        
+        # Draw Logo and Text
+        start_y = 20
+        if self.logo_img:
+            max_w = right_width - 40
+            img_w, img_h = self.logo_img.get_size()
+            if img_w > max_w:
+                scale = max_w / img_w
+                img_w = int(img_w * scale)
+                img_h = int(img_h * scale)
+                scaled_logo = pygame.transform.smoothscale(self.logo_img, (img_w, img_h))
+            else:
+                scaled_logo = self.logo_img
+                
+            logo_x = left_width + (right_width - img_w) // 2
+            self.screen.blit(scaled_logo, (logo_x, start_y))
+            start_y += img_h + 10
+        else:
+            logo_rect = pygame.Rect(left_width + 20, start_y, right_width - 40, 50)
+            draw_gradient_text(self.screen, "AlphaDeep", self.font_large, logo_rect, (0, 191, 255), ACCENT_COLOR)
+            start_y += 60
+            
+        # Draw Subtitles
+        text1 = self.font_medium.render("AlphaDeep Capture", True, (255, 255, 255))
+        text2 = self.font_small.render("For Internal Use only", True, (200, 200, 200))
+        text3 = self.font_small.render("AlphaDeep Inc. DE, USA", True, (150, 150, 150))
+        
+        self.screen.blit(text1, (left_width + (right_width - text1.get_width()) // 2, start_y))
+        start_y += text1.get_height() + 5
+        self.screen.blit(text2, (left_width + (right_width - text2.get_width()) // 2, start_y))
+        start_y += text2.get_height() + 5
+        self.screen.blit(text3, (left_width + (right_width - text3.get_width()) // 2, start_y))
+        start_y += text3.get_height() + 20
+        
+        # Layout and draw buttons
+        self.layout_buttons(panel_rect, start_y)
+        for btn in self.buttons.values():
+            btn.draw(self.screen)
+            
+        # Status Text
+        status_y = self.buttons['comment'].rect.bottom + 30
+        if self.current_sample_dir:
+            path_str = self.current_sample_dir.name
+            info_str = f"{path_str} ({self.image_count} imgs)"
+        else:
+            info_str = "No active sample"
+            
+        text_surf = self.font_small.render(info_str, True, (200, 200, 200))
+        if text_surf.get_width() > right_width - 40:
+            text_surf = pygame.transform.smoothscale(text_surf, (right_width - 40, text_surf.get_height()))
+        self.screen.blit(text_surf, (left_width + 20, status_y))
+
+        if self.active_dialog:
+            self.active_dialog.draw(self.screen)
+
+        pygame.display.flip()
+
+    def draw_camera_grid(self, rect):
+        frames = self.cam_manager.get_frames()
+        num_cams = len(frames)
+        if num_cams == 0:
+            return
+            
+        # 2x2 grid
+        cell_w = rect.width // 2
+        cell_h = rect.height // 2
+        
+        positions = [
+            (rect.x, rect.y),
+            (rect.x + cell_w, rect.y),
+            (rect.x, rect.y + cell_h),
+            (rect.x + cell_w, rect.y + cell_h)
+        ]
+        
+        for i, frame in enumerate(frames):
+            if i >= 4:
+                break
+            if frame is not None:
+                # Transpose and flip for Pygame
+                surf = pygame.surfarray.make_surface(np.rot90(frame))
+                surf = pygame.transform.flip(surf, True, False)
+                surf = pygame.transform.scale(surf, (cell_w - 4, cell_h - 4))
+                self.screen.blit(surf, (positions[i][0] + 2, positions[i][1] + 2))
+                
+                # Draw label
+                label = self.font_small.render(self.cam_manager.streams[i].name, True, (255, 255, 255))
+                self.screen.blit(label, (positions[i][0] + 10, positions[i][1] + 10))
+            else:
+                # Draw placeholder if no frame
+                pygame.draw.rect(self.screen, (20, 20, 20), (positions[i][0]+2, positions[i][1]+2, cell_w-4, cell_h-4))
+                label = self.font_small.render(f"Waiting for {self.cam_manager.streams[i].name}...", True, (150, 150, 150))
+                self.screen.blit(label, (positions[i][0] + 10, positions[i][1] + 10))
+
+    def run(self):
+        running = True
+        while running:
+            running = self.handle_events()
+            
+            if self.auto_capture_active:
+                now = time.time()
+                remaining = max(0.0, self.auto_capture_end_time - now)
+                
+                if remaining > 0:
+                    self.buttons['auto_capture'].text = f"Capturing... {remaining:.1f}s"
+                    if now - self.last_auto_capture_time >= self.auto_capture_period:
+                        self.capture_sample()
+                        self.last_auto_capture_time = now
+                else:
+                    self.auto_capture_active = False
+                    self.buttons['auto_capture'].text = "Auto Capture"
+                    self.buttons['capture'].is_disabled = False
+                    self.buttons['auto_capture'].is_disabled = False
+            
+            self.draw()
+            self.clock.tick(self.fps)
+            
+        self.cam_manager.release()
+        pygame.quit()
+
+def main():
+    app = AlphaDeepCaptureApp()
+    app.run()
+
+if __name__ == "__main__":
+    main()

alphadeep_capture/ui.py

@@ -0,0 +1,289 @@
+import pygame
+
+
+class Button:
+    def __init__(self, x, y, width, height, text, font, bg_color, text_color, hover_color=None):
+        self.rect = pygame.Rect(x, y, width, height)
+        self.text = text
+        self.font = font
+        self.bg_color = bg_color
+        self.text_color = text_color
+        self.hover_color = hover_color or bg_color
+        self.is_hovered = False
+        self.is_active = False # Used for toggles
+        self.is_disabled = False
+
+    def draw(self, surface):
+        if self.is_disabled:
+            color = (80, 80, 80)
+            text_color = (150, 150, 150)
+        else:
+            color = self.hover_color if (self.is_hovered or self.is_active) else self.bg_color
+            text_color = self.text_color
+            
+        pygame.draw.rect(surface, color, self.rect, border_radius=8)
+        
+        text_surf = self.font.render(self.text, True, text_color)
+        text_rect = text_surf.get_rect(center=self.rect.center)
+        surface.blit(text_surf, text_rect)
+
+    def update(self, mouse_pos):
+        if not self.is_disabled:
+            self.is_hovered = self.rect.collidepoint(mouse_pos)
+        else:
+            self.is_hovered = False
+
+    def handle_event(self, event):
+        if self.is_disabled:
+            return False
+        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+            if self.is_hovered:
+                return True
+        return False
+
+class ConfirmDialog:
+    def __init__(self, width, height, title, message, font_medium, font_small):
+        self.rect = pygame.Rect(0, 0, width, height)
+        self.title = title
+        self.message = message
+        self.font_medium = font_medium
+        self.font_small = font_small
+        
+        self.result = None
+        self.resolved = False
+        
+        self.yes_btn = Button(0, 0, 100, 40, "Yes", font_small, (60, 60, 60), (255, 255, 255), (90, 90, 90))
+        self.no_btn = Button(0, 0, 100, 40, "No", font_small, (60, 60, 60), (255, 255, 255), (90, 90, 90))
+        
+    def handle_event(self, event):
+        if self.yes_btn.handle_event(event):
+            self.result = True
+            self.resolved = True
+        elif self.no_btn.handle_event(event):
+            self.result = False
+            self.resolved = True
+            
+        mouse_pos = pygame.mouse.get_pos()
+        self.yes_btn.update(mouse_pos)
+        self.no_btn.update(mouse_pos)
+
+    def draw(self, surface):
+        self.rect.center = surface.get_rect().center
+        
+        overlay = pygame.Surface(surface.get_size(), pygame.SRCALPHA)
+        overlay.fill((0, 0, 0, 150))
+        surface.blit(overlay, (0, 0))
+        
+        pygame.draw.rect(surface, (45, 45, 45), self.rect, border_radius=10)
+        pygame.draw.rect(surface, (100, 100, 100), self.rect, width=2, border_radius=10)
+        
+        title_surf = self.font_medium.render(self.title, True, (255, 255, 255))
+        surface.blit(title_surf, (self.rect.x + 20, self.rect.y + 20))
+        
+        msg_surf = self.font_small.render(self.message, True, (200, 200, 200))
+        surface.blit(msg_surf, (self.rect.x + 20, self.rect.y + 60))
+        
+        self.yes_btn.rect.bottomright = (self.rect.centerx - 10, self.rect.bottom - 20)
+        self.no_btn.rect.bottomleft = (self.rect.centerx + 10, self.rect.bottom - 20)
+        
+        self.yes_btn.draw(surface)
+        self.no_btn.draw(surface)
+
+class CommentDialog:
+    def __init__(self, width, height, title, initial_text, font_medium, font_small):
+        self.rect = pygame.Rect(0, 0, width, height)
+        self.title = title
+        self.text = initial_text
+        self.font_medium = font_medium
+        self.font_small = font_small
+        
+        self.result = None
+        self.resolved = False
+        
+        self.ok_btn = Button(0, 0, 100, 40, "OK", font_small, (60, 60, 60), (255, 255, 255), (90, 90, 90))
+        self.cancel_btn = Button(0, 0, 100, 40, "Cancel", font_small, (60, 60, 60), (255, 255, 255), (90, 90, 90))
+        
+    def handle_event(self, event):
+        if event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_RETURN:
+                self.result = self.text
+                self.resolved = True
+            elif event.key == pygame.K_ESCAPE:
+                self.result = None
+                self.resolved = True
+            elif event.key == pygame.K_BACKSPACE:
+                self.text = self.text[:-1]
+            else:
+                self.text += event.unicode
+                
+        if self.ok_btn.handle_event(event):
+            self.result = self.text
+            self.resolved = True
+        elif self.cancel_btn.handle_event(event):
+            self.result = None
+            self.resolved = True
+            
+        mouse_pos = pygame.mouse.get_pos()
+        self.ok_btn.update(mouse_pos)
+        self.cancel_btn.update(mouse_pos)
+
+    def draw(self, surface):
+        self.rect.center = surface.get_rect().center
+        
+        overlay = pygame.Surface(surface.get_size(), pygame.SRCALPHA)
+        overlay.fill((0, 0, 0, 150))
+        surface.blit(overlay, (0, 0))
+        
+        pygame.draw.rect(surface, (45, 45, 45), self.rect, border_radius=10)
+        pygame.draw.rect(surface, (100, 100, 100), self.rect, width=2, border_radius=10)
+        
+        title_surf = self.font_medium.render(self.title, True, (255, 255, 255))
+        surface.blit(title_surf, (self.rect.x + 20, self.rect.y + 20))
+        
+        input_rect = pygame.Rect(self.rect.x + 20, self.rect.y + 70, self.rect.width - 40, 40)
+        pygame.draw.rect(surface, (30, 30, 30), input_rect, border_radius=5)
+        
+        # Blinking cursor simulation (simple)
+        cursor = "_" if (pygame.time.get_ticks() // 500) % 2 == 0 else ""
+        text_surf = self.font_small.render(self.text + cursor, True, (255, 255, 255))
+        
+        surface.set_clip(input_rect)
+        surface.blit(text_surf, (input_rect.x + 10, input_rect.y + 10))
+        surface.set_clip(None)
+        
+        self.ok_btn.rect.bottomright = (self.rect.centerx - 10, self.rect.bottom - 20)
+        self.cancel_btn.rect.bottomleft = (self.rect.centerx + 10, self.rect.bottom - 20)
+        
+        self.ok_btn.draw(surface)
+        self.cancel_btn.draw(surface)
+
+class MessageDialog:
+    def __init__(self, width, height, title, message, font_medium, font_small):
+        self.rect = pygame.Rect(0, 0, width, height)
+        self.title = title
+        self.message = message
+        self.font_medium = font_medium
+        self.font_small = font_small
+        
+        self.resolved = False
+        
+        self.ok_btn = Button(0, 0, 100, 40, "OK", font_small, (60, 60, 60), (255, 255, 255), (90, 90, 90))
+        
+    def handle_event(self, event):
+        if self.ok_btn.handle_event(event) or (event.type == pygame.KEYDOWN and (event.key == pygame.K_RETURN or event.key == pygame.K_ESCAPE)):
+            self.resolved = True
+            
+        mouse_pos = pygame.mouse.get_pos()
+        self.ok_btn.update(mouse_pos)
+
+    def draw(self, surface):
+        self.rect.center = surface.get_rect().center
+        
+        overlay = pygame.Surface(surface.get_size(), pygame.SRCALPHA)
+        overlay.fill((0, 0, 0, 150))
+        surface.blit(overlay, (0, 0))
+        
+        pygame.draw.rect(surface, (45, 45, 45), self.rect, border_radius=10)
+        pygame.draw.rect(surface, (100, 100, 100), self.rect, width=2, border_radius=10)
+        
+        title_surf = self.font_medium.render(self.title, True, (255, 255, 255))
+        surface.blit(title_surf, (self.rect.x + 20, self.rect.y + 20))
+        
+        msg_surf = self.font_small.render(self.message, True, (200, 200, 200))
+        surface.blit(msg_surf, (self.rect.x + 20, self.rect.y + 60))
+        
+        self.ok_btn.rect.centerx = self.rect.centerx
+        self.ok_btn.rect.bottom = self.rect.bottom - 20
+        self.ok_btn.draw(surface)
+
+class DetectionDialog:
+    def __init__(self, width, height, detections, font_medium, font_small, title_prefix="Detection Results"):
+        # detections is a list of tuples: (pygame_surface, list_of_objects)
+        self.rect = pygame.Rect(0, 0, width, height)
+        self.detections = detections
+        self.current_idx = 0
+        self.title_prefix = title_prefix
+        
+        self.font_medium = font_medium
+        self.font_small = font_small
+        self.resolved = False
+        
+        self.close_btn = Button(0, 0, 100, 40, "Close", font_small, (60, 60, 60), (255, 255, 255), (90, 90, 90))
+        self.next_btn = Button(0, 0, 100, 40, "Next", font_small, (0, 120, 215), (255, 255, 255), (0, 150, 255))
+        
+    def handle_event(self, event):
+        if self.close_btn.handle_event(event) or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE):
+            self.resolved = True
+            
+        if len(self.detections) > 1 and self.current_idx < len(self.detections) - 1:
+            if self.next_btn.handle_event(event) or (event.type == pygame.KEYDOWN and event.key == pygame.K_RIGHT):
+                self.current_idx += 1
+                
+        mouse_pos = pygame.mouse.get_pos()
+        self.close_btn.update(mouse_pos)
+        self.next_btn.update(mouse_pos)
+
+    def draw(self, surface):
+        self.rect.center = surface.get_rect().center
+        
+        overlay = pygame.Surface(surface.get_size(), pygame.SRCALPHA)
+        overlay.fill((0, 0, 0, 150))
+        surface.blit(overlay, (0, 0))
+        
+        pygame.draw.rect(surface, (45, 45, 45), self.rect, border_radius=10)
+        pygame.draw.rect(surface, (100, 100, 100), self.rect, width=2, border_radius=10)
+        
+        title_surf = self.font_medium.render(f"{self.title_prefix} ({self.current_idx + 1}/{max(1, len(self.detections))})", True, (255, 255, 255))
+        surface.blit(title_surf, (self.rect.x + 20, self.rect.y + 20))
+        
+        if not self.detections:
+            msg = self.font_medium.render("Nothing detected.", True, (200, 200, 200))
+            surface.blit(msg, (self.rect.centerx - msg.get_width()//2, self.rect.centery))
+        else:
+            img_surf, objects = self.detections[self.current_idx]
+            
+            img_rect = img_surf.get_rect()
+            max_img_h = self.rect.height - 150
+            max_img_w = self.rect.width - 40
+            scale = min(max_img_w / img_rect.width, max_img_h / img_rect.height)
+            
+            if scale < 1.0:
+                w, h = int(img_rect.width * scale), int(img_rect.height * scale)
+                display_surf = pygame.transform.smoothscale(img_surf, (w, h))
+            else:
+                display_surf = img_surf
+                w, h = img_rect.width, img_rect.height
+                
+            draw_x = self.rect.centerx - w // 2
+            draw_y = self.rect.centery - h // 2
+            
+            surface.blit(display_surf, (draw_x, draw_y))
+            
+            # Draw bounding boxes
+            for obj in objects:
+                rx1, ry1 = float(obj.get("x1", 0.0)), float(obj.get("y1", 0.0))
+                rx2, ry2 = float(obj.get("x2", 0.0)), float(obj.get("y2", 0.0))
+                
+                x = draw_x + int(rx1 * w)
+                y = draw_y + int(ry1 * h)
+                bw = int((rx2 - rx1) * w)
+                bh = int((ry2 - ry1) * h)
+                
+                box_rect = pygame.Rect(x, y, bw, bh)
+                pygame.draw.rect(surface, (0, 255, 0), box_rect, width=2)
+                
+                label_str = f"{obj.get('cls', '?')} {float(obj.get('confidence', 0.0)):.2f}"
+                lbl = self.font_small.render(label_str, True, (0, 0, 0), (0, 255, 0))
+                surface.blit(lbl, (x, max(draw_y, y - lbl.get_height())))
+        
+        has_next = len(self.detections) > 1 and self.current_idx < len(self.detections) - 1
+        
+        if has_next:
+            self.close_btn.rect.bottomright = (self.rect.centerx - 10, self.rect.bottom - 20)
+            self.next_btn.rect.bottomleft = (self.rect.centerx + 10, self.rect.bottom - 20)
+            self.next_btn.draw(surface)
+        else:
+            self.close_btn.rect.centerx = self.rect.centerx
+            self.close_btn.rect.bottom = self.rect.bottom - 20
+            
+        self.close_btn.draw(surface)

alphadeep_capture-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: alphadeep-capture
+Version: 0.1.0
+Summary: AlphaDeep Live Capture Tool
+Author-email: "AlphaDeep Inc." <nmilosev@alphadeep.ai>
+License: Apache 2.0
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: opencv-python>=4.8.0
+Requires-Dist: pygame>=2.5.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: requests>=2.31.0
+Description-Content-Type: text/markdown
+
+# AlphaDeep Capture
+
+AlphaDeep Capture is a high-performance Python/Pygame application designed for live streaming, data capture, and realtime cloud-inference using the AlphaDeep AI platform.
+
+## Installation
+
+This project is built using modern Python tooling and can be installed locally via `pip` or `uv`:
+
+```bash
+git clone <repository_url>
+cd alphadeep-capture
+
+# Install the application and all dependencies
+uv pip install -e .
+```
+
+## Configuration
+
+AlphaDeep Capture uses a YAML configuration file stored in your user configuration directory (following the XDG Base Directory standard). 
+
+**Configuration Path**: `~/.config/alphadeep/capture/config.yaml`
+
+If this file does not exist when the app is first launched, a default configuration will be automatically generated. 
+
+### Example `config.yaml`
+```yaml
+cameras:
+  - id: 0
+    name: Camera 1
+  - id: 1
+    name: Camera 2
+
+fps: 30
+samples_dir: ~/alphadeep_samples
+
+# AlphaDeep API Configuration
+alphadeep_session: "your_session_id"
+alphadeep_adapter: "zero_adapter"
+alphadeep_task: "detection"
+alphadeep_api_key: "your_api_key_here"
+alphadeep_classes: 
+  - "car"
+  - "person"
+alphadeep_workers: 4
+
+# Enable verbose console output for debugging API responses
+debug: true
+```
+
+### Adding Your API Key
+In order to use the **Analyze** functionality, you must edit your `config.yaml` and provide your `alphadeep_api_key`, `alphadeep_session`, and `alphadeep_task`.
+
+## Running the Application
+
+Once installed, you can launch the application directly from your terminal:
+
+```bash
+alphadeep-capture
+```
+
+## Features and Controls
+
+* **New Sample**: Creates a fresh timestamped directory in your `samples_dir` for saving data.
+* **Capture**: Instantly grabs the current frame from all active cameras and saves them as `.jpg` files in the current sample directory.
+* **Preview Sample**: Opens an interactive gallery overlay to view all images captured in the current sample.
+* **Analyze**: Sends the currently captured sample to the AlphaDeep API for remote inference and overlays the bounding box results in the UI.
+* **Comment**: Opens a dialog to attach text notes to the current sample (saved as `comment.txt`).
+* **Sync (Cloud)**: Placeholder feature for synchronizing samples with AlphaDeep cloud storage.

alphadeep_capture-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+alphadeep_capture/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+alphadeep_capture/camera.py,sha256=13C0UHiCrxpTYk1HnHF81k1CpxYEskQIR9RdIw_Cg9s,1793
+alphadeep_capture/config.py,sha256=kbZ93lPUmaHWcJR2L4aVHBrKAsAmCiNkmQK3_2ZsLQ4,1647
+alphadeep_capture/main.py,sha256=OIMqK746UPgfeS0IjINjAixQAx2yXa3QJ5xsPsal3v8,20932
+alphadeep_capture/ui.py,sha256=Gb2iBVAYoNY7k2l48gjGb4pbNy0kDT6E88I7GmZuO-s,12230
+alphadeep_capture-0.1.0.dist-info/METADATA,sha256=8HJ16V_6VroMUTAbSvZTu3wLOIF5tIVWy0ZhTEusFBs,2653
+alphadeep_capture-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+alphadeep_capture-0.1.0.dist-info/entry_points.txt,sha256=sPy98dmyzMO2zau25HiOppzaTJZ2a4k5ADWGPuHx4hQ,66
+alphadeep_capture-0.1.0.dist-info/RECORD,,

alphadeep_capture-0.1.0.dist-info/WHEEL

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

alphadeep_capture-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+alphadeep-capture = alphadeep_capture.main:main