Remove contributing and license sections from README

Removed contributing guidelines and license section from README.

.gitignore

@@ -35,6 +35,7 @@ env/
 #  Usually these files are written by a python script from a template
 #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 *.manifest
+*.spec
 
 # Installer logs
 pip-log.txt
@@ -93,12 +94,3 @@ celerybeat-schedule
 # Windows
 Thumbs.db
 
-# Kneron firmware/models and large artifacts
-*.nef
-fw_*.bin
-*.zip
-*.7z
-*.tar
-*.tar.gz
-*.tgz
-*.mflow

AGENTS.md

@@ -1,54 +0,0 @@
-# Repository Guidelines
-
-## Project Structure & Module Organization
-- `main.py`: Application entry point.
-- `core/`: Engine and logic
-  - `core/functions/`: inference, device, and workflow orchestration
-  - `core/nodes/`: node types and base classes
-  - `core/pipeline.py`: pipeline analysis/validation
-- `ui/`: PyQt5 UI (windows, dialogs, components)
-- `config/`: settings and theme
-- `resources/`: assets
-- `tests/` + root `test_*.py`: runnable test scripts
-
-## Build, Test, and Development Commands
-- Environment: Python 3.9–3.11.
-- Setup (uv): `uv venv && . .venv/bin/activate` (Windows: `.venv\Scripts\activate`), then `uv pip install -e .`
-- Setup (pip): `python -m venv .venv && activate && pip install -e .`
-- Run app: `python main.py`
-- Run tests (examples):
-  - `python tests/test_integration.py`
-  - `python tests/test_deploy.py`
-  - Many tests are direct scripts; run from repo root.
-
-## Coding Style & Naming Conventions
-- Python, PEP 8, 4-space indents.
-- Names: modules/functions `snake_case`, classes `PascalCase`, constants `UPPER_SNAKE_CASE`.
-- Prefer type hints and docstrings for new/changed code.
-- Separation: keep UI in `ui/`; business logic in `core/`; avoid mixing concerns.
-
-## Testing Guidelines
-- Place runnable scripts under `tests/` and name `test_*.py`.
-- Follow TDD principles in `CLAUDE.md` (small, focused tests; Red → Green → Refactor).
-- GUI tests: create a minimal `QApplication` as needed; keep long-running or hardware-dependent tests optional.
-- Example pattern: `if __name__ == "__main__": run_all_tests()` to allow direct execution.
-
-## Commit & Pull Request Guidelines
-- Small, atomic commits; all tests pass before commit.
-- Message style: imperative mood; note change type e.g. `[Structural]` vs `[Behavioral]` per `CLAUDE.md`.
-- PRs include: clear description, linked issue, test plan, and screenshots/GIFs for UI changes.
-- Do not introduce unrelated refactors in feature/bugfix PRs.
-
-## Security & Configuration Tips
-- Do not commit firmware (`fw_*.bin`) or model (`.nef`) files.
-- Avoid hard-coded absolute paths; use project-relative paths and config in `config/`.
-- Headless runs: set `QT_QPA_PLATFORM=offscreen` when needed.
-
-## Agent-Specific Instructions
-- Scope: applies to entire repository tree.
-- Make minimal, targeted patches; do not add dependencies without discussion.
-- Prefer absolute imports from package root; keep edits consistent with existing structure and naming.
-
-## TOOL to use
-- 你可以使用 「gemini -p "xxx"」來呼叫 gemini cli 這個工具做事情， gemini cli 的上下文 token 很大，你可以用它找專案裡的程式碼，上網查資料等。但禁止使用它修改或刪除檔案。以下是一個使用範例
- - Bash(gemini -p "找出專案裡使用 xAI 的地方")

CLAUDE.md

@@ -74,8 +74,3 @@ When approaching a new feature:
 Follow this process precisely, always prioritizing clean, well-tested code over quick implementation.
 
 Always write one test at a time, make it run, then improve structure. Always run all the tests (except long-running tests) each time.
-
-
-## TOOL to use
-- 你可以使用 「gemini -p "xxx"」來呼叫 gemini cli 這個工具做事情， gemini cli 的上下文 token 很大，你可以用它找專案裡的程式碼，上網查資料等。但禁止使用它修改或刪除檔案。以下是一個使用範例
- - Bash(gemini -p "找出專案裡使用 xAI 的地方")

README.md

@@ -246,14 +246,3 @@ cluster4npu_ui/
 ├── tests/                 # Test suite
 └── resources/             # Assets and styling
 ```
-
-### Contributing
-
-1. Follow the TDD workflow defined in `CLAUDE.md`
-2. Run tests before committing changes
-3. Maintain the three-panel UI architecture
-4. Document new node types and their properties
-
-## License
-
-This project is part of the Cluster4NPU ecosystem for parallel AI inference on Kneron NPU hardware.

check_multi_series_config.py

@@ -1,110 +0,0 @@
-#!/usr/bin/env python3
-"""
-Check current multi-series configuration in saved .mflow files
-"""
-
-import json
-import os
-import glob
-
-def check_mflow_files():
-    """Check .mflow files for multi-series configuration"""
-    
-    # Look for .mflow files in common locations
-    search_paths = [
-        "*.mflow",
-        "flows/*.mflow", 
-        "examples/*.mflow",
-        "../*.mflow"
-    ]
-    
-    mflow_files = []
-    for pattern in search_paths:
-        mflow_files.extend(glob.glob(pattern))
-    
-    if not mflow_files:
-        print("No .mflow files found in current directory")
-        return
-    
-    print(f"Found {len(mflow_files)} .mflow file(s):")
-    
-    for mflow_file in mflow_files:
-        print(f"\n=== Checking {mflow_file} ===")
-        
-        try:
-            with open(mflow_file, 'r') as f:
-                data = json.load(f)
-            
-            # Look for nodes with type "Model" or "ExactModelNode"
-            nodes = data.get('nodes', [])
-            model_nodes = [node for node in nodes if node.get('type') in ['Model', 'ExactModelNode']]
-            
-            if not model_nodes:
-                print("  No Model nodes found")
-                continue
-            
-            for i, node in enumerate(model_nodes):
-                print(f"\n  Model Node {i+1}:")
-                print(f"    Name: {node.get('name', 'Unnamed')}")
-                
-                # Check both custom_properties and properties for multi-series config
-                custom_properties = node.get('custom_properties', {})
-                properties = node.get('properties', {})
-                
-                # Multi-series config is typically in custom_properties
-                config_props = custom_properties if custom_properties else properties
-                
-                # Check multi-series configuration
-                multi_series_mode = config_props.get('multi_series_mode', False)
-                enabled_series = config_props.get('enabled_series', [])
-                
-                print(f"    multi_series_mode: {multi_series_mode}")
-                print(f"    enabled_series: {enabled_series}")
-                
-                if multi_series_mode:
-                    print("    Multi-series port configurations:")
-                    for series in ['520', '720', '630', '730', '540']:
-                        port_ids = config_props.get(f'kl{series}_port_ids', '')
-                        if port_ids:
-                            print(f"      kl{series}_port_ids: '{port_ids}'")
-                    
-                    assets_folder = config_props.get('assets_folder', '')
-                    if assets_folder:
-                        print(f"    assets_folder: '{assets_folder}'")
-                    else:
-                        print("    assets_folder: (not set)")
-                else:
-                    print("    Multi-series mode is DISABLED")
-                    print("    Current single-series configuration:")
-                    port_ids = properties.get('port_ids', [])
-                    model_path = properties.get('model_path', '')
-                    print(f"      port_ids: {port_ids}")
-                    print(f"      model_path: '{model_path}'")
-                
-        except Exception as e:
-            print(f"  Error reading file: {e}")
-
-def print_configuration_guide():
-    """Print guide for setting up multi-series configuration"""
-    print("\n" + "="*60)
-    print("MULTI-SERIES CONFIGURATION GUIDE")
-    print("="*60)
-    print()
-    print("To enable multi-series inference, set these properties in your Model Node:")
-    print()
-    print("1. multi_series_mode = True")
-    print("2. enabled_series = ['520', '720']")
-    print("3. kl520_port_ids = '28,32'")
-    print("4. kl720_port_ids = '4'")
-    print("5. assets_folder = (optional, for auto model/firmware detection)")
-    print()
-    print("Expected devices found:")
-    print("  KL520 devices on ports: 28, 32")
-    print("  KL720 device on port: 4")
-    print()
-    print("If multi_series_mode is False or not set, the system will use")
-    print("single-series mode with only the first available device.")
-
-if __name__ == "__main__":
-    check_mflow_files()
-    print_configuration_guide()

core/functions/InferencePipeline.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from concurrent.futures import ThreadPoolExecutor
 import numpy as np
 
-from .Multidongle import MultiDongle, PreProcessor, PostProcessor, DataProcessor
+from Multidongle import MultiDongle, PreProcessor, PostProcessor, DataProcessor
 
 @dataclass
 class StageConfig:
@@ -19,8 +19,6 @@ class StageConfig:
     model_path: str
     upload_fw: bool
     max_queue_size: int = 50
-    # Multi-series support
-    multi_series_config: Optional[Dict[str, Any]] = None  # For multi-series mode
     # Inter-stage processing
     input_preprocessor: Optional[PreProcessor] = None  # Before this stage
     output_postprocessor: Optional[PostProcessor] = None  # After this stage
@@ -45,25 +43,15 @@ class PipelineStage:
         self.stage_id = config.stage_id
         
         # Initialize MultiDongle for this stage
-        if config.multi_series_config:
-            # Multi-series mode
-            self.multidongle = MultiDongle(
-                multi_series_config=config.multi_series_config,
-                max_queue_size=config.max_queue_size
-            )
-            print(f"[Stage {self.stage_id}] Initialized in multi-series mode with config: {list(config.multi_series_config.keys())}")
-        else:
-            # Single-series mode (legacy)
-            self.multidongle = MultiDongle(
-                port_id=config.port_ids,
-                scpu_fw_path=config.scpu_fw_path,
-                ncpu_fw_path=config.ncpu_fw_path,
-                model_path=config.model_path,
-                upload_fw=config.upload_fw,
-                auto_detect=config.auto_detect if hasattr(config, 'auto_detect') else False,
-                max_queue_size=config.max_queue_size
-            )
-            print(f"[Stage {self.stage_id}] Initialized in single-series mode")
+        self.multidongle = MultiDongle(
+            port_id=config.port_ids,
+            scpu_fw_path=config.scpu_fw_path,
+            ncpu_fw_path=config.ncpu_fw_path,
+            model_path=config.model_path,
+            upload_fw=config.upload_fw,
+            auto_detect=config.auto_detect if hasattr(config, 'auto_detect') else False,
+            max_queue_size=config.max_queue_size
+        )
         
         # Store preprocessor and postprocessor for later use
         self.stage_preprocessor = config.stage_preprocessor
@@ -90,13 +78,6 @@ class PipelineStage:
         """Initialize the stage"""
         print(f"[Stage {self.stage_id}] Initializing...")
         try:
-            # Set postprocessor if available
-            if self.stage_postprocessor:
-                self.multidongle.set_postprocess_options(self.stage_postprocessor.options)
-                print(f"[Stage {self.stage_id}] Applied postprocessor: {self.stage_postprocessor.options.postprocess_type.value}")
-            else:
-                print(f"[Stage {self.stage_id}] No postprocessor configured, using default")
-            
             self.multidongle.initialize()
             self.multidongle.start()
             print(f"[Stage {self.stage_id}] Initialized successfully")

core/functions/demo_topology_clean.py

@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+"""
+智慧拓撲排序算法演示 (獨立版本)
+
+不依賴外部模組，純粹展示拓撲排序算法的核心功能
+"""
+
+import json
+from typing import List, Dict, Any, Tuple
+from collections import deque
+
+class TopologyDemo:
+    """演示拓撲排序算法的類別"""
+    
+    def __init__(self):
+        self.stage_order = []
+        
+    def analyze_pipeline(self, pipeline_data: Dict[str, Any]):
+        """分析pipeline並執行拓撲排序"""
+        print("Starting intelligent pipeline topology analysis...")
+        
+        # 提取模型節點
+        model_nodes = [node for node in pipeline_data.get('nodes', []) 
+                      if 'model' in node.get('type', '').lower()]
+        connections = pipeline_data.get('connections', [])
+        
+        if not model_nodes:
+            print("   Warning: No model nodes found!")
+            return []
+            
+        # 建立依賴圖
+        dependency_graph = self._build_dependency_graph(model_nodes, connections)
+        
+        # 檢測循環
+        cycles = self._detect_cycles(dependency_graph)
+        if cycles:
+            print(f"   Warning: Found {len(cycles)} cycles!")
+            dependency_graph = self._resolve_cycles(dependency_graph, cycles)
+        
+        # 執行拓撲排序
+        sorted_stages = self._topological_sort_with_optimization(dependency_graph, model_nodes)
+        
+        # 計算指標
+        metrics = self._calculate_pipeline_metrics(sorted_stages, dependency_graph)
+        self._display_pipeline_analysis(sorted_stages, metrics)
+        
+        return sorted_stages
+    
+    def _build_dependency_graph(self, model_nodes: List[Dict], connections: List[Dict]) -> Dict[str, Dict]:
+        """建立依賴圖"""
+        print("   Building dependency graph...")
+        
+        graph = {}
+        for node in model_nodes:
+            graph[node['id']] = {
+                'node': node,
+                'dependencies': set(),
+                'dependents': set(),
+                'depth': 0
+            }
+        
+        # 分析連接
+        for conn in connections:
+            output_node_id = conn.get('output_node')
+            input_node_id = conn.get('input_node')
+            
+            if output_node_id in graph and input_node_id in graph:
+                graph[input_node_id]['dependencies'].add(output_node_id)
+                graph[output_node_id]['dependents'].add(input_node_id)
+        
+        dep_count = sum(len(data['dependencies']) for data in graph.values())
+        print(f"   Graph built: {len(graph)} nodes, {dep_count} dependencies")
+        return graph
+    
+    def _detect_cycles(self, graph: Dict[str, Dict]) -> List[List[str]]:
+        """檢測循環"""
+        print("   Checking for dependency cycles...")
+        
+        cycles = []
+        visited = set()
+        rec_stack = set()
+        
+        def dfs_cycle_detect(node_id, path):
+            if node_id in rec_stack:
+                cycle_start = path.index(node_id)
+                cycle = path[cycle_start:] + [node_id]
+                cycles.append(cycle)
+                return True
+                
+            if node_id in visited:
+                return False
+                
+            visited.add(node_id)
+            rec_stack.add(node_id)
+            path.append(node_id)
+            
+            for dependent in graph[node_id]['dependents']:
+                if dfs_cycle_detect(dependent, path):
+                    return True
+                    
+            path.pop()
+            rec_stack.remove(node_id)
+            return False
+        
+        for node_id in graph:
+            if node_id not in visited:
+                dfs_cycle_detect(node_id, [])
+        
+        if cycles:
+            print(f"   Warning: Found {len(cycles)} cycles")
+        else:
+            print("   No cycles detected")
+            
+        return cycles
+    
+    def _resolve_cycles(self, graph: Dict[str, Dict], cycles: List[List[str]]) -> Dict[str, Dict]:
+        """解決循環"""
+        print("   Resolving dependency cycles...")
+        
+        for cycle in cycles:
+            node_names = [graph[nid]['node']['name'] for nid in cycle]
+            print(f"      Breaking cycle: {' → '.join(node_names)}")
+            
+            if len(cycle) >= 2:
+                node_to_break = cycle[-2]
+                dependent_to_break = cycle[-1]
+                
+                graph[dependent_to_break]['dependencies'].discard(node_to_break)
+                graph[node_to_break]['dependents'].discard(dependent_to_break)
+                
+                print(f"      Broke dependency: {graph[node_to_break]['node']['name']} → {graph[dependent_to_break]['node']['name']}")
+        
+        return graph
+    
+    def _topological_sort_with_optimization(self, graph: Dict[str, Dict], model_nodes: List[Dict]) -> List[Dict]:
+        """執行優化的拓撲排序"""
+        print("   Performing optimized topological sort...")
+        
+        # 計算深度層級
+        self._calculate_depth_levels(graph)
+        
+        # 按深度分組
+        depth_groups = self._group_by_depth(graph)
+        
+        # 排序
+        sorted_nodes = []
+        for depth in sorted(depth_groups.keys()):
+            group_nodes = depth_groups[depth]
+            
+            group_nodes.sort(key=lambda nid: (
+                len(graph[nid]['dependencies']),
+                -len(graph[nid]['dependents']),
+                graph[nid]['node']['name']
+            ))
+            
+            for node_id in group_nodes:
+                sorted_nodes.append(graph[node_id]['node'])
+                
+        print(f"   Sorted {len(sorted_nodes)} stages into {len(depth_groups)} execution levels")
+        return sorted_nodes
+    
+    def _calculate_depth_levels(self, graph: Dict[str, Dict]):
+        """計算深度層級"""
+        print("      Calculating execution depth levels...")
+        
+        no_deps = [nid for nid, data in graph.items() if not data['dependencies']]
+        queue = deque([(nid, 0) for nid in no_deps])
+        
+        while queue:
+            node_id, depth = queue.popleft()
+            
+            if graph[node_id]['depth'] < depth:
+                graph[node_id]['depth'] = depth
+                
+                for dependent in graph[node_id]['dependents']:
+                    queue.append((dependent, depth + 1))
+    
+    def _group_by_depth(self, graph: Dict[str, Dict]) -> Dict[int, List[str]]:
+        """按深度分組"""
+        depth_groups = {}
+        
+        for node_id, data in graph.items():
+            depth = data['depth']
+            if depth not in depth_groups:
+                depth_groups[depth] = []
+            depth_groups[depth].append(node_id)
+            
+        return depth_groups
+    
+    def _calculate_pipeline_metrics(self, sorted_stages: List[Dict], graph: Dict[str, Dict]) -> Dict[str, Any]:
+        """計算指標"""
+        print("   Calculating pipeline metrics...")
+        
+        total_stages = len(sorted_stages)
+        max_depth = max([data['depth'] for data in graph.values()]) + 1 if graph else 1
+        
+        depth_distribution = {}
+        for data in graph.values():
+            depth = data['depth']
+            depth_distribution[depth] = depth_distribution.get(depth, 0) + 1
+            
+        max_parallel = max(depth_distribution.values()) if depth_distribution else 1
+        critical_path = self._find_critical_path(graph)
+        
+        return {
+            'total_stages': total_stages,
+            'pipeline_depth': max_depth,
+            'max_parallel_stages': max_parallel,
+            'parallelization_efficiency': (total_stages / max_depth) if max_depth > 0 else 1.0,
+            'critical_path_length': len(critical_path),
+            'critical_path': critical_path
+        }
+    
+    def _find_critical_path(self, graph: Dict[str, Dict]) -> List[str]:
+        """找出關鍵路徑"""
+        longest_path = []
+        
+        def dfs_longest_path(node_id, current_path):
+            nonlocal longest_path
+            
+            current_path.append(node_id)
+            
+            if not graph[node_id]['dependents']:
+                if len(current_path) > len(longest_path):
+                    longest_path = current_path.copy()
+            else:
+                for dependent in graph[node_id]['dependents']:
+                    dfs_longest_path(dependent, current_path)
+                    
+            current_path.pop()
+        
+        for node_id, data in graph.items():
+            if not data['dependencies']:
+                dfs_longest_path(node_id, [])
+                
+        return longest_path
+    
+    def _display_pipeline_analysis(self, sorted_stages: List[Dict], metrics: Dict[str, Any]):
+        """顯示分析結果"""
+        print("\n" + "="*60)
+        print("INTELLIGENT PIPELINE TOPOLOGY ANALYSIS COMPLETE")
+        print("="*60)
+        
+        print(f"Pipeline Metrics:")
+        print(f"   Total Stages: {metrics['total_stages']}")
+        print(f"   Pipeline Depth: {metrics['pipeline_depth']} levels")
+        print(f"   Max Parallel Stages: {metrics['max_parallel_stages']}")
+        print(f"   Parallelization Efficiency: {metrics['parallelization_efficiency']:.1%}")
+        
+        print(f"\nOptimized Execution Order:")
+        for i, stage in enumerate(sorted_stages, 1):
+            print(f"   {i:2d}. {stage['name']} (ID: {stage['id'][:8]}...)")
+        
+        if metrics['critical_path']:
+            print(f"\nCritical Path ({metrics['critical_path_length']} stages):")
+            critical_names = []
+            for node_id in metrics['critical_path']:
+                node_name = next((stage['name'] for stage in sorted_stages if stage['id'] == node_id), 'Unknown')
+                critical_names.append(node_name)
+            print(f"   {' → '.join(critical_names)}")
+        
+        print(f"\nPerformance Insights:")
+        if metrics['parallelization_efficiency'] > 0.8:
+            print("   Excellent parallelization potential!")
+        elif metrics['parallelization_efficiency'] > 0.6:
+            print("   Good parallelization opportunities available")
+        else:
+            print("   Limited parallelization - consider pipeline redesign")
+            
+        if metrics['pipeline_depth'] <= 3:
+            print("   Low latency pipeline - great for real-time applications")
+        elif metrics['pipeline_depth'] <= 6:
+            print("   Balanced pipeline depth - good throughput/latency trade-off")
+        else:
+            print("   Deep pipeline - optimized for maximum throughput")
+            
+        print("="*60 + "\n")
+
+def create_demo_pipelines():
+    """創建演示用的pipeline"""
+    
+    # Demo 1: 簡單線性pipeline
+    simple_pipeline = {
+        "project_name": "Simple Linear Pipeline",
+        "nodes": [
+            {"id": "model_001", "name": "Object Detection", "type": "ExactModelNode"},
+            {"id": "model_002", "name": "Fire Classification", "type": "ExactModelNode"},
+            {"id": "model_003", "name": "Result Verification", "type": "ExactModelNode"}
+        ],
+        "connections": [
+            {"output_node": "model_001", "input_node": "model_002"},
+            {"output_node": "model_002", "input_node": "model_003"}
+        ]
+    }
+    
+    # Demo 2: 並行pipeline
+    parallel_pipeline = {
+        "project_name": "Parallel Processing Pipeline",
+        "nodes": [
+            {"id": "model_001", "name": "RGB Processor", "type": "ExactModelNode"},
+            {"id": "model_002", "name": "IR Processor", "type": "ExactModelNode"},
+            {"id": "model_003", "name": "Depth Processor", "type": "ExactModelNode"},
+            {"id": "model_004", "name": "Fusion Engine", "type": "ExactModelNode"}
+        ],
+        "connections": [
+            {"output_node": "model_001", "input_node": "model_004"},
+            {"output_node": "model_002", "input_node": "model_004"},
+            {"output_node": "model_003", "input_node": "model_004"}
+        ]
+    }
+    
+    # Demo 3: 複雜多層pipeline
+    complex_pipeline = {
+        "project_name": "Advanced Multi-Stage Fire Detection Pipeline",
+        "nodes": [
+            {"id": "model_rgb_001", "name": "RGB Feature Extractor", "type": "ExactModelNode"},
+            {"id": "model_edge_002", "name": "Edge Feature Extractor", "type": "ExactModelNode"},
+            {"id": "model_thermal_003", "name": "Thermal Feature Extractor", "type": "ExactModelNode"},
+            {"id": "model_fusion_004", "name": "Feature Fusion", "type": "ExactModelNode"},
+            {"id": "model_attention_005", "name": "Attention Mechanism", "type": "ExactModelNode"},
+            {"id": "model_classifier_006", "name": "Fire Classifier", "type": "ExactModelNode"}
+        ],
+        "connections": [
+            {"output_node": "model_rgb_001", "input_node": "model_fusion_004"},
+            {"output_node": "model_edge_002", "input_node": "model_fusion_004"},
+            {"output_node": "model_thermal_003", "input_node": "model_attention_005"},
+            {"output_node": "model_fusion_004", "input_node": "model_classifier_006"},
+            {"output_node": "model_attention_005", "input_node": "model_classifier_006"}
+        ]
+    }
+    
+    # Demo 4: 有循環的pipeline (測試循環檢測)
+    cycle_pipeline = {
+        "project_name": "Pipeline with Cycles (Testing)",
+        "nodes": [
+            {"id": "model_A", "name": "Model A", "type": "ExactModelNode"},
+            {"id": "model_B", "name": "Model B", "type": "ExactModelNode"},
+            {"id": "model_C", "name": "Model C", "type": "ExactModelNode"}
+        ],
+        "connections": [
+            {"output_node": "model_A", "input_node": "model_B"},
+            {"output_node": "model_B", "input_node": "model_C"},
+            {"output_node": "model_C", "input_node": "model_A"}  # 創建循環!
+        ]
+    }
+    
+    return [simple_pipeline, parallel_pipeline, complex_pipeline, cycle_pipeline]
+
+def main():
+    """主演示函數"""
+    print("INTELLIGENT PIPELINE TOPOLOGY SORTING DEMONSTRATION")
+    print("="*60)
+    print("This demo showcases our advanced pipeline analysis capabilities:")
+    print("• Automatic dependency resolution")
+    print("• Parallel execution optimization")
+    print("• Cycle detection and prevention")
+    print("• Critical path analysis")
+    print("• Performance metrics calculation")
+    print("="*60 + "\n")
+    
+    demo = TopologyDemo()
+    pipelines = create_demo_pipelines()
+    demo_names = ["Simple Linear", "Parallel Processing", "Complex Multi-Stage", "Cycle Detection"]
+    
+    for i, (pipeline, name) in enumerate(zip(pipelines, demo_names), 1):
+        print(f"DEMO {i}: {name} Pipeline")
+        print("="*50)
+        demo.analyze_pipeline(pipeline)
+        print("\n")
+    
+    print("ALL DEMONSTRATIONS COMPLETED SUCCESSFULLY!")
+    print("Ready for production deployment and progress reporting!")
+
+if __name__ == "__main__":
+    main()

core/functions/mflow_converter.py

@@ -23,11 +23,10 @@ Usage:
 
 import json
 import os
-from typing import List, Dict, Any, Tuple, Optional
+from typing import List, Dict, Any, Tuple
 from dataclasses import dataclass
 
-from .InferencePipeline import StageConfig, InferencePipeline
-from .Multidongle import PostProcessor, PostProcessorOptions, PostProcessType
+from InferencePipeline import StageConfig, InferencePipeline
 
 
 class DefaultProcessors:
@@ -464,86 +463,12 @@ class MFlowConverter:
             
         print("="*60 + "\n")
     
-    def _build_multi_series_config_from_properties(self, properties: Dict[str, Any]) -> Dict[str, Any]:
-        """Build multi-series configuration from node properties"""
-        try:
-            enabled_series = properties.get('enabled_series', [])
-            assets_folder = properties.get('assets_folder', '')
-            
-            if not enabled_series:
-                print("Warning: No enabled_series found in multi-series mode")
-                return {}
-            
-            multi_series_config = {}
-            
-            for series in enabled_series:
-                # Get port IDs for this series
-                port_ids_str = properties.get(f'kl{series}_port_ids', '')
-                if not port_ids_str or not port_ids_str.strip():
-                    print(f"Warning: No port IDs configured for KL{series}")
-                    continue
-                
-                # Parse port IDs (comma-separated string to list of integers)
-                try:
-                    port_ids = [int(pid.strip()) for pid in port_ids_str.split(',') if pid.strip()]
-                    if not port_ids:
-                        continue
-                except ValueError:
-                    print(f"Warning: Invalid port IDs for KL{series}: {port_ids_str}")
-                    continue
-                
-                # Build series configuration
-                series_config = {
-                    "port_ids": port_ids
-                }
-                
-                # Add model path if assets folder is configured
-                if assets_folder:
-                    import os
-                    model_folder = os.path.join(assets_folder, 'Models', f'KL{series}')
-                    if os.path.exists(model_folder):
-                        # Look for .nef files in the model folder
-                        nef_files = [f for f in os.listdir(model_folder) if f.endswith('.nef')]
-                        if nef_files:
-                            series_config["model_path"] = os.path.join(model_folder, nef_files[0])
-                            print(f"Found model for KL{series}: {series_config['model_path']}")
-                    
-                    # Add firmware paths if available
-                    firmware_folder = os.path.join(assets_folder, 'Firmware', f'KL{series}')
-                    if os.path.exists(firmware_folder):
-                        scpu_path = os.path.join(firmware_folder, 'fw_scpu.bin')
-                        ncpu_path = os.path.join(firmware_folder, 'fw_ncpu.bin')
-                        
-                        if os.path.exists(scpu_path) and os.path.exists(ncpu_path):
-                            series_config["firmware_paths"] = {
-                                "scpu": scpu_path,
-                                "ncpu": ncpu_path
-                            }
-                            print(f"Found firmware for KL{series}: scpu={scpu_path}, ncpu={ncpu_path}")
-                
-                multi_series_config[f'KL{series}'] = series_config
-                print(f"Configured KL{series} with {len(port_ids)} devices on ports {port_ids}")
-            
-            return multi_series_config if multi_series_config else {}
-            
-        except Exception as e:
-            print(f"Error building multi-series config from properties: {e}")
-            return {}
-    
     def _create_stage_configs(self, model_nodes: List[Dict], preprocess_nodes: List[Dict], 
                             postprocess_nodes: List[Dict], connections: List[Dict]) -> List[StageConfig]:
-        """Create StageConfig objects for each model node with postprocessing support"""
+        """Create StageConfig objects for each model node"""
+        # Note: preprocess_nodes, postprocess_nodes, connections reserved for future enhanced processing
         stage_configs = []
         
-        # Build connection mapping for efficient lookup
-        connection_map = {}
-        for conn in connections:
-            output_node_id = conn.get('output_node')
-            input_node_id = conn.get('input_node')
-            if output_node_id not in connection_map:
-                connection_map[output_node_id] = []
-            connection_map[output_node_id].append(input_node_id)
-        
         for i, model_node in enumerate(self.stage_order):
             properties = model_node.get('properties', {})
             
@@ -577,107 +502,16 @@ class MFlowConverter:
             # Queue size
             max_queue_size = properties.get('max_queue_size', 50)
             
-            # Find connected postprocessing node
-            stage_postprocessor = None
-            model_node_id = model_node.get('id')
-            
-            if model_node_id and model_node_id in connection_map:
-                connected_nodes = connection_map[model_node_id]
-                # Look for postprocessing nodes among connected nodes
-                for connected_id in connected_nodes:
-                    for postprocess_node in postprocess_nodes:
-                        if postprocess_node.get('id') == connected_id:
-                            # Found a connected postprocessing node
-                            postprocess_props = postprocess_node.get('properties', {})
-                            
-                            # Extract postprocessing configuration
-                            postprocess_type_str = postprocess_props.get('postprocess_type', 'fire_detection')
-                            confidence_threshold = postprocess_props.get('confidence_threshold', 0.5)
-                            nms_threshold = postprocess_props.get('nms_threshold', 0.5)
-                            max_detections = postprocess_props.get('max_detections', 100)
-                            class_names_str = postprocess_props.get('class_names', '')
-                            
-                            # Parse class names from node (highest priority)
-                            if isinstance(class_names_str, str) and class_names_str.strip():
-                                class_names = [name.strip() for name in class_names_str.split(',') if name.strip()]
-                            else:
-                                class_names = []
-                            
-                            # Map string to PostProcessType enum
-                            type_mapping = {
-                                'fire_detection': PostProcessType.FIRE_DETECTION,
-                                'yolo_v3': PostProcessType.YOLO_V3,
-                                'yolo_v5': PostProcessType.YOLO_V5,
-                                'classification': PostProcessType.CLASSIFICATION,
-                                'raw_output': PostProcessType.RAW_OUTPUT
-                            }
-                            
-                            postprocess_type = type_mapping.get(postprocess_type_str, PostProcessType.FIRE_DETECTION)
-                            
-                            # Smart defaults for YOLOv5 labels when none provided
-                            if postprocess_type == PostProcessType.YOLO_V5 and not class_names:
-                                # Try to load labels near the model file
-                                loaded = self._load_labels_for_model(model_path)
-                                if loaded:
-                                    class_names = loaded
-                                else:
-                                    # Fallback to COCO-80
-                                    class_names = self._default_coco_labels()
-                            
-                            print(f"Found postprocessing for {stage_id}: type={postprocess_type.value}, threshold={confidence_threshold}, classes={len(class_names)}")
-                            
-                            # Create PostProcessorOptions and PostProcessor
-                            try:
-                                postprocess_options = PostProcessorOptions(
-                                    postprocess_type=postprocess_type,
-                                    threshold=confidence_threshold,
-                                    class_names=class_names,
-                                    nms_threshold=nms_threshold,
-                                    max_detections_per_class=max_detections
-                                )
-                                stage_postprocessor = PostProcessor(postprocess_options)
-                            except Exception as e:
-                                print(f"Warning: Failed to create postprocessor for {stage_id}: {e}")
-                            
-                            break  # Use the first postprocessing node found
-            
-            if stage_postprocessor is None:
-                print(f"No postprocessing node found for {stage_id}, using default")
-                            
-            # Check if multi-series mode is enabled
-            multi_series_mode = properties.get('multi_series_mode', False)
-            multi_series_config = None
-            
-            if multi_series_mode:
-                # Build multi-series config from node properties
-                multi_series_config = self._build_multi_series_config_from_properties(properties)
-                print(f"Multi-series config for {stage_id}: {multi_series_config}")
-                
-                # Create StageConfig for multi-series mode
-                stage_config = StageConfig(
-                    stage_id=stage_id,
-                    port_ids=[],  # Will be handled by multi_series_config
-                    scpu_fw_path='',  # Will be handled by multi_series_config
-                    ncpu_fw_path='',  # Will be handled by multi_series_config
-                    model_path='',  # Will be handled by multi_series_config
-                    upload_fw=upload_fw,
-                    max_queue_size=max_queue_size,
-                    multi_series_config=multi_series_config,
-                    stage_postprocessor=stage_postprocessor
-                )
-            else:
-                # Create StageConfig for single-series mode (legacy)
-                stage_config = StageConfig(
-                    stage_id=stage_id,
-                    port_ids=port_ids,
-                    scpu_fw_path=scpu_fw_path,
-                    ncpu_fw_path=ncpu_fw_path,
-                    model_path=model_path,
-                    upload_fw=upload_fw,
-                    max_queue_size=max_queue_size,
-                    multi_series_config=None,
-                    stage_postprocessor=stage_postprocessor
-                )
+            # Create StageConfig
+            stage_config = StageConfig(
+                stage_id=stage_id,
+                port_ids=port_ids,
+                scpu_fw_path=scpu_fw_path,
+                ncpu_fw_path=ncpu_fw_path,
+                model_path=model_path,
+                upload_fw=upload_fw,
+                max_queue_size=max_queue_size
+            )
             
             stage_configs.append(stage_config)
             
@@ -733,99 +567,6 @@ class MFlowConverter:
             
         return configs
     
-    # ---------- Label helpers ----------
-    def _load_labels_for_model(self, model_path: str) -> Optional[List[str]]:
-        """Attempt to load class labels from files near the model path.
-        Priority: <model>.names -> names.txt -> classes.txt -> labels.txt -> data.yaml/dataset.yaml (names)
-        Returns None if not found.
-        """
-        try:
-            if not model_path:
-                return None
-            base = os.path.splitext(model_path)[0]
-            dir_ = os.path.dirname(model_path)
-            candidates = [
-                f"{base}.names",
-                os.path.join(dir_, 'names.txt'),
-                os.path.join(dir_, 'classes.txt'),
-                os.path.join(dir_, 'labels.txt'),
-                os.path.join(dir_, 'data.yaml'),
-                os.path.join(dir_, 'dataset.yaml'),
-            ]
-            for path in candidates:
-                if os.path.exists(path):
-                    if path.lower().endswith('.yaml'):
-                        labels = self._load_labels_from_yaml(path)
-                    else:
-                        labels = self._load_labels_from_lines(path)
-                    if labels:
-                        print(f"Loaded {len(labels)} labels from {os.path.basename(path)}")
-                        return labels
-        except Exception as e:
-            print(f"Warning: failed loading labels near model: {e}")
-        return None
-
-    def _load_labels_from_lines(self, path: str) -> List[str]:
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                lines = [ln.strip() for ln in f.readlines()]
-            return [ln for ln in lines if ln and not ln.startswith('#')]
-        except Exception:
-            return []
-
-    def _load_labels_from_yaml(self, path: str) -> List[str]:
-        # Try PyYAML if available; else fallback to simple parse
-        try:
-            import yaml  # type: ignore
-            with open(path, 'r', encoding='utf-8') as f:
-                data = yaml.safe_load(f)
-            names = data.get('names') if isinstance(data, dict) else None
-            if isinstance(names, dict):
-                # Ordered by key if numeric, else values
-                items = sorted(names.items(), key=lambda kv: int(kv[0]) if str(kv[0]).isdigit() else kv[0])
-                return [str(v) for _, v in items]
-            elif isinstance(names, list):
-                return [str(x) for x in names]
-        except Exception:
-            pass
-        # Minimal fallback: naive scan
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                content = f.read()
-            if 'names:' in content:
-                after = content.split('names:', 1)[1]
-                # Look for block list
-                lines = [ln.strip() for ln in after.splitlines()]
-                block = []
-                for ln in lines:
-                    if ln.startswith('- '):
-                        block.append(ln[2:].strip())
-                    elif block:
-                        break
-                if block:
-                    return block
-                # Look for bracket list
-                if '[' in after and ']' in after:
-                    inside = after.split('[', 1)[1].split(']', 1)[0]
-                    return [x.strip().strip('"\'') for x in inside.split(',') if x.strip()]
-        except Exception:
-            pass
-        return []
-
-    def _default_coco_labels(self) -> List[str]:
-        # Standard COCO 80 class names
-        return [
-            'person', 'bicycle', 'car', 'motorbike', 'aeroplane', 'bus', 'train', 'truck', 'boat', 'traffic light',
-            'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
-            'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
-            'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard',
-            'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
-            'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'sofa',
-            'pottedplant', 'bed', 'diningtable', 'toilet', 'tvmonitor', 'laptop', 'mouse', 'remote', 'keyboard',
-            'cell phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors',
-            'teddy bear', 'hair drier', 'toothbrush'
-        ]
-    
     def _extract_postprocessing_configs(self, postprocess_nodes: List[Dict]) -> List[Dict[str, Any]]:
         """Extract postprocessing configurations"""
         configs = []
@@ -884,87 +625,22 @@ class MFlowConverter:
         """Validate individual stage configuration"""
         errors = []
         
-        # Check if this is multi-series configuration
-        if stage_config.multi_series_config:
-            # Multi-series validation
-            errors.extend(self._validate_multi_series_config(stage_config.multi_series_config, stage_num))
-        else:
-            # Single-series validation (legacy)
-            # Check model path
-            if not stage_config.model_path:
-                errors.append(f"Stage {stage_num}: Model path is required")
-            elif not os.path.exists(stage_config.model_path):
-                errors.append(f"Stage {stage_num}: Model file not found: {stage_config.model_path}")
+        # Check model path
+        if not stage_config.model_path:
+            errors.append(f"Stage {stage_num}: Model path is required")
+        elif not os.path.exists(stage_config.model_path):
+            errors.append(f"Stage {stage_num}: Model file not found: {stage_config.model_path}")
             
-            # Check firmware paths if upload_fw is True
-            if stage_config.upload_fw:
-                if not os.path.exists(stage_config.scpu_fw_path):
-                    errors.append(f"Stage {stage_num}: SCPU firmware not found: {stage_config.scpu_fw_path}")
-                if not os.path.exists(stage_config.ncpu_fw_path):
-                    errors.append(f"Stage {stage_num}: NCPU firmware not found: {stage_config.ncpu_fw_path}")
+        # Check firmware paths if upload_fw is True
+        if stage_config.upload_fw:
+            if not os.path.exists(stage_config.scpu_fw_path):
+                errors.append(f"Stage {stage_num}: SCPU firmware not found: {stage_config.scpu_fw_path}")
+            if not os.path.exists(stage_config.ncpu_fw_path):
+                errors.append(f"Stage {stage_num}: NCPU firmware not found: {stage_config.ncpu_fw_path}")
                 
-            # Check port IDs
-            if not stage_config.port_ids:
-                errors.append(f"Stage {stage_num}: At least one port ID is required")
-            
-        return errors
-    
-    def _validate_multi_series_config(self, multi_series_config: Dict[str, Any], stage_num: int) -> List[str]:
-        """Validate multi-series configuration"""
-        errors = []
-        
-        if not multi_series_config:
-            errors.append(f"Stage {stage_num}: Multi-series configuration is empty")
-            return errors
-        
-        print(f"Validating multi-series config for stage {stage_num}: {list(multi_series_config.keys())}")
-        
-        # Check each series configuration
-        for series_name, series_config in multi_series_config.items():
-            if not isinstance(series_config, dict):
-                errors.append(f"Stage {stage_num}: Invalid configuration for {series_name}")
-                continue
-            
-            # Check port IDs
-            port_ids = series_config.get('port_ids', [])
-            if not port_ids:
-                errors.append(f"Stage {stage_num}: {series_name} has no port IDs configured")
-                continue
-            
-            if not isinstance(port_ids, list) or not all(isinstance(p, int) for p in port_ids):
-                errors.append(f"Stage {stage_num}: {series_name} port IDs must be a list of integers")
-                continue
-            
-            print(f"  {series_name}: {len(port_ids)} ports configured")
-            
-            # Check model path
-            model_path = series_config.get('model_path')
-            if model_path:
-                if not os.path.exists(model_path):
-                    errors.append(f"Stage {stage_num}: {series_name} model file not found: {model_path}")
-                else:
-                    print(f"  {series_name}: Model validated: {model_path}")
-            else:
-                print(f"  {series_name}: No model path specified (optional for multi-series)")
-            
-            # Check firmware paths if specified
-            firmware_paths = series_config.get('firmware_paths')
-            if firmware_paths and isinstance(firmware_paths, dict):
-                scpu_path = firmware_paths.get('scpu')
-                ncpu_path = firmware_paths.get('ncpu')
-                
-                if scpu_path and not os.path.exists(scpu_path):
-                    errors.append(f"Stage {stage_num}: {series_name} SCPU firmware not found: {scpu_path}")
-                elif scpu_path:
-                    print(f"  {series_name}: SCPU firmware validated: {scpu_path}")
-                    
-                if ncpu_path and not os.path.exists(ncpu_path):
-                    errors.append(f"Stage {stage_num}: {series_name} NCPU firmware not found: {ncpu_path}")
-                elif ncpu_path:
-                    print(f"  {series_name}: NCPU firmware validated: {ncpu_path}")
-        
-        if not errors:
-            print(f"Stage {stage_num}: Multi-series configuration validation passed")
+        # Check port IDs
+        if not stage_config.port_ids:
+            errors.append(f"Stage {stage_num}: At least one port ID is required")
             
         return errors
 

core/functions/multi_series_converter.py

@@ -0,0 +1,398 @@
+"""
+Multi-Series UI Bridge Converter
+
+This module provides a simplified bridge between the UI pipeline data and the 
+MultiSeriesDongleManager system, making it easy to convert UI configurations
+to working multi-series inference pipelines.
+
+Key Features:
+- Direct conversion from UI pipeline data to MultiSeriesDongleManager config
+- Simplified interface for deployment system
+- Automatic validation and configuration generation
+- Support for both folder-based and individual file configurations
+
+Usage:
+    from multi_series_converter import MultiSeriesConverter
+    
+    converter = MultiSeriesConverter()
+    manager = converter.create_multi_series_manager(pipeline_data, ui_config)
+    
+    manager.start()
+    sequence_id = manager.put_input(image, 'BGR565')
+    result = manager.get_result()
+"""
+
+import os
+import sys
+from typing import Dict, Any, List, Tuple, Optional
+
+# Add parent directory to path for imports
+current_dir = os.path.dirname(__file__)
+parent_dir = os.path.dirname(os.path.dirname(current_dir))
+sys.path.insert(0, parent_dir)
+
+try:
+    from multi_series_dongle_manager import MultiSeriesDongleManager, DongleSeriesSpec
+    MULTI_SERIES_AVAILABLE = True
+except ImportError as e:
+    print(f"MultiSeriesDongleManager not available: {e}")
+    MULTI_SERIES_AVAILABLE = False
+
+
+class MultiSeriesConverter:
+    """Simplified converter for UI to MultiSeriesDongleManager bridge"""
+    
+    def __init__(self):
+        self.series_specs = DongleSeriesSpec.SERIES_SPECS if MULTI_SERIES_AVAILABLE else {
+            0x100: {"name": "KL520", "gops": 3},
+            0x720: {"name": "KL720", "gops": 28},
+            0x630: {"name": "KL630", "gops": 400},
+            0x730: {"name": "KL730", "gops": 1600},
+            0x540: {"name": "KL540", "gops": 800}
+        }
+    
+    def create_multi_series_manager(self, pipeline_data: Dict[str, Any], 
+                                  multi_series_config: Dict[str, Any]) -> Optional[MultiSeriesDongleManager]:
+        """
+        Create and configure MultiSeriesDongleManager from UI data
+        
+        Args:
+            pipeline_data: Pipeline data from UI (.mflow format)
+            multi_series_config: Configuration from MultiSeriesConfigDialog
+            
+        Returns:
+            Configured MultiSeriesDongleManager or None if creation fails
+        """
+        if not MULTI_SERIES_AVAILABLE:
+            print("MultiSeriesDongleManager not available")
+            return None
+        
+        try:
+            # Extract firmware and model paths
+            firmware_paths, model_paths = self._extract_paths(multi_series_config)
+            
+            if not firmware_paths or not model_paths:
+                print("Insufficient firmware or model paths")
+                return None
+            
+            # Create and initialize manager
+            manager = MultiSeriesDongleManager(
+                max_queue_size=multi_series_config.get('max_queue_size', 100),
+                result_buffer_size=multi_series_config.get('result_buffer_size', 1000)
+            )
+            
+            # Initialize devices
+            success = manager.scan_and_initialize_devices(firmware_paths, model_paths)
+            
+            if not success:
+                print("Failed to initialize multi-series devices")
+                return None
+            
+            print("Multi-series manager created and initialized successfully")
+            return manager
+            
+        except Exception as e:
+            print(f"Error creating multi-series manager: {e}")
+            return None
+    
+    def _extract_paths(self, multi_series_config: Dict[str, Any]) -> Tuple[Dict[str, Dict[str, str]], Dict[str, str]]:
+        """Extract firmware and model paths from multi-series config"""
+        config_mode = multi_series_config.get('config_mode', 'folder')
+        enabled_series = multi_series_config.get('enabled_series', [])
+        
+        firmware_paths = {}
+        model_paths = {}
+        
+        if config_mode == 'folder':
+            firmware_paths, model_paths = self._extract_folder_paths(multi_series_config, enabled_series)
+        else:
+            firmware_paths, model_paths = self._extract_individual_paths(multi_series_config, enabled_series)
+        
+        return firmware_paths, model_paths
+    
+    def _extract_folder_paths(self, config: Dict[str, Any], enabled_series: List[str]) -> Tuple[Dict[str, Dict[str, str]], Dict[str, str]]:
+        """Extract paths from folder-based configuration"""
+        assets_folder = config.get('assets_folder', '')
+        if not assets_folder or not os.path.exists(assets_folder):
+            print(f"Assets folder not found: {assets_folder}")
+            return {}, {}
+        
+        firmware_base = os.path.join(assets_folder, 'Firmware')
+        models_base = os.path.join(assets_folder, 'Models')
+        
+        firmware_paths = {}
+        model_paths = {}
+        
+        for series in enabled_series:
+            series_name = f'KL{series}' if series.isdigit() else series
+            
+            # Firmware paths
+            series_fw_dir = os.path.join(firmware_base, series_name)
+            if os.path.exists(series_fw_dir):
+                scpu_path = os.path.join(series_fw_dir, 'fw_scpu.bin')
+                ncpu_path = os.path.join(series_fw_dir, 'fw_ncpu.bin')
+                
+                if os.path.exists(scpu_path) and os.path.exists(ncpu_path):
+                    firmware_paths[series_name] = {
+                        'scpu': scpu_path,
+                        'ncpu': ncpu_path
+                    }
+                else:
+                    print(f"Warning: Missing firmware files for {series_name}")
+            
+            # Model paths - find first .nef file
+            series_model_dir = os.path.join(models_base, series_name)
+            if os.path.exists(series_model_dir):
+                model_files = [f for f in os.listdir(series_model_dir) if f.endswith('.nef')]
+                if model_files:
+                    model_paths[series_name] = os.path.join(series_model_dir, model_files[0])
+                else:
+                    print(f"Warning: No .nef model files found for {series_name}")
+        
+        return firmware_paths, model_paths
+    
+    def _extract_individual_paths(self, config: Dict[str, Any], enabled_series: List[str]) -> Tuple[Dict[str, Dict[str, str]], Dict[str, str]]:
+        """Extract paths from individual file configuration"""
+        individual_paths = config.get('individual_paths', {})
+        
+        firmware_paths = {}
+        model_paths = {}
+        
+        for series in enabled_series:
+            series_name = f'KL{series}' if series.isdigit() else series
+            
+            if series_name in individual_paths:
+                series_config = individual_paths[series_name]
+                
+                # Firmware paths
+                scpu_path = series_config.get('scpu', '')
+                ncpu_path = series_config.get('ncpu', '')
+                
+                if scpu_path and ncpu_path and os.path.exists(scpu_path) and os.path.exists(ncpu_path):
+                    firmware_paths[series_name] = {
+                        'scpu': scpu_path,
+                        'ncpu': ncpu_path
+                    }
+                else:
+                    print(f"Warning: Invalid firmware paths for {series_name}")
+                
+                # Model path
+                model_path = series_config.get('model', '')
+                if model_path and os.path.exists(model_path):
+                    model_paths[series_name] = model_path
+                else:
+                    print(f"Warning: Invalid model path for {series_name}")
+        
+        return firmware_paths, model_paths
+    
+    def validate_multi_series_config(self, multi_series_config: Dict[str, Any]) -> Tuple[bool, List[str]]:
+        """
+        Validate multi-series configuration
+        
+        Args:
+            multi_series_config: Configuration to validate
+            
+        Returns:
+            Tuple of (is_valid, list_of_issues)
+        """
+        issues = []
+        
+        # Check enabled series
+        enabled_series = multi_series_config.get('enabled_series', [])
+        if not enabled_series:
+            issues.append("No series enabled")
+        
+        # Check configuration mode
+        config_mode = multi_series_config.get('config_mode', 'folder')
+        if config_mode not in ['folder', 'individual']:
+            issues.append("Invalid configuration mode")
+        
+        # Validate paths
+        firmware_paths, model_paths = self._extract_paths(multi_series_config)
+        
+        if not firmware_paths:
+            issues.append("No valid firmware paths found")
+        
+        if not model_paths:
+            issues.append("No valid model paths found")
+        
+        # Check if all enabled series have both firmware and models
+        for series in enabled_series:
+            series_name = f'KL{series}' if series.isdigit() else series
+            
+            if series_name not in firmware_paths:
+                issues.append(f"Missing firmware for {series_name}")
+            
+            if series_name not in model_paths:
+                issues.append(f"Missing model for {series_name}")
+        
+        # Check port mapping
+        port_mapping = multi_series_config.get('port_mapping', {})
+        if not port_mapping:
+            issues.append("No port mappings configured")
+        
+        return len(issues) == 0, issues
+    
+    def generate_config_summary(self, multi_series_config: Dict[str, Any]) -> str:
+        """Generate a human-readable summary of the configuration"""
+        enabled_series = multi_series_config.get('enabled_series', [])
+        config_mode = multi_series_config.get('config_mode', 'folder')
+        port_mapping = multi_series_config.get('port_mapping', {})
+        
+        summary = ["Multi-Series Configuration Summary", "=" * 40, ""]
+        
+        summary.append(f"Configuration Mode: {config_mode}")
+        summary.append(f"Enabled Series: {', '.join(enabled_series)}")
+        summary.append(f"Port Mappings: {len(port_mapping)}")
+        summary.append("")
+        
+        # Firmware and model paths
+        firmware_paths, model_paths = self._extract_paths(multi_series_config)
+        
+        summary.append("Firmware Configuration:")
+        for series, fw_config in firmware_paths.items():
+            summary.append(f"  {series}:")
+            summary.append(f"    SCPU: {fw_config.get('scpu', 'Not configured')}")
+            summary.append(f"    NCPU: {fw_config.get('ncpu', 'Not configured')}")
+        summary.append("")
+        
+        summary.append("Model Configuration:")
+        for series, model_path in model_paths.items():
+            model_name = os.path.basename(model_path) if model_path else "Not configured"
+            summary.append(f"  {series}: {model_name}")
+        summary.append("")
+        
+        # Port mapping
+        summary.append("Port Mapping:")
+        if port_mapping:
+            for port_id, series in port_mapping.items():
+                summary.append(f"  Port {port_id}: {series}")
+        else:
+            summary.append("  No port mappings configured")
+        
+        return "\n".join(summary)
+    
+    def get_performance_estimate(self, multi_series_config: Dict[str, Any]) -> Dict[str, Any]:
+        """Get estimated performance for the multi-series configuration"""
+        enabled_series = multi_series_config.get('enabled_series', [])
+        port_mapping = multi_series_config.get('port_mapping', {})
+        
+        total_gops = 0
+        series_counts = {}
+        
+        # Count devices per series
+        for port_id, series in port_mapping.items():
+            series_name = f'KL{series}' if series.isdigit() else series
+            series_counts[series_name] = series_counts.get(series_name, 0) + 1
+        
+        # Calculate total GOPS
+        for series_name, count in series_counts.items():
+            # Find corresponding product_id
+            for product_id, spec in self.series_specs.items():
+                if spec["name"] == series_name:
+                    gops = spec["gops"] * count
+                    total_gops += gops
+                    break
+        
+        # Estimate FPS improvement
+        base_fps = 10  # Baseline single dongle FPS
+        estimated_fps = min(base_fps * (total_gops / 10), base_fps * 5)  # Cap at 5x improvement
+        
+        return {
+            'total_gops': total_gops,
+            'estimated_fps': estimated_fps,
+            'series_counts': series_counts,
+            'total_devices': len(port_mapping),
+            'load_balancing': 'automatic_by_gops'
+        }
+
+
+# Convenience function for easy usage
+def create_multi_series_manager_from_ui(pipeline_data: Dict[str, Any], 
+                                       multi_series_config: Dict[str, Any]) -> Optional[MultiSeriesDongleManager]:
+    """
+    Convenience function to create MultiSeriesDongleManager from UI data
+    
+    Args:
+        pipeline_data: Pipeline data from UI (.mflow format)
+        multi_series_config: Configuration from MultiSeriesConfigDialog
+        
+    Returns:
+        Configured MultiSeriesDongleManager or None if creation fails
+    """
+    converter = MultiSeriesConverter()
+    return converter.create_multi_series_manager(pipeline_data, multi_series_config)
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    # Example configuration for testing
+    example_multi_series_config = {
+        'language': 'en',
+        'enabled_series': ['KL520', 'KL720'],
+        'config_mode': 'folder',
+        'assets_folder': r'C:\MyProject\Assets',
+        'port_mapping': {
+            28: 'KL520',
+            32: 'KL720'
+        },
+        'max_queue_size': 100,
+        'result_buffer_size': 1000
+    }
+    
+    example_pipeline_data = {
+        'project_name': 'Test Multi-Series Pipeline',
+        'description': 'Testing multi-series configuration',
+        'nodes': [
+            {'id': '1', 'type': 'input', 'name': 'Camera Input'},
+            {'id': '2', 'type': 'model', 'name': 'Detection Model', 
+             'custom_properties': {'multi_series_mode': True}},
+            {'id': '3', 'type': 'output', 'name': 'Display Output'}
+        ]
+    }
+    
+    try:
+        converter = MultiSeriesConverter()
+        
+        # Validate configuration
+        is_valid, issues = converter.validate_multi_series_config(example_multi_series_config)
+        
+        print("Multi-Series Converter Test")
+        print("=" * 30)
+        print(f"Configuration valid: {is_valid}")
+        
+        if issues:
+            print("Issues found:")
+            for issue in issues:
+                print(f"  - {issue}")
+        
+        # Generate summary
+        print("\nConfiguration Summary:")
+        print(converter.generate_config_summary(example_multi_series_config))
+        
+        # Get performance estimate
+        performance = converter.get_performance_estimate(example_multi_series_config)
+        print(f"\nPerformance Estimate:")
+        print(f"  Total GOPS: {performance['total_gops']}")
+        print(f"  Estimated FPS: {performance['estimated_fps']:.1f}")
+        print(f"  Total devices: {performance['total_devices']}")
+        
+        # Try to create manager (will fail without hardware)
+        if MULTI_SERIES_AVAILABLE:
+            manager = converter.create_multi_series_manager(
+                example_pipeline_data, 
+                example_multi_series_config
+            )
+            
+            if manager:
+                print("\n✓ MultiSeriesDongleManager created successfully")
+                manager.stop()  # Clean shutdown
+            else:
+                print("\n✗ Failed to create MultiSeriesDongleManager (expected without hardware)")
+        else:
+            print("\n⚠ MultiSeriesDongleManager not available")
+            
+    except Exception as e:
+        print(f"Error testing multi-series converter: {e}")
+        import traceback
+        traceback.print_exc()

core/functions/multi_series_mflow_converter.py

@@ -0,0 +1,443 @@
+"""
+Enhanced MFlow to Multi-Series API Converter
+
+This module extends the MFlowConverter to support multi-series dongle configurations
+by detecting multi-series model nodes and generating appropriate configurations for
+the MultiSeriesDongleManager.
+
+Key Features:
+- Detect multi-series enabled model nodes
+- Generate MultiSeriesStageConfig objects
+- Maintain backward compatibility with single-series configurations
+- Validate multi-series folder structures
+- Optimize pipeline for mixed single/multi-series stages
+
+Usage:
+    from multi_series_mflow_converter import MultiSeriesMFlowConverter
+    
+    converter = MultiSeriesMFlowConverter()
+    pipeline_config = converter.load_and_convert("pipeline.mflow")
+    
+    # Automatically creates appropriate pipeline type
+    if pipeline_config.has_multi_series:
+        pipeline = MultiSeriesInferencePipeline(pipeline_config.stage_configs)
+    else:
+        pipeline = InferencePipeline(pipeline_config.stage_configs)
+"""
+
+import json
+import os
+from typing import List, Dict, Any, Tuple, Union
+from dataclasses import dataclass
+
+# Import base converter and pipeline components
+from .mflow_converter import MFlowConverter, PipelineConfig
+from .multi_series_pipeline import MultiSeriesStageConfig, MultiSeriesInferencePipeline
+from .InferencePipeline import StageConfig
+
+
+@dataclass
+class EnhancedPipelineConfig:
+    """Enhanced pipeline configuration supporting both single and multi-series"""
+    stage_configs: List[Union[StageConfig, MultiSeriesStageConfig]]
+    pipeline_name: str
+    description: str
+    input_config: Dict[str, Any]
+    output_config: Dict[str, Any]
+    preprocessing_configs: List[Dict[str, Any]]
+    postprocessing_configs: List[Dict[str, Any]]
+    has_multi_series: bool = False
+    multi_series_count: int = 0
+
+
+class MultiSeriesMFlowConverter(MFlowConverter):
+    """Enhanced converter supporting multi-series configurations"""
+    
+    def __init__(self, default_fw_path: str = "./firmware", default_assets_path: str = "./assets"):
+        """
+        Initialize enhanced converter
+        
+        Args:
+            default_fw_path: Default path for single-series firmware files
+            default_assets_path: Default path for multi-series assets folder structure
+        """
+        super().__init__(default_fw_path)
+        self.default_assets_path = default_assets_path
+        
+    def load_and_convert(self, mflow_file_path: str) -> EnhancedPipelineConfig:
+        """
+        Load .mflow file and convert to enhanced API configuration
+        
+        Args:
+            mflow_file_path: Path to the .mflow file
+            
+        Returns:
+            EnhancedPipelineConfig: Configuration supporting both single and multi-series
+        """
+        with open(mflow_file_path, 'r') as f:
+            mflow_data = json.load(f)
+            
+        return self._convert_mflow_to_enhanced_config(mflow_data)
+    
+    def _convert_mflow_to_enhanced_config(self, mflow_data: Dict[str, Any]) -> EnhancedPipelineConfig:
+        """Convert loaded .mflow data to EnhancedPipelineConfig"""
+        
+        # Extract basic metadata
+        pipeline_name = mflow_data.get('project_name', 'Enhanced Pipeline')
+        description = mflow_data.get('description', '')
+        nodes = mflow_data.get('nodes', [])
+        connections = mflow_data.get('connections', [])
+        
+        # Build node lookup and categorize nodes
+        self._build_node_map(nodes)
+        model_nodes, input_nodes, output_nodes, preprocess_nodes, postprocess_nodes = self._categorize_nodes()
+        
+        # Determine stage order based on connections
+        self._determine_stage_order(model_nodes, connections)
+        
+        # Create enhanced stage configs (supporting both single and multi-series)
+        stage_configs, has_multi_series, multi_series_count = self._create_enhanced_stage_configs(
+            model_nodes, preprocess_nodes, postprocess_nodes, connections
+        )
+        
+        # Extract input/output configurations
+        input_config = self._extract_input_config(input_nodes)
+        output_config = self._extract_output_config(output_nodes)
+        
+        # Extract preprocessing/postprocessing configurations
+        preprocessing_configs = self._extract_preprocessing_configs(preprocess_nodes)
+        postprocessing_configs = self._extract_postprocessing_configs(postprocess_nodes)
+        
+        return EnhancedPipelineConfig(
+            stage_configs=stage_configs,
+            pipeline_name=pipeline_name,
+            description=description,
+            input_config=input_config,
+            output_config=output_config,
+            preprocessing_configs=preprocessing_configs,
+            postprocessing_configs=postprocessing_configs,
+            has_multi_series=has_multi_series,
+            multi_series_count=multi_series_count
+        )
+    
+    def _create_enhanced_stage_configs(self, model_nodes: List[Dict], preprocess_nodes: List[Dict], 
+                                     postprocess_nodes: List[Dict], connections: List[Dict]
+                                     ) -> Tuple[List[Union[StageConfig, MultiSeriesStageConfig]], bool, int]:
+        """
+        Create stage configurations supporting both single and multi-series modes
+        
+        Returns:
+            Tuple of (stage_configs, has_multi_series, multi_series_count)
+        """
+        stage_configs = []
+        has_multi_series = False
+        multi_series_count = 0
+        
+        for node in self.stage_order:
+            # Extract node properties - check both 'custom_properties' and 'custom' keys for compatibility
+            node_properties = node.get('custom_properties', {})
+            if not node_properties:
+                node_properties = node.get('custom', {})
+            
+            # Check if this node is configured for multi-series mode
+            if node_properties.get('multi_series_mode', False):
+                # Create multi-series stage config
+                stage_config = self._create_multi_series_stage_config(node, preprocess_nodes, postprocess_nodes, connections)
+                stage_configs.append(stage_config)
+                has_multi_series = True
+                multi_series_count += 1
+                print(f"Created multi-series stage config for node: {node.get('name', 'Unknown')}")
+            else:
+                # Create single-series stage config (backward compatibility)
+                stage_config = self._create_single_series_stage_config(node, preprocess_nodes, postprocess_nodes, connections)
+                stage_configs.append(stage_config)
+                print(f"Created single-series stage config for node: {node.get('name', 'Unknown')}")
+        
+        return stage_configs, has_multi_series, multi_series_count
+    
+    def _create_multi_series_stage_config(self, node: Dict, preprocess_nodes: List[Dict], 
+                                        postprocess_nodes: List[Dict], connections: List[Dict]) -> MultiSeriesStageConfig:
+        """Create multi-series stage configuration from model node"""
+        
+        # Extract node properties - check both 'custom_properties' and 'custom' keys for compatibility
+        node_properties = node.get('custom_properties', {})
+        if not node_properties:
+            node_properties = node.get('custom', {})
+        
+        stage_id = node.get('name', f"stage_{node.get('id', 'unknown')}")
+        
+        # Extract assets folder and validate structure
+        assets_folder = node_properties.get('assets_folder', '')
+        if not assets_folder or not os.path.exists(assets_folder):
+            raise ValueError(f"Multi-series assets folder not found or not specified for node {stage_id}: {assets_folder}")
+        
+        # Get enabled series
+        enabled_series = node_properties.get('enabled_series', ['520', '720'])
+        if not enabled_series:
+            raise ValueError(f"No series enabled for multi-series node {stage_id}")
+        
+        # Build firmware and model paths
+        firmware_paths = {}
+        model_paths = {}
+        
+        firmware_folder = os.path.join(assets_folder, 'Firmware')
+        models_folder = os.path.join(assets_folder, 'Models')
+        
+        for series in enabled_series:
+            series_name = f'KL{series}'
+            
+            # Firmware paths
+            series_fw_folder = os.path.join(firmware_folder, series_name)
+            if os.path.exists(series_fw_folder):
+                firmware_paths[series_name] = {
+                    'scpu': os.path.join(series_fw_folder, 'fw_scpu.bin'),
+                    'ncpu': os.path.join(series_fw_folder, 'fw_ncpu.bin')
+                }
+            
+            # Model paths - find the first .nef file
+            series_model_folder = os.path.join(models_folder, series_name)
+            if os.path.exists(series_model_folder):
+                model_files = [f for f in os.listdir(series_model_folder) if f.endswith('.nef')]
+                if model_files:
+                    model_paths[series_name] = os.path.join(series_model_folder, model_files[0])
+        
+        # Validate paths
+        if not firmware_paths:
+            raise ValueError(f"No firmware found for multi-series node {stage_id} in enabled series: {enabled_series}")
+        
+        if not model_paths:
+            raise ValueError(f"No models found for multi-series node {stage_id} in enabled series: {enabled_series}")
+        
+        return MultiSeriesStageConfig(
+            stage_id=stage_id,
+            multi_series_mode=True,
+            firmware_paths=firmware_paths,
+            model_paths=model_paths,
+            max_queue_size=node_properties.get('max_queue_size', 100),
+            result_buffer_size=node_properties.get('result_buffer_size', 1000),
+            # TODO: Add preprocessor/postprocessor support if needed
+        )
+    
+    def _create_single_series_stage_config(self, node: Dict, preprocess_nodes: List[Dict], 
+                                         postprocess_nodes: List[Dict], connections: List[Dict]) -> MultiSeriesStageConfig:
+        """Create single-series stage configuration for backward compatibility"""
+        
+        # Extract node properties - check both 'custom_properties' and 'custom' keys for compatibility
+        node_properties = node.get('custom_properties', {})
+        if not node_properties:
+            node_properties = node.get('custom', {})
+        
+        stage_id = node.get('name', f"stage_{node.get('id', 'unknown')}")
+        
+        # Extract single-series paths
+        model_path = node_properties.get('model_path', '')
+        scpu_fw_path = node_properties.get('scpu_fw_path', '')
+        ncpu_fw_path = node_properties.get('ncpu_fw_path', '')
+        
+        # Validate single-series configuration
+        if not model_path:
+            raise ValueError(f"Model path required for single-series node {stage_id}")
+        
+        return MultiSeriesStageConfig(
+            stage_id=stage_id,
+            multi_series_mode=False,
+            port_ids=[],  # Will be auto-detected
+            scpu_fw_path=scpu_fw_path,
+            ncpu_fw_path=ncpu_fw_path,
+            model_path=model_path,
+            upload_fw=True if scpu_fw_path and ncpu_fw_path else False,
+            max_queue_size=node_properties.get('max_queue_size', 50),
+            # TODO: Add preprocessor/postprocessor support if needed
+        )
+    
+    def validate_enhanced_config(self, config: EnhancedPipelineConfig) -> Tuple[bool, List[str]]:
+        """
+        Validate enhanced pipeline configuration
+        
+        Returns:
+            Tuple of (is_valid, list_of_error_messages)
+        """
+        errors = []
+        
+        # Basic validation
+        if not config.stage_configs:
+            errors.append("No stages configured")
+        
+        if not config.pipeline_name:
+            errors.append("Pipeline name is required")
+        
+        # Validate each stage
+        for i, stage_config in enumerate(config.stage_configs):
+            stage_errors = self._validate_stage_config(stage_config, i)
+            errors.extend(stage_errors)
+        
+        # Multi-series specific validation
+        if config.has_multi_series:
+            multi_series_errors = self._validate_multi_series_configuration(config)
+            errors.extend(multi_series_errors)
+        
+        return len(errors) == 0, errors
+    
+    def _validate_stage_config(self, stage_config: Union[StageConfig, MultiSeriesStageConfig], stage_index: int) -> List[str]:
+        """Validate individual stage configuration"""
+        errors = []
+        stage_name = getattr(stage_config, 'stage_id', f'Stage {stage_index}')
+        
+        if isinstance(stage_config, MultiSeriesStageConfig):
+            if stage_config.multi_series_mode:
+                # Validate multi-series configuration
+                if not stage_config.firmware_paths:
+                    errors.append(f"{stage_name}: No firmware paths configured for multi-series mode")
+                
+                if not stage_config.model_paths:
+                    errors.append(f"{stage_name}: No model paths configured for multi-series mode")
+                
+                # Validate file existence
+                for series_name, fw_paths in (stage_config.firmware_paths or {}).items():
+                    scpu_path = fw_paths.get('scpu')
+                    ncpu_path = fw_paths.get('ncpu')
+                    
+                    if not scpu_path or not os.path.exists(scpu_path):
+                        errors.append(f"{stage_name}: SCPU firmware not found for {series_name}: {scpu_path}")
+                    
+                    if not ncpu_path or not os.path.exists(ncpu_path):
+                        errors.append(f"{stage_name}: NCPU firmware not found for {series_name}: {ncpu_path}")
+                
+                for series_name, model_path in (stage_config.model_paths or {}).items():
+                    if not model_path or not os.path.exists(model_path):
+                        errors.append(f"{stage_name}: Model not found for {series_name}: {model_path}")
+            else:
+                # Validate single-series configuration
+                if not stage_config.model_path:
+                    errors.append(f"{stage_name}: Model path is required for single-series mode")
+                elif not os.path.exists(stage_config.model_path):
+                    errors.append(f"{stage_name}: Model file not found: {stage_config.model_path}")
+        
+        return errors
+    
+    def _validate_multi_series_configuration(self, config: EnhancedPipelineConfig) -> List[str]:
+        """Validate multi-series specific requirements"""
+        errors = []
+        
+        # Check for mixed configurations
+        single_series_count = len(config.stage_configs) - config.multi_series_count
+        
+        if config.multi_series_count > 0 and single_series_count > 0:
+            # Mixed pipeline - add warning
+            print(f"Warning: Mixed pipeline detected - {config.multi_series_count} multi-series stages and {single_series_count} single-series stages")
+        
+        # Additional multi-series validations can be added here
+        
+        return errors
+    
+    def create_enhanced_inference_pipeline(self, config: EnhancedPipelineConfig) -> Union[MultiSeriesInferencePipeline, 'InferencePipeline']:
+        """
+        Create appropriate inference pipeline based on configuration
+        
+        Returns:
+            MultiSeriesInferencePipeline if multi-series stages detected, otherwise regular InferencePipeline
+        """
+        if config.has_multi_series:
+            print(f"Creating MultiSeriesInferencePipeline with {config.multi_series_count} multi-series stages")
+            return MultiSeriesInferencePipeline(
+                stage_configs=config.stage_configs,
+                pipeline_name=config.pipeline_name
+            )
+        else:
+            print("Creating standard InferencePipeline (single-series only)")
+            # Convert to standard StageConfig objects for backward compatibility
+            from .InferencePipeline import InferencePipeline
+            standard_configs = []
+            
+            for stage_config in config.stage_configs:
+                if isinstance(stage_config, MultiSeriesStageConfig) and not stage_config.multi_series_mode:
+                    # Convert to standard StageConfig
+                    standard_config = StageConfig(
+                        stage_id=stage_config.stage_id,
+                        port_ids=stage_config.port_ids or [],
+                        scpu_fw_path=stage_config.scpu_fw_path or '',
+                        ncpu_fw_path=stage_config.ncpu_fw_path or '',
+                        model_path=stage_config.model_path or '',
+                        upload_fw=stage_config.upload_fw,
+                        max_queue_size=stage_config.max_queue_size
+                    )
+                    standard_configs.append(standard_config)
+            
+            return InferencePipeline(
+                stage_configs=standard_configs,
+                pipeline_name=config.pipeline_name
+            )
+
+
+def create_assets_folder_structure(base_path: str, series_list: List[str] = None):
+    """
+    Create the recommended folder structure for multi-series assets
+    
+    Args:
+        base_path: Root path where assets folder should be created
+        series_list: List of series to create folders for (default: ['520', '720', '630', '730', '540'])
+    """
+    if series_list is None:
+        series_list = ['520', '720', '630', '730', '540']
+    
+    assets_path = os.path.join(base_path, 'Assets')
+    firmware_path = os.path.join(assets_path, 'Firmware')
+    models_path = os.path.join(assets_path, 'Models')
+    
+    # Create main directories
+    os.makedirs(firmware_path, exist_ok=True)
+    os.makedirs(models_path, exist_ok=True)
+    
+    # Create series-specific directories
+    for series in series_list:
+        series_name = f'KL{series}'
+        os.makedirs(os.path.join(firmware_path, series_name), exist_ok=True)
+        os.makedirs(os.path.join(models_path, series_name), exist_ok=True)
+    
+    # Create README file explaining the structure
+    readme_content = """
+# Multi-Series Assets Folder Structure
+
+This folder contains firmware and models organized by dongle series for multi-series inference.
+
+## Structure:
+```
+Assets/
+├── Firmware/
+│   ├── KL520/
+│   │   ├── fw_scpu.bin
+│   │   └── fw_ncpu.bin
+│   ├── KL720/
+│   │   ├── fw_scpu.bin
+│   │   └── fw_ncpu.bin
+│   └── [other series...]
+└── Models/
+    ├── KL520/
+    │   └── [model.nef files]
+    ├── KL720/
+    │   └── [model.nef files]
+    └── [other series...]
+```
+
+## Usage:
+1. Place firmware files (fw_scpu.bin, fw_ncpu.bin) in the appropriate series subfolder under Firmware/
+2. Place model files (.nef) in the appropriate series subfolder under Models/
+3. Configure your model node to use this Assets folder in multi-series mode
+4. Select which series to enable in the model node properties
+
+## Supported Series:
+- KL520: Entry-level performance
+- KL720: Mid-range performance
+- KL630: High performance
+- KL730: Very high performance  
+- KL540: Specialized performance
+
+The multi-series system will automatically load balance inference across all enabled series
+based on their GOPS capacity for optimal performance.
+"""
+    
+    with open(os.path.join(assets_path, 'README.md'), 'w') as f:
+        f.write(readme_content.strip())
+    
+    print(f"Multi-series assets folder structure created at: {assets_path}")
+    print("Please copy your firmware and model files to the appropriate series subfolders.")

core/functions/multi_series_pipeline.py

@@ -0,0 +1,433 @@
+"""
+Multi-Series Inference Pipeline
+
+This module extends the InferencePipeline to support multi-series dongle configurations
+using the MultiSeriesDongleManager for improved performance across different dongle series.
+
+Main Components:
+    - MultiSeriesPipelineStage: Pipeline stage supporting both single and multi-series modes
+    - Enhanced InferencePipeline with multi-series support
+    - Configuration adapters for seamless integration
+
+Usage:
+    from core.functions.multi_series_pipeline import MultiSeriesInferencePipeline
+    
+    # Multi-series configuration
+    config = MultiSeriesStageConfig(
+        stage_id="detection",
+        multi_series_mode=True,
+        firmware_paths={"KL520": {"scpu": "...", "ncpu": "..."}, ...},
+        model_paths={"KL520": "...", "KL720": "..."}
+    )
+"""
+
+from typing import List, Dict, Any, Optional, Callable, Union
+import threading
+import queue
+import time
+import traceback
+import numpy as np
+from dataclasses import dataclass
+
+# Import existing pipeline components
+from .InferencePipeline import (
+    PipelineData, InferencePipeline, PreProcessor, PostProcessor, DataProcessor
+)
+from .Multidongle import MultiDongle
+
+# Import multi-series manager
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+from multi_series_dongle_manager import MultiSeriesDongleManager
+
+
+@dataclass
+class MultiSeriesStageConfig:
+    """Enhanced configuration for multi-series pipeline stages"""
+    stage_id: str
+    max_queue_size: int = 100
+    
+    # Multi-series mode configuration
+    multi_series_mode: bool = False
+    firmware_paths: Optional[Dict[str, Dict[str, str]]] = None  # {"KL520": {"scpu": path, "ncpu": path}}
+    model_paths: Optional[Dict[str, str]] = None  # {"KL520": model_path, "KL720": model_path}
+    result_buffer_size: int = 1000
+    
+    # Single-series mode configuration (backward compatibility)
+    port_ids: Optional[List[int]] = None
+    scpu_fw_path: Optional[str] = None
+    ncpu_fw_path: Optional[str] = None
+    model_path: Optional[str] = None
+    upload_fw: bool = False
+    
+    # Processing configuration
+    input_preprocessor: Optional[PreProcessor] = None
+    output_postprocessor: Optional[PostProcessor] = None
+    stage_preprocessor: Optional[PreProcessor] = None
+    stage_postprocessor: Optional[PostProcessor] = None
+
+
+class MultiSeriesPipelineStage:
+    """Enhanced pipeline stage supporting both single and multi-series modes"""
+    
+    def __init__(self, config: MultiSeriesStageConfig):
+        self.config = config
+        self.stage_id = config.stage_id
+        
+        # Initialize inference engine based on mode
+        if config.multi_series_mode:
+            # Multi-series mode using MultiSeriesDongleManager
+            self.inference_engine = MultiSeriesDongleManager(
+                max_queue_size=config.max_queue_size,
+                result_buffer_size=config.result_buffer_size
+            )
+            self.is_multi_series = True
+        else:
+            # Single-series mode using MultiDongle (backward compatibility)
+            self.inference_engine = MultiDongle(
+                port_id=config.port_ids or [],
+                scpu_fw_path=config.scpu_fw_path or "",
+                ncpu_fw_path=config.ncpu_fw_path or "",
+                model_path=config.model_path or "",
+                upload_fw=config.upload_fw,
+                max_queue_size=config.max_queue_size
+            )
+            self.is_multi_series = False
+        
+        # Store processors
+        self.input_preprocessor = config.input_preprocessor
+        self.output_postprocessor = config.output_postprocessor
+        
+        # Threading for this stage
+        self.input_queue = queue.Queue(maxsize=config.max_queue_size)
+        self.output_queue = queue.Queue(maxsize=config.max_queue_size)
+        self.worker_thread = None
+        self.running = False
+        self._stop_event = threading.Event()
+        
+        # Statistics
+        self.processed_count = 0
+        self.error_count = 0
+        self.processing_times = []
+        
+    def initialize(self):
+        """Initialize the stage"""
+        print(f"[Stage {self.stage_id}] Initializing {'multi-series' if self.is_multi_series else 'single-series'} mode...")
+        
+        try:
+            if self.is_multi_series:
+                # Initialize multi-series manager
+                if not self.inference_engine.scan_and_initialize_devices(
+                    self.config.firmware_paths,
+                    self.config.model_paths
+                ):
+                    raise RuntimeError("Failed to initialize multi-series dongles")
+                print(f"[Stage {self.stage_id}] Multi-series dongles initialized successfully")
+            else:
+                # Initialize single-series MultiDongle
+                self.inference_engine.initialize()
+                print(f"[Stage {self.stage_id}] Single-series dongle initialized successfully")
+                
+        except Exception as e:
+            print(f"[Stage {self.stage_id}] Initialization failed: {e}")
+            raise
+    
+    def start(self):
+        """Start the stage worker thread"""
+        if self.worker_thread and self.worker_thread.is_alive():
+            return
+            
+        self.running = True
+        self._stop_event.clear()
+        
+        # Start inference engine
+        if self.is_multi_series:
+            self.inference_engine.start()
+        else:
+            self.inference_engine.start()
+            
+        # Start worker thread
+        self.worker_thread = threading.Thread(target=self._worker_loop, daemon=True)
+        self.worker_thread.start()
+        print(f"[Stage {self.stage_id}] Worker thread started")
+    
+    def stop(self):
+        """Stop the stage gracefully"""
+        print(f"[Stage {self.stage_id}] Stopping...")
+        self.running = False
+        self._stop_event.set()
+        
+        # Put sentinel to unblock worker
+        try:
+            self.input_queue.put(None, timeout=1.0)
+        except queue.Full:
+            pass
+            
+        # Wait for worker thread
+        if self.worker_thread and self.worker_thread.is_alive():
+            self.worker_thread.join(timeout=3.0)
+            
+        # Stop inference engine
+        if self.is_multi_series:
+            self.inference_engine.stop()
+        else:
+            self.inference_engine.stop()
+        print(f"[Stage {self.stage_id}] Stopped")
+    
+    def _worker_loop(self):
+        """Main worker loop for processing data"""
+        print(f"[Stage {self.stage_id}] Worker loop started")
+        
+        while self.running and not self._stop_event.is_set():
+            try:
+                # Get input data
+                try:
+                    pipeline_data = self.input_queue.get(timeout=1.0)
+                    if pipeline_data is None:  # Sentinel value
+                        continue
+                except queue.Empty:
+                    if self._stop_event.is_set():
+                        break
+                    continue
+                
+                start_time = time.time()
+                
+                # Process data through this stage
+                processed_data = self._process_data(pipeline_data)
+                
+                # Only count and record timing for actual inference results
+                if processed_data and self._has_inference_result(processed_data):
+                    processing_time = time.time() - start_time
+                    self.processing_times.append(processing_time)
+                    if len(self.processing_times) > 1000:
+                        self.processing_times = self.processing_times[-500:]
+                    
+                    self.processed_count += 1
+                
+                # Put result to output queue
+                try:
+                    self.output_queue.put(processed_data, block=False)
+                except queue.Full:
+                    # Drop oldest and add new
+                    try:
+                        self.output_queue.get_nowait()
+                        self.output_queue.put(processed_data, block=False)
+                    except queue.Empty:
+                        pass
+                        
+            except Exception as e:
+                self.error_count += 1
+                print(f"[Stage {self.stage_id}] Processing error: {e}")
+                traceback.print_exc()
+                
+        print(f"[Stage {self.stage_id}] Worker loop stopped")
+    
+    def _has_inference_result(self, processed_data) -> bool:
+        """Check if processed_data contains a valid inference result"""
+        if not processed_data:
+            return False
+        
+        try:
+            if hasattr(processed_data, 'stage_results') and processed_data.stage_results:
+                stage_result = processed_data.stage_results.get(self.stage_id)
+                if stage_result:
+                    if isinstance(stage_result, tuple) and len(stage_result) == 2:
+                        prob, result_str = stage_result
+                        return prob is not None and result_str is not None and result_str != 'Processing'
+                    elif isinstance(stage_result, dict):
+                        if stage_result.get("status") in ["processing", "async"]:
+                            return False
+                        if stage_result.get("result") == "Processing":
+                            return False
+                        return True
+                    else:
+                        return stage_result is not None
+        except Exception:
+            pass
+            
+        return False
+    
+    def _process_data(self, pipeline_data: PipelineData) -> PipelineData:
+        """Process data through this stage"""
+        try:
+            current_data = pipeline_data.data
+            
+            # Step 1: Input preprocessing (inter-stage)
+            if self.input_preprocessor and isinstance(current_data, np.ndarray):
+                if self.is_multi_series:
+                    # For multi-series, we may need different preprocessing
+                    current_data = self.input_preprocessor.process(current_data, (640, 640), 'BGR565')
+                else:
+                    current_data = self.input_preprocessor.process(
+                        current_data, 
+                        self.inference_engine.model_input_shape, 
+                        'BGR565'
+                    )
+            
+            # Step 2: Inference
+            inference_result = None
+            
+            if isinstance(current_data, np.ndarray) and len(current_data.shape) == 3:
+                if self.is_multi_series:
+                    # Multi-series inference
+                    sequence_id = self.inference_engine.put_input(current_data, 'BGR565')
+                    
+                    # Try to get result (non-blocking for async processing)
+                    result = self.inference_engine.get_result(timeout=0.1)
+                    
+                    if result is not None:
+                        # Extract actual inference data from MultiSeriesDongleManager result
+                        if hasattr(result, 'result') and result.result:
+                            if isinstance(result.result, tuple) and len(result.result) == 2:
+                                inference_result = result.result
+                            else:
+                                inference_result = result.result
+                        else:
+                            inference_result = {'probability': 0.0, 'result': 'Processing', 'status': 'async'}
+                    else:
+                        inference_result = {'probability': 0.0, 'result': 'Processing', 'status': 'async'}
+                        
+                else:
+                    # Single-series inference (existing behavior)
+                    processed_data = self.inference_engine.preprocess_frame(current_data, 'BGR565')
+                    if processed_data is not None:
+                        self.inference_engine.put_input(processed_data, 'BGR565')
+                    
+                    # Get inference result
+                    result = self.inference_engine.get_latest_inference_result()
+                    
+                    if result is not None:
+                        if isinstance(result, tuple) and len(result) == 2:
+                            inference_result = result
+                        elif isinstance(result, dict) and result:
+                            inference_result = result
+                        else:
+                            inference_result = result
+                    else:
+                        inference_result = {'probability': 0.0, 'result': 'Processing', 'status': 'async'}
+            
+            # Step 3: Update pipeline data
+            if not inference_result:
+                inference_result = {'probability': 0.0, 'result': 'Processing', 'status': 'async'}
+                
+            pipeline_data.stage_results[self.stage_id] = inference_result
+            pipeline_data.data = inference_result
+            pipeline_data.metadata[f'{self.stage_id}_timestamp'] = time.time()
+            
+            return pipeline_data
+            
+        except Exception as e:
+            print(f"[Stage {self.stage_id}] Data processing error: {e}")
+            pipeline_data.stage_results[self.stage_id] = {
+                'error': str(e),
+                'probability': 0.0,
+                'result': 'Processing Error'
+            }
+            return pipeline_data
+    
+    def put_data(self, data: PipelineData, timeout: float = 1.0) -> bool:
+        """Put data into this stage's input queue"""
+        try:
+            self.input_queue.put(data, timeout=timeout)
+            return True
+        except queue.Full:
+            return False
+    
+    def get_result(self, timeout: float = 0.1) -> Optional[PipelineData]:
+        """Get result from this stage's output queue"""
+        try:
+            return self.output_queue.get(timeout=timeout)
+        except queue.Empty:
+            return None
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get stage statistics"""
+        avg_processing_time = (
+            sum(self.processing_times) / len(self.processing_times) 
+            if self.processing_times else 0.0
+        )
+        
+        # Get engine-specific statistics
+        if self.is_multi_series:
+            engine_stats = self.inference_engine.get_statistics()
+        else:
+            engine_stats = self.inference_engine.get_statistics()
+        
+        return {
+            'stage_id': self.stage_id,
+            'mode': 'multi-series' if self.is_multi_series else 'single-series',
+            'processed_count': self.processed_count,
+            'error_count': self.error_count,
+            'avg_processing_time': avg_processing_time,
+            'input_queue_size': self.input_queue.qsize(),
+            'output_queue_size': self.output_queue.qsize(),
+            'engine_stats': engine_stats
+        }
+
+
+class MultiSeriesInferencePipeline(InferencePipeline):
+    """Enhanced inference pipeline with multi-series support"""
+    
+    def __init__(self, stage_configs: List[MultiSeriesStageConfig], 
+                 final_postprocessor: Optional[PostProcessor] = None,
+                 pipeline_name: str = "MultiSeriesInferencePipeline"):
+        """
+        Initialize multi-series inference pipeline
+        """
+        self.pipeline_name = pipeline_name
+        self.stage_configs = stage_configs
+        self.final_postprocessor = final_postprocessor
+        
+        # Create enhanced stages
+        self.stages: List[MultiSeriesPipelineStage] = []
+        for config in stage_configs:
+            stage = MultiSeriesPipelineStage(config)
+            self.stages.append(stage)
+        
+        # Initialize other components from parent class
+        self.coordinator_thread = None
+        self.running = False
+        self._stop_event = threading.Event()
+        
+        self.pipeline_input_queue = queue.Queue(maxsize=100)
+        self.pipeline_output_queue = queue.Queue(maxsize=100)
+        
+        self.result_callback = None
+        self.error_callback = None
+        self.stats_callback = None
+        
+        self.pipeline_counter = 0
+        self.completed_counter = 0
+        self.error_counter = 0
+        
+        self.fps_start_time = None
+        self.fps_lock = threading.Lock()
+
+
+def create_multi_series_config_from_model_node(model_config: Dict[str, Any]) -> MultiSeriesStageConfig:
+    """
+    Create MultiSeriesStageConfig from model node configuration
+    """
+    if model_config.get('multi_series_mode', False):
+        # Multi-series configuration
+        return MultiSeriesStageConfig(
+            stage_id=model_config.get('node_name', 'inference_stage'),
+            multi_series_mode=True,
+            firmware_paths=model_config.get('firmware_paths'),
+            model_paths=model_config.get('model_paths'),
+            max_queue_size=model_config.get('max_queue_size', 100),
+            result_buffer_size=model_config.get('result_buffer_size', 1000)
+        )
+    else:
+        # Single-series configuration (backward compatibility)
+        return MultiSeriesStageConfig(
+            stage_id=model_config.get('node_name', 'inference_stage'),
+            multi_series_mode=False,
+            port_ids=[],  # Will be auto-detected
+            scpu_fw_path=model_config.get('scpu_fw_path'),
+            ncpu_fw_path=model_config.get('ncpu_fw_path'),
+            model_path=model_config.get('model_path'),
+            upload_fw=True,
+            max_queue_size=model_config.get('max_queue_size', 50)
+        )

core/functions/yolo_v5_postprocess_reference.py

@@ -1,146 +0,0 @@
-import numpy as np
-
-# Constants based on Kneron example_utils implementation
-YOLO_V3_CELL_BOX_NUM = 3
-YOLO_V5_ANCHORS = np.array([
-    [[10, 13], [16, 30], [33, 23]],
-    [[30, 61], [62, 45], [59, 119]],
-    [[116, 90], [156, 198], [373, 326]]
-])
-NMS_THRESH_YOLOV5 = 0.5
-YOLO_MAX_DETECTION_PER_CLASS = 100
-
-
-def _sigmoid(x):
-    return 1.0 / (1.0 + np.exp(-x))
-
-
-def _iou(box_src, boxes_dst):
-    max_x1 = np.maximum(box_src[0], boxes_dst[:, 0])
-    max_y1 = np.maximum(box_src[1], boxes_dst[:, 1])
-    min_x2 = np.minimum(box_src[2], boxes_dst[:, 2])
-    min_y2 = np.minimum(box_src[3], boxes_dst[:, 3])
-
-    area_intersection = np.maximum(0, (min_x2 - max_x1)) * np.maximum(0, (min_y2 - max_y1))
-    area_src = (box_src[2] - box_src[0]) * (box_src[3] - box_src[1])
-    area_dst = (boxes_dst[:, 2] - boxes_dst[:, 0]) * (boxes_dst[:, 1] - boxes_dst[:, 1] + (boxes_dst[:, 3] - boxes_dst[:, 1]))
-    # Correct dst area computation
-    area_dst = (boxes_dst[:, 2] - boxes_dst[:, 0]) * (boxes_dst[:, 3] - boxes_dst[:, 1])
-    area_union = area_src + area_dst - area_intersection
-    iou = area_intersection / np.maximum(area_union, 1e-6)
-    return iou
-
-
-def _boxes_scale(boxes, hw):
-    """Rollback padding and scale to original image size using HwPreProcInfo."""
-    ratio_w = hw.img_width / max(1, float(getattr(hw, 'resized_img_width', hw.img_width)))
-    ratio_h = hw.img_height / max(1, float(getattr(hw, 'resized_img_height', hw.img_height)))
-
-    pad_left = int(getattr(hw, 'pad_left', 0))
-    pad_top = int(getattr(hw, 'pad_top', 0))
-
-    boxes[..., :4] = boxes[..., :4] - np.array([pad_left, pad_top, pad_left, pad_top])
-    boxes[..., :4] = boxes[..., :4] * np.array([ratio_w, ratio_h, ratio_w, ratio_h])
-    return boxes
-
-
-def post_process_yolo_v5_reference(inf_list, hw_preproc_info, thresh_value=0.5):
-    """
-    Reference YOLOv5 postprocess copied and adapted from Kneron example_utils.
-
-    Args:
-        inf_list: list of outputs; each item has .ndarray or is ndarray of shape [1, 255, H, W]
-        hw_preproc_info: kp.HwPreProcInfo providing model input and resize/pad info
-        thresh_value: confidence threshold (0.0~1.0)
-
-    Returns:
-        List of tuples: (x1, y1, x2, y2, score, class_num)
-    """
-    feature_map_list = []
-    candidate_boxes_list = []
-
-    for i in range(len(inf_list)):
-        arr = inf_list[i].ndarray if hasattr(inf_list[i], 'ndarray') else inf_list[i]
-        # Expect shape [1, 255, H, W]
-        anchor_offset = int(arr.shape[1] / YOLO_V3_CELL_BOX_NUM)
-        feature_map = arr.transpose((0, 2, 3, 1))
-        feature_map = _sigmoid(feature_map)
-        feature_map = feature_map.reshape((feature_map.shape[0],
-                                           feature_map.shape[1],
-                                           feature_map.shape[2],
-                                           YOLO_V3_CELL_BOX_NUM,
-                                           anchor_offset))
-
-        # ratio based on model input vs output grid size
-        ratio_w = float(getattr(hw_preproc_info, 'model_input_width', arr.shape[3])) / arr.shape[3]
-        ratio_h = float(getattr(hw_preproc_info, 'model_input_height', arr.shape[2])) / arr.shape[2]
-        nrows = arr.shape[2]
-        ncols = arr.shape[3]
-        grids = np.expand_dims(np.stack(np.meshgrid(np.arange(ncols), np.arange(nrows)), 2), axis=0)
-
-        for anchor_idx in range(YOLO_V3_CELL_BOX_NUM):
-            feature_map[..., anchor_idx, 0:2] = (feature_map[..., anchor_idx, 0:2] * 2. - 0.5 + grids) * np.array(
-                [ratio_h, ratio_w])
-            feature_map[..., anchor_idx, 2:4] = (feature_map[..., anchor_idx, 2:4] * 2) ** 2 * YOLO_V5_ANCHORS[i][anchor_idx]
-
-            # Convert to (x1,y1,x2,y2)
-            feature_map[..., anchor_idx, 0:2] = feature_map[..., anchor_idx, 0:2] - (feature_map[..., anchor_idx, 2:4] / 2.)
-            feature_map[..., anchor_idx, 2:4] = feature_map[..., anchor_idx, 0:2] + feature_map[..., anchor_idx, 2:4]
-
-        # Rollback padding and resize to original img size
-        feature_map = _boxes_scale(boxes=feature_map, hw=hw_preproc_info)
-        feature_map_list.append(feature_map)
-
-    # Concatenate and apply objectness * class prob
-    predict_bboxes = np.concatenate(
-        [np.reshape(fm, (-1, fm.shape[-1])) for fm in feature_map_list], axis=0)
-    predict_bboxes[..., 5:] = np.repeat(predict_bboxes[..., 4][..., np.newaxis],
-                                        predict_bboxes[..., 5:].shape[1], axis=1) * predict_bboxes[..., 5:]
-    predict_bboxes_mask = (predict_bboxes[..., 5:] > thresh_value).sum(axis=1)
-    predict_bboxes = predict_bboxes[predict_bboxes_mask >= 1]
-
-    # Per-class NMS
-    H = int(getattr(hw_preproc_info, 'img_height', 0))
-    W = int(getattr(hw_preproc_info, 'img_width', 0))
-
-    for class_idx in range(5, predict_bboxes.shape[1]):
-        candidate_boxes_mask = predict_bboxes[..., class_idx] > thresh_value
-        class_good_box_count = int(candidate_boxes_mask.sum())
-        if class_good_box_count == 1:
-            bb = predict_bboxes[candidate_boxes_mask][0]
-            candidate_boxes_list.append((
-                int(max(0, min(bb[0] + 0.5, W - 1))),
-                int(max(0, min(bb[1] + 0.5, H - 1))),
-                int(max(0, min(bb[2] + 0.5, W - 1))),
-                int(max(0, min(bb[3] + 0.5, H - 1))),
-                float(bb[class_idx]),
-                class_idx - 5
-            ))
-        elif class_good_box_count > 1:
-            candidate_boxes = predict_bboxes[candidate_boxes_mask].copy()
-            candidate_boxes = candidate_boxes[candidate_boxes[:, class_idx].argsort()][::-1]
-
-            for candidate_box_idx in range(candidate_boxes.shape[0] - 1):
-                if candidate_boxes[candidate_box_idx][class_idx] != 0:
-                    ious = _iou(candidate_boxes[candidate_box_idx], candidate_boxes[candidate_box_idx + 1:])
-                    remove_mask = ious > NMS_THRESH_YOLOV5
-                    candidate_boxes[candidate_box_idx + 1:][remove_mask, class_idx] = 0
-
-            good_count = 0
-            for candidate_box_idx in range(candidate_boxes.shape[0]):
-                if candidate_boxes[candidate_box_idx, class_idx] > 0:
-                    bb = candidate_boxes[candidate_box_idx]
-                    candidate_boxes_list.append((
-                        int(max(0, min(bb[0] + 0.5, W - 1))),
-                        int(max(0, min(bb[1] + 0.5, H - 1))),
-                        int(max(0, min(bb[2] + 0.5, W - 1))),
-                        int(max(0, min(bb[3] + 0.5, H - 1))),
-                        float(bb[class_idx]),
-                        class_idx - 5
-                    ))
-                    good_count += 1
-                    if good_count == YOLO_MAX_DETECTION_PER_CLASS:
-                        break
-
-    return candidate_boxes_list
-

core/nodes/exact_nodes.py

@@ -5,18 +5,37 @@ This module provides node implementations that exactly match the original
 properties and behavior from the monolithic UI.py file.
 """
 
-import os
-
 try:
     from NodeGraphQt import BaseNode
     NODEGRAPH_AVAILABLE = True
 except ImportError:
     NODEGRAPH_AVAILABLE = False
-    # Create a mock base class
+    # Create a mock base class with property support
     class BaseNode:
         def __init__(self):
+            self._properties = {}
+        
+        def create_property(self, name, value):
+            self._properties[name] = value
+        
+        def set_property(self, name, value):
+            self._properties[name] = value
+        
+        def get_property(self, name):
+            return self._properties.get(name, None)
+        
+        def add_input(self, *args, **kwargs):
             pass
         
+        def add_output(self, *args, **kwargs):
+            pass
+        
+        def set_color(self, *args, **kwargs):
+            pass
+        
+        def name(self):
+            return getattr(self, 'NODE_NAME', 'Unknown Node')
+
 
 class ExactInputNode(BaseNode):
     """Input data source node - exact match to original."""
@@ -75,9 +94,6 @@ class ExactInputNode(BaseNode):
     
     def get_business_properties(self):
         """Get all business properties for serialization."""
-        if not NODEGRAPH_AVAILABLE:
-            return {}
-        
         properties = {}
         for prop_name in self._property_options.keys():
             try:
@@ -102,75 +118,51 @@ class ExactModelNode(BaseNode):
     def __init__(self):
         super().__init__()
         
+        # Setup node connections (NodeGraphQt specific)
         if NODEGRAPH_AVAILABLE:
-            # Setup node connections - exact match
             self.add_input('input', multi_input=False, color=(255, 140, 0))
             self.add_output('output', color=(0, 255, 0))
             self.set_color(65, 84, 102)
         
-            # Original properties - exact match
-            self.create_property('model_path', '')
-            self.create_property('scpu_fw_path', '')
-            self.create_property('ncpu_fw_path', '')
-            self.create_property('dongle_series', '520')
-            self.create_property('num_dongles', 1)
-            self.create_property('port_id', '')
-            self.create_property('upload_fw', True)
+        # Create properties (always, regardless of NodeGraphQt availability)
+        self.create_property('multi_series_mode', False)
         
+        # Multi-series properties
+        self.create_property('assets_folder', '')
+        self.create_property('enabled_series', ['520', '720'])
+        self.create_property('port_mapping', {})
+        
+        # Single-series properties (original)
+        self.create_property('model_path', '')
+        self.create_property('scpu_fw_path', '')
+        self.create_property('ncpu_fw_path', '')
+        self.create_property('dongle_series', '520')
+        self.create_property('num_dongles', 1)
+        self.create_property('port_id', '')
+        self.create_property('upload_fw', True)
+        
+        # Property options with multi-series support (always available)
+        self._property_options = {
             # Multi-series properties
-            self.create_property('multi_series_mode', False)
-            self.create_property('assets_folder', '')
-            self.create_property('enabled_series', ['520', '720'])
+            'multi_series_mode': {'type': 'bool', 'default': False, 'description': 'Enable multi-series dongle support'},
+            'assets_folder': {'type': 'file_path', 'filter': 'Directories', 'mode': 'directory'},
+            'enabled_series': ['520', '720', '630', '730', '540'],
+            'port_mapping': {'type': 'dict', 'description': 'Port ID to series mapping'},
             
-            # Series-specific port ID configurations
-            self.create_property('kl520_port_ids', '')
-            self.create_property('kl720_port_ids', '')
-            self.create_property('kl630_port_ids', '')
-            self.create_property('kl730_port_ids', '')
-            # self.create_property('kl540_port_ids', '')
+            # Single-series properties (original)
+            'dongle_series': ['520', '720', '1080', 'Custom'],
+            'num_dongles': {'min': 1, 'max': 16},
+            'model_path': {'type': 'file_path', 'filter': 'NEF Model files (*.nef)'},
+            'scpu_fw_path': {'type': 'file_path', 'filter': 'SCPU Firmware files (*.bin)'},
+            'ncpu_fw_path': {'type': 'file_path', 'filter': 'NCPU Firmware files (*.bin)'},
+            'port_id': {'placeholder': 'e.g., 8080 or auto'},
+            'upload_fw': {'type': 'bool', 'default': True, 'description': 'Upload firmware to dongle if needed'}
+        }
         
-            self.create_property('max_queue_size', 100)
-            self.create_property('result_buffer_size', 1000)
-            self.create_property('batch_size', 1)
-            self.create_property('enable_preprocessing', False)
-            self.create_property('enable_postprocessing', False)
-            
-            # Original property options - exact match
-            self._property_options = {
-                'dongle_series': ['520', '720'],
-                'num_dongles': {'min': 1, 'max': 16},
-                'model_path': {'type': 'file_path', 'filter': 'NEF Model files (*.nef)'},
-                'scpu_fw_path': {'type': 'file_path', 'filter': 'SCPU Firmware files (*.bin)'},
-                'ncpu_fw_path': {'type': 'file_path', 'filter': 'NCPU Firmware files (*.bin)'},
-                'port_id': {'placeholder': 'e.g., 8080 or auto'},
-                'upload_fw': {'type': 'bool', 'default': True, 'description': 'Upload firmware to dongle if needed'},
-                
-                # Multi-series property options
-                'multi_series_mode': {'type': 'bool', 'default': False, 'description': 'Enable multi-series dongle support'},
-                'assets_folder': {'type': 'file_path', 'filter': 'Folder', 'mode': 'directory'},
-                'enabled_series': {'type': 'list', 'options': ['520', '720', '630', '730', '540'], 'default': ['520', '720']},
-                
-                # Series-specific port ID options
-                'kl520_port_ids': {'placeholder': 'e.g., 28,32 (comma-separated port IDs for KL520)', 'description': 'Port IDs for KL520 dongles'},
-                'kl720_port_ids': {'placeholder': 'e.g., 30,34 (comma-separated port IDs for KL720)', 'description': 'Port IDs for KL720 dongles'},
-                'kl630_port_ids': {'placeholder': 'e.g., 36,38 (comma-separated port IDs for KL630)', 'description': 'Port IDs for KL630 dongles'},
-                'kl730_port_ids': {'placeholder': 'e.g., 40,42 (comma-separated port IDs for KL730)', 'description': 'Port IDs for KL730 dongles'},
-                # 'kl540_port_ids': {'placeholder': 'e.g., 44,46 (comma-separated port IDs for KL540)', 'description': 'Port IDs for KL540 dongles'},
-
-                'max_queue_size': {'min': 1, 'max': 1000, 'default': 100},
-                'result_buffer_size': {'min': 100, 'max': 10000, 'default': 1000},
-                'batch_size': {'min': 1, 'max': 32, 'default': 1},
-                'enable_preprocessing': {'type': 'bool', 'default': False},
-                'enable_postprocessing': {'type': 'bool', 'default': False}
-            }
-            
-            # Create custom properties dictionary for UI compatibility
+        # Create custom properties dictionary for UI compatibility (NodeGraphQt specific)
+        if NODEGRAPH_AVAILABLE:
             self._populate_custom_properties()
     
-            # Set up custom property handlers for folder selection
-            if NODEGRAPH_AVAILABLE:
-                self._setup_custom_property_handlers()
-    
     def _populate_custom_properties(self):
         """Populate the custom properties dictionary for UI compatibility."""
         if not NODEGRAPH_AVAILABLE:
@@ -195,9 +187,6 @@ class ExactModelNode(BaseNode):
     
     def get_business_properties(self):
         """Get all business properties for serialization."""
-        if not NODEGRAPH_AVAILABLE:
-            return {}
-        
         properties = {}
         for prop_name in self._property_options.keys():
             try:
@@ -208,400 +197,19 @@ class ExactModelNode(BaseNode):
     
     def get_display_properties(self):
         """Return properties that should be displayed in the UI panel."""
-        if not NODEGRAPH_AVAILABLE:
-            return []
-        
-        # Base properties that are always shown
-        base_props = ['multi_series_mode']
-        
+        # Check if multi-series mode is enabled
+        multi_series_enabled = False
         try:
-            # Check if we're in multi-series mode
-            multi_series_mode = self.get_property('multi_series_mode')
-            
-            if multi_series_mode:
-                # Multi-series mode: show multi-series specific properties
-                multi_props = ['assets_folder', 'enabled_series']
-                
-                # Add port ID configurations for enabled series
-                try:
-                    enabled_series = self.get_property('enabled_series') or []
-                    for series in enabled_series:
-                        port_prop = f'kl{series}_port_ids'
-                        if port_prop not in multi_props:  # Avoid duplicates
-                            multi_props.append(port_prop)
-                except:
-                    pass  # If can't get enabled_series, just show basic properties
-                
-                # Add other multi-series properties
-                multi_props.extend([
-                    'max_queue_size', 'result_buffer_size', 'batch_size',
-                    'enable_preprocessing', 'enable_postprocessing'
-                ])
-                
-                return base_props + multi_props
-            else:
-                # Single-series mode: show traditional properties
-                return base_props + [
-                    'model_path', 'scpu_fw_path', 'ncpu_fw_path', 
-                    'dongle_series', 'num_dongles', 'port_id', 'upload_fw'
-                ]
+            multi_series_enabled = self.get_property('multi_series_mode')
         except:
-            # Fallback to single-series mode if property access fails
-            return base_props + [
-                'model_path', 'scpu_fw_path', 'ncpu_fw_path', 
-                'dongle_series', 'num_dongles', 'port_id', 'upload_fw'
-            ]
-
-    def get_inference_config(self):
-        """Get configuration for inference pipeline"""
-        if not NODEGRAPH_AVAILABLE:
-            return {}
-        
-        try:
-            multi_series_mode = self.get_property('multi_series_mode')
-            
-            if multi_series_mode:
-                # Multi-series configuration with series-specific port IDs
-                config = {
-                    'multi_series_mode': True,
-                    'assets_folder': self.get_property('assets_folder'),
-                    'enabled_series': self.get_property('enabled_series'),
-                    'max_queue_size': self.get_property('max_queue_size'),
-                    'result_buffer_size': self.get_property('result_buffer_size'),
-                    'batch_size': self.get_property('batch_size'),
-                    'enable_preprocessing': self.get_property('enable_preprocessing'),
-                    'enable_postprocessing': self.get_property('enable_postprocessing')
-                }
-                
-                # Build multi-series config for MultiDongle
-                multi_series_config = self._build_multi_series_config()
-                if multi_series_config:
-                    config['multi_series_config'] = multi_series_config
-                
-                return config
-            else:
-                # Single-series configuration
-                return {
-                    'multi_series_mode': False,
-                    'model_path': self.get_property('model_path'),
-                    'scpu_fw_path': self.get_property('scpu_fw_path'),
-                    'ncpu_fw_path': self.get_property('ncpu_fw_path'),
-                    'dongle_series': self.get_property('dongle_series'),
-                    'num_dongles': self.get_property('num_dongles'),
-                    'port_id': self.get_property('port_id'),
-                    'upload_fw': self.get_property('upload_fw')
-                }
-        except:
-            # Fallback to single-series configuration
-            return {
-                'multi_series_mode': False,
-                'model_path': self.get_property('model_path', ''),
-                'scpu_fw_path': self.get_property('scpu_fw_path', ''),
-                'ncpu_fw_path': self.get_property('ncpu_fw_path', ''),
-                'dongle_series': self.get_property('dongle_series', '520'),
-                'num_dongles': self.get_property('num_dongles', 1),
-                'port_id': self.get_property('port_id', ''),
-                'upload_fw': self.get_property('upload_fw', True)
-            }
-
-    def _build_multi_series_config(self):
-        """Build multi-series configuration for MultiDongle"""
-        try:
-            enabled_series = self.get_property('enabled_series') or []
-            assets_folder = self.get_property('assets_folder') or ''
-            
-            if not enabled_series:
-                return None
-            
-            multi_series_config = {}
-            
-            for series in enabled_series:
-                # Get port IDs for this series
-                port_ids_str = self.get_property(f'kl{series}_port_ids') or ''
-                if not port_ids_str.strip():
-                    continue  # Skip series without port IDs
-                
-                # Parse port IDs (comma-separated string to list of integers)
-                try:
-                    port_ids = [int(pid.strip()) for pid in port_ids_str.split(',') if pid.strip()]
-                    if not port_ids:
-                        continue
-                except ValueError:
-                    print(f"Warning: Invalid port IDs for KL{series}: {port_ids_str}")
-                    continue
-                
-                # Build series configuration
-                series_config = {
-                    "port_ids": port_ids
-                }
-                
-                # Add model path if assets folder is configured
-                if assets_folder:
-                    import os
-                    model_folder = os.path.join(assets_folder, 'Models', f'KL{series}')
-                    if os.path.exists(model_folder):
-                        # Look for .nef files in the model folder
-                        nef_files = [f for f in os.listdir(model_folder) if f.endswith('.nef')]
-                        if nef_files:
-                            series_config["model_path"] = os.path.join(model_folder, nef_files[0])
-                    
-                    # Add firmware paths if available
-                    firmware_folder = os.path.join(assets_folder, 'Firmware', f'KL{series}')
-                    if os.path.exists(firmware_folder):
-                        scpu_path = os.path.join(firmware_folder, 'fw_scpu.bin')
-                        ncpu_path = os.path.join(firmware_folder, 'fw_ncpu.bin')
-                        
-                        if os.path.exists(scpu_path) and os.path.exists(ncpu_path):
-                            series_config["firmware_paths"] = {
-                                "scpu": scpu_path,
-                                "ncpu": ncpu_path
-                            }
-                
-                multi_series_config[f'KL{series}'] = series_config
-            
-            return multi_series_config if multi_series_config else None
-            
-        except Exception as e:
-            print(f"Error building multi-series config: {e}")
-            return None
-
-    def get_hardware_requirements(self):
-        """Get hardware requirements for this node"""
-        if not NODEGRAPH_AVAILABLE:
-            return {}
-        
-        try:
-            multi_series_mode = self.get_property('multi_series_mode')
-            
-            if multi_series_mode:
-                enabled_series = self.get_property('enabled_series')
-                return {
-                    'multi_series_mode': True,
-                    'required_series': enabled_series,
-                    'estimated_dongles': len(enabled_series) * 2  # Assume 2 dongles per series
-                }
-            else:
-                dongle_series = self.get_property('dongle_series')
-                num_dongles = self.get_property('num_dongles')
-                return {
-                    'multi_series_mode': False,
-                    'required_series': [f'KL{dongle_series}'],
-                    'estimated_dongles': num_dongles
-                }
-        except:
-            return {'multi_series_mode': False, 'required_series': ['KL520'], 'estimated_dongles': 1}
-
-    def _setup_custom_property_handlers(self):
-        """Setup custom property handlers, especially for folder selection."""
-        try:
-            # For assets_folder, we want to trigger folder selection dialog
-            # This might require custom widget or property handling
-            # For now, we'll use the standard approach but add validation
-            
-            # You can override the property widget here if needed
-            # This is a placeholder for custom folder selection implementation
             pass
-        except Exception as e:
-            print(f"Warning: Could not setup custom property handlers: {e}")
         
-    def select_assets_folder(self):
-        """Method to open folder selection dialog for assets folder using improved utility."""
-        if not NODEGRAPH_AVAILABLE:
-            return ""
-            
-        try:
-            from utils.folder_dialog import select_assets_folder
-            
-            # Get current folder path as initial directory
-            current_folder = ""
-            try:
-                current_folder = self.get_property('assets_folder') or ""
-            except:
-                pass
-            
-            # Use the specialized assets folder dialog with validation
-            result = select_assets_folder(initial_dir=current_folder)
-            
-            if result['path']:
-                # Set the property
-                if NODEGRAPH_AVAILABLE:
-                    self.set_property('assets_folder', result['path'])
-                
-                # Print validation results
-                if result['valid']:
-                    print(f"✓ Valid Assets folder set to: {result['path']}")
-                    if 'details' in result and 'available_series' in result['details']:
-                        series = result['details']['available_series']
-                        print(f"  Available series: {', '.join(series)}")
-                else:
-                    print(f"⚠ Assets folder set to: {result['path']}")
-                    print(f"  Warning: {result['message']}")
-                    print("  Expected structure: Assets/Firmware/ and Assets/Models/ with series subfolders")
-                
-                return result['path']
-            else:
-                print("No folder selected")
-                return ""
-            
-        except ImportError:
-            print("utils.folder_dialog not available, falling back to simple input")
-            # Fallback to manual input
-            folder_path = input("Enter Assets folder path: ").strip()
-            if folder_path and NODEGRAPH_AVAILABLE:
-                self.set_property('assets_folder', folder_path)
-                return folder_path
-        except Exception as e:
-            print(f"Error selecting assets folder: {e}")
-            
-        return ""
-
-    def _validate_assets_folder(self, folder_path):
-        """Validate that the assets folder has the expected structure."""
-        try:
-            import os
-            
-            # Check if Firmware and Models folders exist
-            firmware_path = os.path.join(folder_path, 'Firmware')
-            models_path = os.path.join(folder_path, 'Models')
-            
-            has_firmware = os.path.exists(firmware_path) and os.path.isdir(firmware_path)
-            has_models = os.path.exists(models_path) and os.path.isdir(models_path)
-            
-            if not (has_firmware and has_models):
-                return False
-            
-            # Check for at least one series subfolder
-            expected_series = ['KL520', 'KL720', 'KL630', 'KL730']
-            
-            firmware_series = [d for d in os.listdir(firmware_path) 
-                             if os.path.isdir(os.path.join(firmware_path, d)) and d in expected_series]
-            
-            models_series = [d for d in os.listdir(models_path)
-                           if os.path.isdir(os.path.join(models_path, d)) and d in expected_series]
-            
-            # At least one series should exist in both firmware and models
-            return len(firmware_series) > 0 and len(models_series) > 0
-            
-        except Exception as e:
-            print(f"Error validating assets folder: {e}")
-            return False
-
-    def get_assets_folder_info(self):
-        """Get information about the configured assets folder."""
-        if not NODEGRAPH_AVAILABLE:
-            return {}
-            
-        try:
-            folder_path = self.get_property('assets_folder')
-            if not folder_path:
-                return {'status': 'not_set', 'message': 'No assets folder selected'}
-            
-            if not os.path.exists(folder_path):
-                return {'status': 'invalid', 'message': 'Selected folder does not exist'}
-            
-            info = {'status': 'valid', 'path': folder_path, 'series': []}
-            
-            # Get available series
-            firmware_path = os.path.join(folder_path, 'Firmware')
-            models_path = os.path.join(folder_path, 'Models')
-            
-            if os.path.exists(firmware_path):
-                firmware_series = [d for d in os.listdir(firmware_path) 
-                                 if os.path.isdir(os.path.join(firmware_path, d))]
-                info['firmware_series'] = firmware_series
-            
-            if os.path.exists(models_path):
-                models_series = [d for d in os.listdir(models_path)
-                               if os.path.isdir(os.path.join(models_path, d))]
-                info['models_series'] = models_series
-            
-            # Find common series
-            if 'firmware_series' in info and 'models_series' in info:
-                common_series = list(set(info['firmware_series']) & set(info['models_series']))
-                info['available_series'] = common_series
-                
-                if not common_series:
-                    info['status'] = 'incomplete'
-                    info['message'] = 'No series found with both firmware and models'
-            
-            return info
-            
-        except Exception as e:
-            return {'status': 'error', 'message': f'Error reading assets folder: {e}'}
-
-    def validate_configuration(self) -> tuple[bool, str]:
-        """
-        Validate the current node configuration.
-        
-        Returns:
-            Tuple of (is_valid, error_message)
-        """
-        if not NODEGRAPH_AVAILABLE:
-            return True, ""
-        
-        try:
-            multi_series_mode = self.get_property('multi_series_mode')
-            
-            if multi_series_mode:
-                # Multi-series validation
-                enabled_series = self.get_property('enabled_series')
-                if not enabled_series:
-                    return False, "No series enabled in multi-series mode"
-                
-                # Check if at least one series has port IDs configured
-                has_valid_series = False
-                for series in enabled_series:
-                    port_ids_str = self.get_property(f'kl{series}_port_ids', '')
-                    if port_ids_str and port_ids_str.strip():
-                        # Validate port ID format
-                        try:
-                            port_ids = [int(pid.strip()) for pid in port_ids_str.split(',') if pid.strip()]
-                            if port_ids:
-                                has_valid_series = True
-                                print(f"Valid series config found for KL{series}: ports {port_ids}")
-                        except ValueError:
-                            print(f"Warning: Invalid port ID format for KL{series}: {port_ids_str}")
-                            continue
-                
-                if not has_valid_series:
-                    return False, "At least one series must have valid port IDs configured"
-                
-                # Assets folder validation (optional for multi-series)
-                assets_folder = self.get_property('assets_folder')
-                if assets_folder:
-                    if not os.path.exists(assets_folder):
-                        print(f"Warning: Assets folder does not exist: {assets_folder}")
-                    else:
-                        # Validate assets folder structure if provided
-                        assets_info = self.get_assets_folder_info()
-                        if assets_info.get('status') == 'error':
-                            print(f"Warning: Assets folder issue: {assets_info.get('message', 'Unknown error')}")
-                
-                print("Multi-series mode validation passed")
-                return True, ""
-            else:
-                # Single-series validation (legacy)
-                model_path = self.get_property('model_path')
-                if not model_path:
-                    return False, "Model path is required"
-                
-                if not os.path.exists(model_path):
-                    return False, f"Model file does not exist: {model_path}"
-                
-                # Check dongle series
-                dongle_series = self.get_property('dongle_series')
-                if dongle_series not in ['520', '720', '1080', 'Custom']:
-                    return False, f"Invalid dongle series: {dongle_series}"
-                
-                # Check number of dongles
-                num_dongles = self.get_property('num_dongles')
-                if not isinstance(num_dongles, int) or num_dongles < 1:
-                    return False, "Number of dongles must be at least 1"
-                
-                return True, ""
-                
-        except Exception as e:
-            return False, f"Validation error: {str(e)}"
+        if multi_series_enabled:
+            # Multi-series mode properties
+            return ['multi_series_mode', 'assets_folder', 'enabled_series', 'port_mapping']
+        else:
+            # Single-series mode properties (original)
+            return ['multi_series_mode', 'model_path', 'scpu_fw_path', 'ncpu_fw_path', 'dongle_series', 'num_dongles', 'port_id', 'upload_fw']
 
 
 class ExactPreprocessNode(BaseNode):
@@ -660,9 +268,6 @@ class ExactPreprocessNode(BaseNode):
     
     def get_business_properties(self):
         """Get all business properties for serialization."""
-        if not NODEGRAPH_AVAILABLE:
-            return {}
-        
         properties = {}
         for prop_name in self._property_options.keys():
             try:
@@ -673,7 +278,7 @@ class ExactPreprocessNode(BaseNode):
 
 
 class ExactPostprocessNode(BaseNode):
-    """Postprocessing node with full MultiDongle postprocessing support."""
+    """Postprocessing node - exact match to original."""
     
     __identifier__ = 'com.cluster.postprocess_node.ExactPostprocessNode'
     NODE_NAME = 'Postprocess Node'
@@ -687,33 +292,18 @@ class ExactPostprocessNode(BaseNode):
             self.add_output('output', color=(0, 255, 0))
             self.set_color(153, 51, 51)
             
-            # Enhanced properties with MultiDongle postprocessing support
-            self.create_property('postprocess_type', 'fire_detection')
-            self.create_property('class_names', 'No Fire,Fire')
+            # Original properties - exact match
             self.create_property('output_format', 'JSON')
             self.create_property('confidence_threshold', 0.5)
             self.create_property('nms_threshold', 0.4)
             self.create_property('max_detections', 100)
-            self.create_property('enable_confidence_filter', True)
-            self.create_property('enable_nms', True)
-            self.create_property('coordinate_system', 'relative')
-            self.create_property('operations', 'filter,nms,format')
             
-            # Enhanced property options with MultiDongle integration
+            # Original property options - exact match
             self._property_options = {
-                'postprocess_type': ['fire_detection', 'yolo_v3', 'yolo_v5', 'classification', 'raw_output'],
-                'class_names': {
-                    'placeholder': 'comma-separated class names',
-                    'description': 'Class names for model output (e.g., "No Fire,Fire" or "person,car,bicycle")'
-                },
-                'output_format': ['JSON', 'XML', 'CSV', 'Binary', 'MessagePack', 'YAML'],
-                'confidence_threshold': {'min': 0.0, 'max': 1.0, 'step': 0.01},
-                'nms_threshold': {'min': 0.0, 'max': 1.0, 'step': 0.01},
-                'max_detections': {'min': 1, 'max': 1000},
-                'enable_confidence_filter': {'type': 'bool', 'default': True},
-                'enable_nms': {'type': 'bool', 'default': True},
-                'coordinate_system': ['relative', 'absolute', 'center', 'custom'],
-                'operations': {'placeholder': 'comma-separated: filter,nms,format,validate,transform'}
+                'output_format': ['JSON', 'XML', 'CSV', 'Binary'],
+                'confidence_threshold': {'min': 0.0, 'max': 1.0, 'step': 0.1},
+                'nms_threshold': {'min': 0.0, 'max': 1.0, 'step': 0.1},
+                'max_detections': {'min': 1, 'max': 1000}
             }
             
             # Create custom properties dictionary for UI compatibility
@@ -743,9 +333,6 @@ class ExactPostprocessNode(BaseNode):
     
     def get_business_properties(self):
         """Get all business properties for serialization."""
-        if not NODEGRAPH_AVAILABLE:
-            return {}
-        
         properties = {}
         for prop_name in self._property_options.keys():
             try:
@@ -754,120 +341,6 @@ class ExactPostprocessNode(BaseNode):
                 pass
         return properties
 
-    def get_multidongle_postprocess_options(self):
-        """Create PostProcessorOptions from node configuration."""
-        try:
-            from ..functions.Multidongle import PostProcessType, PostProcessorOptions
-            
-            postprocess_type_str = self.get_property('postprocess_type')
-            
-            # Map string to enum
-            type_mapping = {
-                'fire_detection': PostProcessType.FIRE_DETECTION,
-                'yolo_v3': PostProcessType.YOLO_V3,
-                'yolo_v5': PostProcessType.YOLO_V5,
-                'classification': PostProcessType.CLASSIFICATION,
-                'raw_output': PostProcessType.RAW_OUTPUT
-            }
-            
-            postprocess_type = type_mapping.get(postprocess_type_str, PostProcessType.FIRE_DETECTION)
-            
-            # Parse class names
-            class_names_str = self.get_property('class_names')
-            class_names = [name.strip() for name in class_names_str.split(',') if name.strip()] if class_names_str else []
-            
-            return PostProcessorOptions(
-                postprocess_type=postprocess_type,
-                threshold=self.get_property('confidence_threshold'),
-                class_names=class_names,
-                nms_threshold=self.get_property('nms_threshold'),
-                max_detections_per_class=self.get_property('max_detections')
-            )
-        except ImportError:
-            print("Warning: PostProcessorOptions not available")
-            return None
-        except Exception as e:
-            print(f"Error creating PostProcessorOptions: {e}")
-            return None
-    
-    def get_postprocessing_config(self):
-        """Get postprocessing configuration for pipeline execution."""
-        return {
-            'node_id': self.id,
-            'node_name': self.name(),
-            # MultiDongle postprocessing integration
-            'postprocess_type': self.get_property('postprocess_type'),
-            'class_names': self._parse_class_list(self.get_property('class_names')),
-            'multidongle_options': self.get_multidongle_postprocess_options(),
-            # Core postprocessing properties
-            'output_format': self.get_property('output_format'),
-            'confidence_threshold': self.get_property('confidence_threshold'),
-            'enable_confidence_filter': self.get_property('enable_confidence_filter'),
-            'nms_threshold': self.get_property('nms_threshold'),
-            'enable_nms': self.get_property('enable_nms'),
-            'max_detections': self.get_property('max_detections'),
-            'coordinate_system': self.get_property('coordinate_system'),
-            'operations': self._parse_operations_list(self.get_property('operations'))
-        }
-    
-    def _parse_class_list(self, value_str):
-        """Parse comma-separated class names or indices."""
-        if not value_str:
-            return []
-        return [x.strip() for x in value_str.split(',') if x.strip()]
-    
-    def _parse_operations_list(self, operations_str):
-        """Parse comma-separated operations list."""
-        if not operations_str:
-            return []
-        return [op.strip() for op in operations_str.split(',') if op.strip()]
-    
-    def validate_configuration(self):
-        """Validate the current node configuration."""
-        try:
-            # Check confidence threshold
-            confidence_threshold = self.get_property('confidence_threshold')
-            if not isinstance(confidence_threshold, (int, float)) or confidence_threshold < 0 or confidence_threshold > 1:
-                return False, "Confidence threshold must be between 0 and 1"
-            
-            # Check NMS threshold
-            nms_threshold = self.get_property('nms_threshold')
-            if not isinstance(nms_threshold, (int, float)) or nms_threshold < 0 or nms_threshold > 1:
-                return False, "NMS threshold must be between 0 and 1"
-            
-            # Check max detections
-            max_detections = self.get_property('max_detections')
-            if not isinstance(max_detections, int) or max_detections < 1:
-                return False, "Max detections must be at least 1"
-            
-            # Validate operations string
-            operations = self.get_property('operations')
-            valid_operations = ['filter', 'nms', 'format', 'validate', 'transform', 'track', 'aggregate']
-            
-            if operations:
-                ops_list = [op.strip() for op in operations.split(',')]
-                invalid_ops = [op for op in ops_list if op not in valid_operations]
-                if invalid_ops:
-                    return False, f"Invalid operations: {', '.join(invalid_ops)}"
-            
-            return True, ""
-        except Exception as e:
-            return False, f"Validation error: {str(e)}"
-    
-    def get_display_properties(self):
-        """Return properties that should be displayed in the UI panel."""
-        # Core properties that should always be visible for easy mode switching
-        return [
-            'postprocess_type',
-            'class_names', 
-            'confidence_threshold',
-            'nms_threshold',
-            'output_format',
-            'enable_confidence_filter',
-            'enable_nms',
-            'max_detections'
-        ]
-
 
 class ExactOutputNode(BaseNode):
     """Output data sink node - exact match to original."""
@@ -924,9 +397,6 @@ class ExactOutputNode(BaseNode):
     
     def get_business_properties(self):
         """Get all business properties for serialization."""
-        if not NODEGRAPH_AVAILABLE:
-            return {}
-        
         properties = {}
         for prop_name in self._property_options.keys():
             try:

core/nodes/postprocess_node.py

@@ -19,7 +19,6 @@ Usage:
 """
 
 from .base_node import BaseNodeWithProperties
-from ..functions.Multidongle import PostProcessType, PostProcessorOptions
 
 
 class PostprocessNode(BaseNodeWithProperties):
@@ -46,17 +45,6 @@ class PostprocessNode(BaseNodeWithProperties):
     
     def setup_properties(self):
         """Initialize postprocessing-specific properties."""
-        # Postprocessing type - NEW: Integration with MultiDongle postprocessing
-        self.create_business_property('postprocess_type', 'fire_detection', [
-            'fire_detection', 'yolo_v3', 'yolo_v5', 'classification', 'raw_output'
-        ])
-        
-        # Class names for postprocessing
-        self.create_business_property('class_names', 'No Fire,Fire', {
-            'placeholder': 'comma-separated class names',
-            'description': 'Class names for model output (e.g., "No Fire,Fire" or "person,car,bicycle")'
-        })
-        
         # Output format
         self.create_business_property('output_format', 'JSON', [
             'JSON', 'XML', 'CSV', 'Binary', 'MessagePack', 'YAML'
@@ -191,33 +179,6 @@ class PostprocessNode(BaseNodeWithProperties):
         
         return True, ""
     
-    def get_multidongle_postprocess_options(self) -> 'PostProcessorOptions':
-        """Create PostProcessorOptions from node configuration."""
-        postprocess_type_str = self.get_property('postprocess_type')
-        
-        # Map string to enum
-        type_mapping = {
-            'fire_detection': PostProcessType.FIRE_DETECTION,
-            'yolo_v3': PostProcessType.YOLO_V3,
-            'yolo_v5': PostProcessType.YOLO_V5,
-            'classification': PostProcessType.CLASSIFICATION,
-            'raw_output': PostProcessType.RAW_OUTPUT
-        }
-        
-        postprocess_type = type_mapping.get(postprocess_type_str, PostProcessType.FIRE_DETECTION)
-        
-        # Parse class names
-        class_names_str = self.get_property('class_names')
-        class_names = [name.strip() for name in class_names_str.split(',') if name.strip()] if class_names_str else []
-        
-        return PostProcessorOptions(
-            postprocess_type=postprocess_type,
-            threshold=self.get_property('confidence_threshold'),
-            class_names=class_names,
-            nms_threshold=self.get_property('nms_threshold'),
-            max_detections_per_class=self.get_property('max_detections')
-        )
-    
     def get_postprocessing_config(self) -> dict:
         """
         Get postprocessing configuration for pipeline execution.
@@ -228,11 +189,6 @@ class PostprocessNode(BaseNodeWithProperties):
         return {
             'node_id': self.id,
             'node_name': self.name(),
-            # NEW: MultiDongle postprocessing integration
-            'postprocess_type': self.get_property('postprocess_type'),
-            'class_names': self._parse_class_list(self.get_property('class_names')),
-            'multidongle_options': self.get_multidongle_postprocess_options(),
-            # Original properties
             'output_format': self.get_property('output_format'),
             'confidence_threshold': self.get_property('confidence_threshold'),
             'enable_confidence_filter': self.get_property('enable_confidence_filter'),

core/pipeline.py

@@ -277,56 +277,30 @@ def find_shortest_path_distance(start_node, target_node, visited=None, distance=
 
 
 def find_preprocess_nodes_for_model(model_node, all_nodes):
-    """Find preprocessing nodes that connect to the given model node.
+    """Find preprocessing nodes that connect to the given model node."""
+    preprocess_nodes = []
+    
+    # Get all nodes that connect to the model's inputs
+    for input_port in model_node.inputs():
+        for connected_output in input_port.connected_outputs():
+            connected_node = connected_output.node()
+            if isinstance(connected_node, PreprocessNode):
+                preprocess_nodes.append(connected_node)
     
-    This guards against mixed data types (e.g., string IDs from .mflow) by
-    verifying attributes before traversing connections.
-    """
-    preprocess_nodes: List[PreprocessNode] = []
-    try:
-        if hasattr(model_node, 'inputs'):
-            for input_port in model_node.inputs() or []:
-                try:
-                    if hasattr(input_port, 'connected_outputs'):
-                        for connected_output in input_port.connected_outputs() or []:
-                            try:
-                                if hasattr(connected_output, 'node'):
-                                    connected_node = connected_output.node()
-                                    if isinstance(connected_node, PreprocessNode):
-                                        preprocess_nodes.append(connected_node)
-                            except Exception:
-                                continue
-                except Exception:
-                    continue
-    except Exception:
-        # Swallow traversal errors and return what we found so far
-        pass
     return preprocess_nodes
 
 
 def find_postprocess_nodes_for_model(model_node, all_nodes):
-    """Find postprocessing nodes that the given model node connects to.
+    """Find postprocessing nodes that the given model node connects to."""
+    postprocess_nodes = []
+    
+    # Get all nodes that the model connects to
+    for output in model_node.outputs():
+        for connected_input in output.connected_inputs():
+            connected_node = connected_input.node()
+            if isinstance(connected_node, PostprocessNode):
+                postprocess_nodes.append(connected_node)
     
-    Defensive against cases where ports are not NodeGraphQt objects.
-    """
-    postprocess_nodes: List[PostprocessNode] = []
-    try:
-        if hasattr(model_node, 'outputs'):
-            for output in model_node.outputs() or []:
-                try:
-                    if hasattr(output, 'connected_inputs'):
-                        for connected_input in output.connected_inputs() or []:
-                            try:
-                                if hasattr(connected_input, 'node'):
-                                    connected_node = connected_input.node()
-                                    if isinstance(connected_node, PostprocessNode):
-                                        postprocess_nodes.append(connected_node)
-                            except Exception:
-                                continue
-                except Exception:
-                    continue
-    except Exception:
-        pass
     return postprocess_nodes
 
 

debug_deployment.py

@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-"""
-Debug deployment error
-"""
-
-import sys
-import os
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-def simulate_deployment():
-    """Simulate the deployment process to find the Optional error"""
-    try:
-        print("Testing export_pipeline_data equivalent...")
-        
-        # Simulate creating a node and getting properties
-        from core.nodes.exact_nodes import ExactModelNode
-        
-        # This would be similar to what dashboard does
-        node = ExactModelNode()
-        print("Node created")
-        
-        # Check if node has get_business_properties
-        if hasattr(node, 'get_business_properties'):
-            print("Node has get_business_properties")
-            try:
-                props = node.get_business_properties()
-                print(f"Properties extracted: {type(props)}")
-            except Exception as e:
-                print(f"Error in get_business_properties: {e}")
-                import traceback
-                traceback.print_exc()
-        
-        # Test the mflow converter directly
-        print("\nTesting MFlowConverter...")
-        from core.functions.mflow_converter import MFlowConverter
-        converter = MFlowConverter(default_fw_path='.')
-        print("MFlowConverter created successfully")
-        
-        # Test multi-series config building
-        test_props = {
-            'multi_series_mode': True,
-            'enabled_series': ['520', '720'],
-            'kl520_port_ids': '28,32',
-            'kl720_port_ids': '4'
-        }
-        
-        config = converter._build_multi_series_config_from_properties(test_props)
-        print(f"Multi-series config: {config}")
-        
-        print("All tests passed!")
-        
-    except Exception as e:
-        print(f"Error: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    simulate_deployment()

debug_multi_series_flow.py

@@ -1,90 +0,0 @@
-#!/usr/bin/env python3
-"""
-Debug the multi-series configuration flow
-"""
-
-import sys
-import os
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-def test_full_flow():
-    """Test the complete multi-series configuration flow"""
-    print("=== Testing Multi-Series Configuration Flow ===")
-    
-    # Simulate node properties as they would appear in the UI
-    mock_node_properties = {
-        'multi_series_mode': True,
-        'enabled_series': ['520', '720'],
-        'kl520_port_ids': '28,32',
-        'kl720_port_ids': '4',
-        'assets_folder': '',
-        'max_queue_size': 100
-    }
-    
-    print(f"1. Mock node properties: {mock_node_properties}")
-    
-    # Test the mflow converter building multi-series config
-    try:
-        from core.functions.mflow_converter import MFlowConverter
-        converter = MFlowConverter(default_fw_path='.')
-        
-        config = converter._build_multi_series_config_from_properties(mock_node_properties)
-        print(f"2. Multi-series config built: {config}")
-        
-        if config:
-            print("   [OK] Multi-series config successfully built")
-            
-            # Test StageConfig creation
-            from core.functions.InferencePipeline import StageConfig
-            
-            stage_config = StageConfig(
-                stage_id="test_stage",
-                port_ids=[],  # Not used in multi-series
-                scpu_fw_path='',
-                ncpu_fw_path='',
-                model_path='',
-                upload_fw=False,
-                multi_series_mode=True,
-                multi_series_config=config
-            )
-            
-            print(f"3. StageConfig created with multi_series_mode: {stage_config.multi_series_mode}")
-            print(f"   Multi-series config: {stage_config.multi_series_config}")
-            
-            # Test what would happen in PipelineStage initialization
-            print("4. Testing PipelineStage initialization logic:")
-            if stage_config.multi_series_mode and stage_config.multi_series_config:
-                print("   [OK] Would initialize MultiDongle with multi_series_config")
-                print(f"   MultiDongle(multi_series_config={stage_config.multi_series_config})")
-            else:
-                print("   [ERROR] Would fall back to single-series mode")
-                
-        else:
-            print("   [ERROR] Multi-series config is None - this is the problem!")
-            
-    except Exception as e:
-        print(f"Error in flow test: {e}")
-        import traceback
-        traceback.print_exc()
-
-def test_node_direct():
-    """Test creating a node directly and getting its inference config"""
-    print("\n=== Testing Node Direct Configuration ===")
-    
-    try:
-        from core.nodes.exact_nodes import ExactModelNode
-        
-        # This won't work without NodeGraphQt, but let's see what happens
-        node = ExactModelNode()
-        print("Node created (mock mode)")
-        
-        # Test the get_business_properties method that would be called during export
-        props = node.get_business_properties()
-        print(f"Business properties: {props}")
-        
-    except Exception as e:
-        print(f"Error in node test: {e}")
-
-if __name__ == "__main__":
-    test_full_flow()
-    test_node_direct()

example_postprocess_options.py

@@ -1,141 +0,0 @@
-#!/usr/bin/env python3
-"""
-Example demonstrating the new default postprocess options in the app.
-
-This script shows how to use the different postprocessing types:
-- Fire detection (classification)
-- YOLO v3/v5 (object detection with bounding boxes)
-- General classification
-- Raw output
-
-The postprocessing options are built-in to the app and provide text output
-and bounding box visualization in live view windows.
-"""
-
-import sys
-import os
-
-# Add the project root to Python path
-sys.path.insert(0, os.path.dirname(__file__))
-
-from core.functions.Multidongle import (
-    MultiDongle, 
-    PostProcessorOptions, 
-    PostProcessType,
-    WebcamInferenceRunner
-)
-
-
-def demo_fire_detection():
-    """Demo fire detection postprocessing (default)"""
-    print("=== Fire Detection Demo ===")
-    
-    # Configure for fire detection
-    options = PostProcessorOptions(
-        postprocess_type=PostProcessType.FIRE_DETECTION,
-        threshold=0.5,
-        class_names=["No Fire", "Fire"]
-    )
-    
-    print(f"Postprocess type: {options.postprocess_type.value}")
-    print(f"Threshold: {options.threshold}")
-    print(f"Class names: {options.class_names}")
-    return options
-
-
-def demo_yolo_object_detection():
-    """Demo YOLO object detection with bounding boxes"""
-    print("=== YOLO Object Detection Demo ===")
-    
-    # Configure for YOLO v5 object detection
-    options = PostProcessorOptions(
-        postprocess_type=PostProcessType.YOLO_V5,
-        threshold=0.3,
-        class_names=["person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train", "truck"],
-        nms_threshold=0.5,
-        max_detections_per_class=50
-    )
-    
-    print(f"Postprocess type: {options.postprocess_type.value}")
-    print(f"Detection threshold: {options.threshold}")
-    print(f"NMS threshold: {options.nms_threshold}")
-    print(f"Class names: {options.class_names[:5]}...")  # Show first 5
-    return options
-
-
-def demo_general_classification():
-    """Demo general classification"""
-    print("=== General Classification Demo ===")
-    
-    # Configure for general classification
-    options = PostProcessorOptions(
-        postprocess_type=PostProcessType.CLASSIFICATION,
-        threshold=0.6,
-        class_names=["cat", "dog", "bird", "fish", "horse"]
-    )
-    
-    print(f"Postprocess type: {options.postprocess_type.value}")
-    print(f"Threshold: {options.threshold}")
-    print(f"Class names: {options.class_names}")
-    return options
-
-
-def main():
-    """Main demo function"""
-    print("Default Postprocess Options Demo")
-    print("=" * 40)
-    
-    # Demo different postprocessing options
-    fire_options = demo_fire_detection()
-    print()
-    
-    yolo_options = demo_yolo_object_detection()
-    print()
-    
-    classification_options = demo_general_classification()
-    print()
-    
-    # Example of how to initialize MultiDongle with options
-    print("=== MultiDongle Integration Example ===")
-    
-    # NOTE: Update these paths according to your setup
-    PORT_IDS = [28, 32]  # Update with your device port IDs
-    SCPU_FW = 'fw_scpu.bin'  # Update with your firmware path
-    NCPU_FW = 'fw_ncpu.bin'  # Update with your firmware path
-    MODEL_PATH = 'your_model.nef'  # Update with your model path
-    
-    try:
-        # Example 1: Fire detection (default)
-        print("Initializing with fire detection...")
-        multidongle_fire = MultiDongle(
-            port_id=PORT_IDS,
-            scpu_fw_path=SCPU_FW,
-            ncpu_fw_path=NCPU_FW,
-            model_path=MODEL_PATH,
-            upload_fw=False,  # Set to True if you need firmware upload
-            postprocess_options=fire_options
-        )
-        print(f"✓ Fire detection configured: {multidongle_fire.postprocess_options.postprocess_type.value}")
-        
-        # Example 2: Change postprocessing options dynamically
-        print("Changing to YOLO detection...")
-        multidongle_fire.set_postprocess_options(yolo_options)
-        print(f"✓ YOLO detection configured: {multidongle_fire.postprocess_options.postprocess_type.value}")
-        
-        # Example 3: Get available types
-        available_types = multidongle_fire.get_available_postprocess_types()
-        print(f"Available postprocess types: {[t.value for t in available_types]}")
-        
-    except Exception as e:
-        print(f"Note: MultiDongle initialization skipped (no hardware): {e}")
-    
-    print("\n=== Usage Notes ===")
-    print("1. Fire detection option is set as default")
-    print("2. Text output shows classification results with probabilities")
-    print("3. Bounding box output visualizes detected objects in live view")
-    print("4. All postprocessing is built-in to the app (no external dependencies)")
-    print("5. Exact nodes can configure postprocessing through UI properties")
-
-
-if __name__ == "__main__":
-    main()

example_utils/ExampleEnum.py

@@ -1,59 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2021-2022. Kneron Inc. All rights reserved.                   *
-# ******************************************************************************
-
-from enum import Enum
-
-
-class ImageType(Enum):
-    GENERAL = 'general'
-    BINARY = 'binary'
-
-
-class ImageFormat(Enum):
-    RGB565 = 'RGB565'
-    RGBA8888 = 'RGBA8888'
-    YUYV = 'YUYV'
-    CRY1CBY0 = 'CrY1CbY0'
-    CBY1CRY0 = 'CbY1CrY0'
-    Y1CRY0CB = 'Y1CrY0Cb'
-    Y1CBY0CR = 'Y1CbY0Cr'
-    CRY0CBY1 = 'CrY0CbY1'
-    CBY0CRY1 = 'CbY0CrY1'
-    Y0CRY1CB = 'Y0CrY1Cb'
-    Y0CBY1CR = 'Y0CbY1Cr'
-    RAW8 = 'RAW8'
-    YUV420p = 'YUV420p'
-
-
-class ResizeMode(Enum):
-    NONE = 'none'
-    ENABLE = 'auto'
-
-
-class PaddingMode(Enum):
-    NONE = 'none'
-    PADDING_CORNER = 'corner'
-    PADDING_SYMMETRIC = 'symmetric'
-
-
-class PostprocessMode(Enum):
-    NONE = 'none'
-    YOLO_V3 = 'yolo_v3'
-    YOLO_V5 = 'yolo_v5'
-
-
-class NormalizeMode(Enum):
-    NONE = 'none'
-    KNERON = 'kneron'
-    TENSORFLOW = 'tensorflow'
-    YOLO = 'yolo'
-    CUSTOMIZED_DEFAULT = 'customized_default'
-    CUSTOMIZED_SUB128 = 'customized_sub128'
-    CUSTOMIZED_DIV2 = 'customized_div2'
-    CUSTOMIZED_SUB128_DIV2 = 'customized_sub128_div2'
-
-
-class InferenceRetrieveNodeMode(Enum):
-    FIXED = 'fixed'
-    FLOAT = 'float'

example_utils/ExampleHelper.py

@@ -1,578 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2022. Kneron Inc. All rights reserved.                        *
-# ******************************************************************************
-from typing import List, Union
-from utils.ExampleEnum import *
-
-import numpy as np
-import re
-import os
-import sys
-import cv2
-
-PWD = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(1, os.path.join(PWD, '../..'))
-
-import kp
-
-TARGET_FW_VERSION = 'KDP2'
-
-
-def get_device_usb_speed_by_port_id(usb_port_id: int) -> kp.UsbSpeed:
-    device_list = kp.core.scan_devices()
-
-    for device_descriptor in device_list.device_descriptor_list:
-        if 0 == usb_port_id:
-            return device_descriptor.link_speed
-        elif usb_port_id == device_descriptor.usb_port_id:
-            return device_descriptor.link_speed
-
-    raise IOError('Specified USB port ID {} not exist.'.format(usb_port_id))
-
-
-def get_connect_device_descriptor(target_device: str,
-                                  scan_index_list: Union[List[int], None],
-                                  usb_port_id_list: Union[List[int], None]):
-    print('[Check Device]')
-
-    # scan devices
-    _device_list = kp.core.scan_devices()
-
-    # check Kneron device exist
-    if _device_list.device_descriptor_number == 0:
-        print('Error: no Kneron device !')
-        exit(0)
-
-    _index_device_descriptor_list = []
-
-    # get device_descriptor of specified scan index
-    if scan_index_list is not None:
-        for _scan_index in scan_index_list:
-            if _device_list.device_descriptor_number > _scan_index >= 0:
-                _index_device_descriptor_list.append([_scan_index, _device_list.device_descriptor_list[_scan_index]])
-            else:
-                print('Error: no matched Kneron device of specified scan index !')
-                exit(0)
-    # get device_descriptor of specified port ID
-    elif usb_port_id_list is not None:
-        for _scan_index, __device_descriptor in enumerate(_device_list.device_descriptor_list):
-            for _usb_port_id in usb_port_id_list:
-                if __device_descriptor.usb_port_id == _usb_port_id:
-                    _index_device_descriptor_list.append([_scan_index, __device_descriptor])
-
-        if 0 == len(_index_device_descriptor_list):
-            print('Error: no matched Kneron device of specified port ID !')
-            exit(0)
-    # get device_descriptor of by default
-    else:
-        _index_device_descriptor_list = [[_scan_index, __device_descriptor] for _scan_index, __device_descriptor in
-                                         enumerate(_device_list.device_descriptor_list)]
-
-    # check device_descriptor is specified target device
-    if target_device.lower() == 'kl520':
-        _target_device_product_id = kp.ProductId.KP_DEVICE_KL520
-    elif target_device.lower() == 'kl720':
-        _target_device_product_id = kp.ProductId.KP_DEVICE_KL720
-    elif target_device.lower() == 'kl630':
-        _target_device_product_id = kp.ProductId.KP_DEVICE_KL630
-    elif target_device.lower() == 'kl730':
-        _target_device_product_id = kp.ProductId.KP_DEVICE_KL730
-    elif target_device.lower() == 'kl830':
-        _target_device_product_id = kp.ProductId.KP_DEVICE_KL830
-
-    for _scan_index, __device_descriptor in _index_device_descriptor_list:
-        if kp.ProductId(__device_descriptor.product_id) != _target_device_product_id:
-            print('Error: Not matched Kneron device of specified target device !')
-            exit(0)
-
-    for _scan_index, __device_descriptor in _index_device_descriptor_list:
-        if TARGET_FW_VERSION not in __device_descriptor.firmware:
-            print('Error: device is not running KDP2/KDP2 Loader firmware ...')
-            print('please upload firmware first via \'kp.core.load_firmware_from_file()\'')
-            exit(0)
-
-    print(' - Success')
-
-    return _index_device_descriptor_list
-
-
-def read_image(img_path: str, img_type: str, img_format: str):
-    print('[Read Image]')
-    if img_type == ImageType.GENERAL.value:
-        _img = cv2.imread(filename=img_path)
-
-        if len(_img.shape) < 3:
-            channel_num = 2
-        else:
-            channel_num = _img.shape[2]
-
-        if channel_num == 1:
-            if img_format == ImageFormat.RGB565.value:
-                color_cvt_code = cv2.COLOR_GRAY2BGR565
-            elif img_format == ImageFormat.RGBA8888.value:
-                color_cvt_code = cv2.COLOR_GRAY2BGRA
-            elif img_format == ImageFormat.RAW8.value:
-                color_cvt_code = None
-            else:
-                print('Error: No matched image format !')
-                exit(0)
-        elif channel_num == 3:
-            if img_format == ImageFormat.RGB565.value:
-                color_cvt_code = cv2.COLOR_BGR2BGR565
-            elif img_format == ImageFormat.RGBA8888.value:
-                color_cvt_code = cv2.COLOR_BGR2BGRA
-            elif img_format == ImageFormat.RAW8.value:
-                color_cvt_code = cv2.COLOR_BGR2GRAY
-            else:
-                print('Error: No matched image format !')
-                exit(0)
-        else:
-            print('Error: Not support image format !')
-            exit(0)
-
-        if color_cvt_code is not None:
-            _img = cv2.cvtColor(src=_img, code=color_cvt_code)
-
-    elif img_type == ImageType.BINARY.value:
-        with open(file=img_path, mode='rb') as file:
-            _img = file.read()
-    else:
-        print('Error: Not support image type !')
-        exit(0)
-
-    print(' - Success')
-    return _img
-
-
-def get_kp_image_format(image_format: str) -> kp.ImageFormat:
-    if image_format == ImageFormat.RGB565.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_RGB565
-    elif image_format == ImageFormat.RGBA8888.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_RGBA8888
-    elif image_format == ImageFormat.YUYV.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YUYV
-    elif image_format == ImageFormat.CRY1CBY0.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YCBCR422_CRY1CBY0
-    elif image_format == ImageFormat.CBY1CRY0.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YCBCR422_CBY1CRY0
-    elif image_format == ImageFormat.Y1CRY0CB.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YCBCR422_Y1CRY0CB
-    elif image_format == ImageFormat.Y1CBY0CR.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YCBCR422_Y1CBY0CR
-    elif image_format == ImageFormat.CRY0CBY1.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YCBCR422_CRY0CBY1
-    elif image_format == ImageFormat.CBY0CRY1.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YCBCR422_CBY0CRY1
-    elif image_format == ImageFormat.Y0CRY1CB.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YCBCR422_Y0CRY1CB
-    elif image_format == ImageFormat.Y0CBY1CR.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YCBCR422_Y0CBY1CR
-    elif image_format == ImageFormat.RAW8.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_RAW8
-    elif image_format == ImageFormat.YUV420p.value:
-        _kp_image_format = kp.ImageFormat.KP_IMAGE_FORMAT_YUV420
-    else:
-        print('Error: Not support image format !')
-        exit(0)
-
-    return _kp_image_format
-
-
-def get_kp_normalize_mode(norm_mode: str) -> kp.NormalizeMode:
-    if norm_mode == NormalizeMode.NONE.value:
-        _kp_norm = kp.NormalizeMode.KP_NORMALIZE_DISABLE
-    elif norm_mode == NormalizeMode.KNERON.value:
-        _kp_norm = kp.NormalizeMode.KP_NORMALIZE_KNERON
-    elif norm_mode == NormalizeMode.YOLO.value:
-        _kp_norm = kp.NormalizeMode.KP_NORMALIZE_YOLO
-    elif norm_mode == NormalizeMode.TENSORFLOW.value:
-        _kp_norm = kp.NormalizeMode.KP_NORMALIZE_TENSOR_FLOW
-    elif norm_mode == NormalizeMode.CUSTOMIZED_DEFAULT.value:
-        _kp_norm = kp.NormalizeMode.KP_NORMALIZE_CUSTOMIZED_DEFAULT
-    elif norm_mode == NormalizeMode.CUSTOMIZED_SUB128.value:
-        _kp_norm = kp.NormalizeMode.KP_NORMALIZE_CUSTOMIZED_SUB128
-    elif norm_mode == NormalizeMode.CUSTOMIZED_DIV2.value:
-        _kp_norm = kp.NormalizeMode.KP_NORMALIZE_CUSTOMIZED_DIV2
-    elif norm_mode == NormalizeMode.CUSTOMIZED_SUB128_DIV2.value:
-        _kp_norm = kp.NormalizeMode.KP_NORMALIZE_CUSTOMIZED_SUB128_DIV2
-    else:
-        print('Error: Not support normalize mode !')
-        exit(0)
-
-    return _kp_norm
-
-
-def get_kp_pre_process_resize_mode(resize_mode: str) -> kp.ResizeMode:
-    if resize_mode == ResizeMode.NONE.value:
-        _kp_resize_mode = kp.ResizeMode.KP_RESIZE_DISABLE
-    elif resize_mode == ResizeMode.ENABLE.value:
-        _kp_resize_mode = kp.ResizeMode.KP_RESIZE_ENABLE
-    else:
-        print('Error: Not support pre process resize mode !')
-        exit(0)
-
-    return _kp_resize_mode
-
-
-def get_kp_pre_process_padding_mode(padding_mode: str) -> kp.PaddingMode:
-    if padding_mode == PaddingMode.NONE.value:
-        _kp_padding_mode = kp.PaddingMode.KP_PADDING_DISABLE
-    elif padding_mode == PaddingMode.PADDING_CORNER.value:
-        _kp_padding_mode = kp.PaddingMode.KP_PADDING_CORNER
-    elif padding_mode == PaddingMode.PADDING_SYMMETRIC.value:
-        _kp_padding_mode = kp.PaddingMode.KP_PADDING_SYMMETRIC
-    else:
-        print('Error: Not support pre process padding mode !')
-        exit(0)
-
-    return _kp_padding_mode
-
-
-def get_ex_post_process_mode(post_proc: str) -> PostprocessMode:
-    if post_proc in PostprocessMode._value2member_map_:
-        _ex_post_proc = PostprocessMode(post_proc)
-    else:
-        print('Error: Not support post process mode !')
-        exit(0)
-
-    return _ex_post_proc
-
-
-def parse_crop_box_from_str(crop_box_str: str) -> List[kp.InferenceCropBox]:
-    _group_list = re.compile(r'\([\s]*(\d+)[\s]*,[\s]*(\d+)[\s]*,[\s]*(\d+)[\s]*,[\s]*(\d+)[\s]*\)').findall(
-        crop_box_str)
-    _crop_box_list = []
-
-    for _idx, _crop_box in enumerate(_group_list):
-        _crop_box_list.append(
-            kp.InferenceCropBox(
-                crop_box_index=_idx,
-                x=int(_crop_box[0]),
-                y=int(_crop_box[1]),
-                width=int(_crop_box[2]),
-                height=int(_crop_box[3])
-            )
-        )
-
-    return _crop_box_list
-
-
-def convert_onnx_data_to_npu_data(tensor_descriptor: kp.TensorDescriptor, onnx_data: np.ndarray) -> bytes:
-    def __get_npu_ndarray(__tensor_descriptor: kp.TensorDescriptor, __npu_ndarray_dtype: np.dtype):
-        assert __tensor_descriptor.tensor_shape_info.version == kp.ModelTensorShapeInformationVersion.KP_MODEL_TENSOR_SHAPE_INFO_VERSION_2
-
-        if __tensor_descriptor.data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8B,
-                                               kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8BHL]:
-            """ calculate channel group stride in C language
-            for (int axis = 0; axis < (int)tensor_shape_info->shape_len; axis++) {
-                if (1 == tensor_shape_info->stride_npu[axis]) {
-                    channel_idx = axis;
-                    continue;
-                }
-
-                npu_channel_group_stride_tmp = tensor_shape_info->stride_npu[axis] * tensor_shape_info->shape[axis];
-                if (npu_channel_group_stride_tmp > npu_channel_group_stride)
-                    npu_channel_group_stride = npu_channel_group_stride_tmp;
-            }
-            """
-            __shape = np.array(__tensor_descriptor.tensor_shape_info.v2.shape, dtype=int)
-            __stride_npu = np.array(__tensor_descriptor.tensor_shape_info.v2.stride_npu, dtype=int)
-            __channel_idx = np.where(__stride_npu == 1)[0][0]
-            __dimension_stride = __stride_npu * __shape
-            __dimension_stride[__channel_idx] = 0
-            __npu_channel_group_stride = np.max(__dimension_stride.flatten())
-
-            """
-            __shape = __tensor_descriptor.tensor_shape_info.v2.shape
-            __max_element_num += ((__shape[__channel_idx] / 16) + (0 if (__shape[__channel_idx] % 16) == 0 else 1)) * __npu_channel_group_stride
-            """
-            __max_element_num = ((__shape[__channel_idx] >> 4) + (0 if (__shape[__channel_idx] % 16) == 0 else 1)) * __npu_channel_group_stride
-        else:
-            __max_element_num = 0
-            __dimension_num = len(__tensor_descriptor.tensor_shape_info.v2.shape)
-
-            for dimension in range(__dimension_num):
-                __element_num = __tensor_descriptor.tensor_shape_info.v2.shape[dimension] * __tensor_descriptor.tensor_shape_info.v2.stride_npu[dimension]
-                if __element_num > __max_element_num:
-                    __max_element_num = __element_num
-
-        return np.zeros(shape=__max_element_num, dtype=__npu_ndarray_dtype).flatten()
-
-    quantization_parameters = tensor_descriptor.quantization_parameters
-    tensor_shape_info = tensor_descriptor.tensor_shape_info
-    npu_data_layout = tensor_descriptor.data_layout
-
-    quantization_max_value = 0
-    quantization_min_value = 0
-    radix = 0
-    scale = 0
-    quantization_factor = 0
-
-    channel_idx = 0
-    npu_channel_group_stride = -1
-
-    onnx_data_shape_index = None
-    onnx_data_buf_offset = 0
-    npu_data_buf_offset = 0
-
-    npu_data_element_u16b = 0
-    npu_data_high_bit_offset = 16
-
-    npu_data_dtype = np.int8
-
-    if tensor_shape_info.version != kp.ModelTensorShapeInformationVersion.KP_MODEL_TENSOR_SHAPE_INFO_VERSION_2:
-        raise AttributeError('Unsupport ModelTensorShapeInformationVersion {}'.format(tensor_descriptor.tensor_shape_info.version))
-
-    """
-    input data quantization
-    """
-    if npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_4W4C8B,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8B,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8B_CH_COMPACT,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_16W1C8B,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_RAW_8B,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW4C8B_KEEP_A,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW4C8B_DROP_A,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW1C8B]:
-        quantization_max_value = np.iinfo(np.int8).max
-        quantization_min_value = np.iinfo(np.int8).min
-        npu_data_dtype = np.int8
-    elif npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_8W1C16B,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_RAW_16B,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_4W4C8BHL,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8BHL,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8BHL_CH_COMPACT,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_16W1C8BHL,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW1C16B_LE,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW1C16B_BE]:
-        quantization_max_value = np.iinfo(np.int16).max
-        quantization_min_value = np.iinfo(np.int16).min
-        npu_data_dtype = np.int16
-    elif npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_RAW_FLOAT]:
-        quantization_max_value = np.finfo(np.float32).max
-        quantization_min_value = np.finfo(np.float32).min
-        npu_data_dtype = np.float32
-    else:
-        raise AttributeError('Unsupport ModelTensorDataLayout {}'.format(npu_data_layout))
-
-
-    shape = np.array(tensor_shape_info.v2.shape, dtype=np.int32)
-    dimension_num = len(shape)
-    quantized_axis = quantization_parameters.v1.quantized_axis
-    radix = np.array([quantized_fixed_point_descriptor.radix for quantized_fixed_point_descriptor in quantization_parameters.v1.quantized_fixed_point_descriptor_list], dtype=np.int32)
-    scale = np.array([quantized_fixed_point_descriptor.scale.value for quantized_fixed_point_descriptor in quantization_parameters.v1.quantized_fixed_point_descriptor_list], dtype=np.float32)
-
-    quantization_factor = np.power(2, radix) * scale
-    if 1 < len(quantization_parameters.v1.quantized_fixed_point_descriptor_list):
-        quantization_factor = np.expand_dims(quantization_factor, axis=tuple([dimension for dimension in range(dimension_num) if dimension is not quantized_axis]))
-        quantization_factor = np.broadcast_to(array=quantization_factor, shape=shape)
-
-    onnx_quantized_data = (onnx_data * quantization_factor).astype(np.float32)
-    onnx_quantized_data = np.round(onnx_quantized_data)
-    onnx_quantized_data = np.clip(onnx_quantized_data, quantization_min_value, quantization_max_value).astype(npu_data_dtype)
-
-    """
-    flatten onnx/npu data
-    """
-    onnx_quantized_data_flatten = onnx_quantized_data.flatten()
-    npu_data_flatten = __get_npu_ndarray(__tensor_descriptor=tensor_descriptor, __npu_ndarray_dtype=npu_data_dtype)
-
-    '''
-    re-arrange data from onnx to npu
-    '''
-    onnx_data_shape_index = np.zeros(shape=(len(shape)), dtype=int)
-    stride_onnx = np.array(tensor_shape_info.v2.stride_onnx, dtype=int)
-    stride_npu = np.array(tensor_shape_info.v2.stride_npu, dtype=int)
-
-    if npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_4W4C8B,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8B,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8B_CH_COMPACT,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_16W1C8B,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_RAW_8B,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW4C8B_KEEP_A,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW4C8B_DROP_A,
-                           kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW1C8B]:
-        while True:
-            onnx_data_buf_offset = onnx_data_shape_index.dot(stride_onnx)
-            npu_data_buf_offset = onnx_data_shape_index.dot(stride_npu)
-
-            if npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8B]:
-                if -1 == npu_channel_group_stride:
-                    """ calculate channel group stride in C language
-                    for (int axis = 0; axis < (int)tensor_shape_info->shape_len; axis++) {
-                        if (1 == tensor_shape_info->stride_npu[axis]) {
-                            channel_idx = axis;
-                            continue;
-                        }
-
-                        npu_channel_group_stride_tmp = tensor_shape_info->stride_npu[axis] * tensor_shape_info->shape[axis];
-                        if (npu_channel_group_stride_tmp > npu_channel_group_stride)
-                            npu_channel_group_stride = npu_channel_group_stride_tmp;
-                    }
-
-                    npu_channel_group_stride -= 16;
-                    """
-                    channel_idx = np.where(stride_npu == 1)[0][0]
-                    dimension_stride = stride_npu * shape
-                    dimension_stride[channel_idx] = 0
-                    npu_channel_group_stride = np.max(dimension_stride.flatten()) - 16
-
-                """
-                npu_data_buf_offset += (onnx_data_shape_index[channel_idx] / 16) * npu_channel_group_stride
-                """
-                npu_data_buf_offset += (onnx_data_shape_index[channel_idx] >> 4) * npu_channel_group_stride
-
-            npu_data_flatten[npu_data_buf_offset] = onnx_quantized_data_flatten[onnx_data_buf_offset]
-
-            '''
-            update onnx_data_shape_index
-            '''
-            for dimension in range(dimension_num - 1, -1, -1):
-                onnx_data_shape_index[dimension] += 1
-                if onnx_data_shape_index[dimension] == shape[dimension]:
-                    if dimension == 0:
-                        break
-                    onnx_data_shape_index[dimension] = 0
-                    continue
-                else:
-                    break
-
-            if onnx_data_shape_index[0] == shape[0]:
-                break
-    elif npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_8W1C16B,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_RAW_16B,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW1C16B_LE]:
-        while True:
-            onnx_data_buf_offset = onnx_data_shape_index.dot(stride_onnx)
-            npu_data_buf_offset = onnx_data_shape_index.dot(stride_npu)
-
-            npu_data_element_u16b = np.frombuffer(buffer=onnx_quantized_data_flatten[onnx_data_buf_offset].tobytes(), dtype=np.uint16)
-            npu_data_flatten[npu_data_buf_offset] = np.frombuffer(buffer=(npu_data_element_u16b & 0xfffe).tobytes(), dtype=np.int16)
-
-            '''
-            update onnx_data_shape_index
-            '''
-            for dimension in range(dimension_num - 1, -1, -1):
-                onnx_data_shape_index[dimension] += 1
-                if onnx_data_shape_index[dimension] == shape[dimension]:
-                    if dimension == 0:
-                        break
-                    onnx_data_shape_index[dimension] = 0
-                    continue
-                else:
-                    break
-
-            if onnx_data_shape_index[0] == shape[0]:
-                break
-    elif npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_HW1C16B_BE]:
-        while True:
-            onnx_data_buf_offset = onnx_data_shape_index.dot(stride_onnx)
-            npu_data_buf_offset = onnx_data_shape_index.dot(stride_npu)
-
-            npu_data_element_u16b = np.frombuffer(buffer=onnx_quantized_data_flatten[onnx_data_buf_offset].tobytes(), dtype=np.uint16)
-            npu_data_element_u16b = np.frombuffer(buffer=(npu_data_element_u16b & 0xfffe).tobytes(), dtype=np.int16)
-            npu_data_flatten[npu_data_buf_offset] = npu_data_element_u16b.byteswap()
-
-            '''
-            update onnx_data_shape_index
-            '''
-            for dimension in range(dimension_num - 1, -1, -1):
-                onnx_data_shape_index[dimension] += 1
-                if onnx_data_shape_index[dimension] == shape[dimension]:
-                    if dimension == 0:
-                        break
-                    onnx_data_shape_index[dimension] = 0
-                    continue
-                else:
-                    break
-
-            if onnx_data_shape_index[0] == shape[0]:
-                break
-    elif npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_4W4C8BHL,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8BHL,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8BHL_CH_COMPACT,
-                             kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_16W1C8BHL]:
-        
-        npu_data_flatten = np.frombuffer(buffer=npu_data_flatten.tobytes(), dtype=np.uint8).copy()
-
-        while True:
-            onnx_data_buf_offset = onnx_data_shape_index.dot(stride_onnx)
-            npu_data_buf_offset = onnx_data_shape_index.dot(stride_npu)
-
-            if npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_1W16C8BHL]:
-                if -1 == npu_channel_group_stride:
-                    """ calculate channel group stride in C language
-                    for (int axis = 0; axis < (int)tensor_shape_info->shape_len; axis++) {
-                        if (1 == tensor_shape_info->stride_npu[axis]) {
-                            channel_idx = axis;
-                            continue;
-                        }
-
-                        npu_channel_group_stride_tmp = tensor_shape_info->stride_npu[axis] * tensor_shape_info->shape[axis];
-                        if (npu_channel_group_stride_tmp > npu_channel_group_stride)
-                            npu_channel_group_stride = npu_channel_group_stride_tmp;
-                    }
-
-                    npu_channel_group_stride -= 16;
-                    """
-                    channel_idx = np.where(stride_npu == 1)[0][0]
-                    dimension_stride = stride_npu * shape
-                    dimension_stride[channel_idx] = 0
-                    npu_channel_group_stride = np.max(dimension_stride.flatten()) - 16
-
-                """
-                npu_data_buf_offset += (onnx_data_shape_index[channel_idx] / 16) * npu_channel_group_stride
-                """
-                npu_data_buf_offset += (onnx_data_shape_index[channel_idx] >> 4) * npu_channel_group_stride
-
-            """
-            npu_data_buf_offset = (npu_data_buf_offset / 16) * 32 + (npu_data_buf_offset % 16)
-            """
-            npu_data_buf_offset = ((npu_data_buf_offset >> 4) << 5) + (npu_data_buf_offset & 15)
-
-            npu_data_element_u16b = np.frombuffer(buffer=onnx_quantized_data_flatten[onnx_data_buf_offset].tobytes(), dtype=np.uint16)
-            npu_data_element_u16b = (npu_data_element_u16b >> 1)
-            npu_data_flatten[npu_data_buf_offset] = (npu_data_element_u16b & 0x007f).astype(dtype=np.uint8)
-            npu_data_flatten[npu_data_buf_offset + npu_data_high_bit_offset] = ((npu_data_element_u16b >> 7) & 0x00ff).astype(dtype=np.uint8)
-
-            '''
-            update onnx_data_shape_index
-            '''
-            for dimension in range(dimension_num - 1, -1, -1):
-                onnx_data_shape_index[dimension] += 1
-                if onnx_data_shape_index[dimension] == shape[dimension]:
-                    if dimension == 0:
-                        break
-                    onnx_data_shape_index[dimension] = 0
-                    continue
-                else:
-                    break
-
-            if onnx_data_shape_index[0] == shape[0]:
-                break
-    elif npu_data_layout in [kp.ModelTensorDataLayout.KP_MODEL_TENSOR_DATA_LAYOUT_RAW_FLOAT]:
-        while True:
-            onnx_data_buf_offset = onnx_data_shape_index.dot(stride_onnx)
-            npu_data_buf_offset = onnx_data_shape_index.dot(stride_npu)
-
-            npu_data_flatten[npu_data_buf_offset] = onnx_quantized_data_flatten[onnx_data_buf_offset]
-
-            '''
-            update onnx_data_shape_index
-            '''
-            for dimension in range(dimension_num - 1, -1, -1):
-                onnx_data_shape_index[dimension] += 1
-                if onnx_data_shape_index[dimension] == shape[dimension]:
-                    if dimension == 0:
-                        break
-                    onnx_data_shape_index[dimension] = 0
-                    continue
-                else:
-                    break
-
-            if onnx_data_shape_index[0] == shape[0]:
-                break
-    else:
-        raise AttributeError('Unsupport ModelTensorDataLayout {}'.format(npu_data_layout))
-    
-    return npu_data_flatten.tobytes()

example_utils/ExamplePostProcess.py

@@ -1,344 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2022. Kneron Inc. All rights reserved.                        *
-# ******************************************************************************
-from typing import List
-
-from utils.ExampleValue import ExampleBoundingBox, ExampleYoloResult
-
-import os
-import sys
-import numpy as np
-
-PWD = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(1, os.path.join(PWD, '../..'))
-
-import kp
-
-YOLO_V3_CELL_BOX_NUM = 3
-YOLO_V3_BOX_FIX_CH = 5
-NMS_THRESH_YOLOV3 = 0.45
-NMS_THRESH_YOLOV5 = 0.5
-MAX_POSSIBLE_BOXES = 2000
-MODEL_SHIRNK_RATIO_TYV3 = [32, 16]
-MODEL_SHIRNK_RATIO_V5 = [8, 16, 32]
-YOLO_MAX_DETECTION_PER_CLASS = 100
-
-TINY_YOLO_V3_ANCHERS = np.array([
-    [[81, 82], [135, 169], [344, 319]],
-    [[23, 27], [37, 58], [81, 82]]
-])
-
-YOLO_V5_ANCHERS = np.array([
-    [[10, 13], [16, 30], [33, 23]],
-    [[30, 61], [62, 45], [59, 119]],
-    [[116, 90], [156, 198], [373, 326]]
-])
-
-
-def _sigmoid(x):
-    return 1. / (1. + np.exp(-x))
-
-
-def _iou(box_src, boxes_dst):
-    max_x1 = np.maximum(box_src[0], boxes_dst[:, 0])
-    max_y1 = np.maximum(box_src[1], boxes_dst[:, 1])
-    min_x2 = np.minimum(box_src[2], boxes_dst[:, 2])
-    min_y2 = np.minimum(box_src[3], boxes_dst[:, 3])
-
-    area_intersection = np.maximum(0, (min_x2 - max_x1)) * np.maximum(0, (min_y2 - max_y1))
-    area_src = (box_src[2] - box_src[0]) * (box_src[3] - box_src[1])
-    area_dst = (boxes_dst[:, 2] - boxes_dst[:, 0]) * (boxes_dst[:, 3] - boxes_dst[:, 1])
-    area_union = area_src + area_dst - area_intersection
-
-    iou = area_intersection / area_union
-
-    return iou
-
-
-def _boxes_scale(boxes, hardware_preproc_info: kp.HwPreProcInfo):
-    """
-    Kneron hardware image pre-processing will do cropping, resize, padding by following ordering:
-    1. cropping
-    2. resize
-    3. padding
-    """
-    ratio_w = hardware_preproc_info.img_width / hardware_preproc_info.resized_img_width
-    ratio_h = hardware_preproc_info.img_height / hardware_preproc_info.resized_img_height
-
-    # rollback padding
-    boxes[..., :4] = boxes[..., :4] - np.array([hardware_preproc_info.pad_left, hardware_preproc_info.pad_top,
-                                                hardware_preproc_info.pad_left, hardware_preproc_info.pad_top])
-
-    # scale coordinate
-    boxes[..., :4] = boxes[..., :4] * np.array([ratio_w, ratio_h, ratio_w, ratio_h])
-
-    return boxes
-
-
-def post_process_tiny_yolo_v3(inference_float_node_output_list: List[kp.InferenceFloatNodeOutput],
-                              hardware_preproc_info: kp.HwPreProcInfo,
-                              thresh_value: float,
-                              with_sigmoid: bool = True) -> ExampleYoloResult:
-    """
-    Tiny YOLO V3 post-processing function.
-
-    Parameters
-    ----------
-    inference_float_node_output_list : List[kp.InferenceFloatNodeOutput]
-        A floating-point output node list, it should come from
-        'kp.inference.generic_inference_retrieve_float_node()'.
-    hardware_preproc_info : kp.HwPreProcInfo
-        Information of Hardware Pre Process.
-    thresh_value : float
-        The threshold of YOLO postprocessing, range from 0.0 ~ 1.0
-    with_sigmoid: bool, default=True
-        Do sigmoid operation before postprocessing.
-
-    Returns
-    -------
-    yolo_result : utils.ExampleValue.ExampleYoloResult
-        YoloResult object contained the post-processed result.
-
-    See Also
-    --------
-    kp.core.connect_devices : To connect multiple (including one) Kneron devices.
-    kp.inference.generic_inference_retrieve_float_node : Retrieve single node output data from raw output buffer.
-    kp.InferenceFloatNodeOutput
-    kp.HwPreProcInfo
-    utils.ExampleValue.ExampleYoloResult
-    """
-    feature_map_list = []
-    candidate_boxes_list = []
-
-    for i in range(len(inference_float_node_output_list)):
-        anchor_offset = int(inference_float_node_output_list[i].shape[1] / YOLO_V3_CELL_BOX_NUM)
-        feature_map = inference_float_node_output_list[i].ndarray.transpose((0, 2, 3, 1))
-        feature_map = _sigmoid(feature_map) if with_sigmoid else feature_map
-        feature_map = feature_map.reshape((feature_map.shape[0],
-                                           feature_map.shape[1],
-                                           feature_map.shape[2],
-                                           YOLO_V3_CELL_BOX_NUM,
-                                           anchor_offset))
-
-        ratio_w = hardware_preproc_info.model_input_width / inference_float_node_output_list[i].shape[3]
-        ratio_h = hardware_preproc_info.model_input_height / inference_float_node_output_list[i].shape[2]
-        nrows = inference_float_node_output_list[i].shape[2]
-        ncols = inference_float_node_output_list[i].shape[3]
-        grids = np.expand_dims(np.stack(np.meshgrid(np.arange(ncols), np.arange(nrows)), 2), axis=0)
-
-        for anchor_idx in range(YOLO_V3_CELL_BOX_NUM):
-            feature_map[..., anchor_idx, 0:2] = (feature_map[..., anchor_idx, 0:2] + grids) * np.array(
-                [ratio_h, ratio_w])
-            feature_map[..., anchor_idx, 2:4] = (feature_map[..., anchor_idx, 2:4] * 2) ** 2 * TINY_YOLO_V3_ANCHERS[i][
-                anchor_idx]
-
-            feature_map[..., anchor_idx, 0:2] = feature_map[..., anchor_idx, 0:2] - (
-                        feature_map[..., anchor_idx, 2:4] / 2.)
-            feature_map[..., anchor_idx, 2:4] = feature_map[..., anchor_idx, 0:2] + feature_map[..., anchor_idx, 2:4]
-
-        feature_map = _boxes_scale(boxes=feature_map,
-                                   hardware_preproc_info=hardware_preproc_info)
-
-        feature_map_list.append(feature_map)
-
-    predict_bboxes = np.concatenate(
-        [np.reshape(feature_map, (-1, feature_map.shape[-1])) for feature_map in feature_map_list], axis=0)
-    predict_bboxes[..., 5:] = np.repeat(predict_bboxes[..., 4][..., np.newaxis],
-                                        predict_bboxes[..., 5:].shape[1],
-                                        axis=1) * predict_bboxes[..., 5:]
-    predict_bboxes_mask = (predict_bboxes[..., 5:] > thresh_value).sum(axis=1)
-    predict_bboxes = predict_bboxes[predict_bboxes_mask >= 1]
-
-    # nms
-    for class_idx in range(5, predict_bboxes.shape[1]):
-        candidate_boxes_mask = predict_bboxes[..., class_idx] > thresh_value
-        class_good_box_count = candidate_boxes_mask.sum()
-        if class_good_box_count == 1:
-            candidate_boxes_list.append(
-                ExampleBoundingBox(
-                    x1=round(float(predict_bboxes[candidate_boxes_mask, 0][0]), 4),
-                    y1=round(float(predict_bboxes[candidate_boxes_mask, 1][0]), 4),
-                    x2=round(float(predict_bboxes[candidate_boxes_mask, 2][0]), 4),
-                    y2=round(float(predict_bboxes[candidate_boxes_mask, 3][0]), 4),
-                    score=round(float(predict_bboxes[candidate_boxes_mask, class_idx][0]), 4),
-                    class_num=class_idx - 5
-                )
-            )
-        elif class_good_box_count > 1:
-            candidate_boxes = predict_bboxes[candidate_boxes_mask].copy()
-            candidate_boxes = candidate_boxes[candidate_boxes[:, class_idx].argsort()][::-1]
-
-            for candidate_box_idx in range(candidate_boxes.shape[0] - 1):
-                # origin python version post-processing
-                if 0 != candidate_boxes[candidate_box_idx][class_idx]:
-                    remove_mask = _iou(box_src=candidate_boxes[candidate_box_idx],
-                                        boxes_dst=candidate_boxes[candidate_box_idx + 1:]) > NMS_THRESH_YOLOV3
-                    candidate_boxes[candidate_box_idx + 1:][remove_mask, class_idx] = 0
-
-            good_count = 0
-            for candidate_box_idx in range(candidate_boxes.shape[0]):
-                if candidate_boxes[candidate_box_idx, class_idx] > 0:
-                    candidate_boxes_list.append(
-                        ExampleBoundingBox(
-                            x1=round(float(candidate_boxes[candidate_box_idx, 0]), 4),
-                            y1=round(float(candidate_boxes[candidate_box_idx, 1]), 4),
-                            x2=round(float(candidate_boxes[candidate_box_idx, 2]), 4),
-                            y2=round(float(candidate_boxes[candidate_box_idx, 3]), 4),
-                            score=round(float(candidate_boxes[candidate_box_idx, class_idx]), 4),
-                            class_num=class_idx - 5
-                        )
-                    )
-                    good_count += 1
-
-                    if YOLO_MAX_DETECTION_PER_CLASS == good_count:
-                        break
-
-    for idx, candidate_boxes in enumerate(candidate_boxes_list):
-        candidate_boxes_list[idx].x1 = 0 if (candidate_boxes_list[idx].x1 + 0.5 < 0) else int(
-                candidate_boxes_list[idx].x1 + 0.5)
-        candidate_boxes_list[idx].y1 = 0 if (candidate_boxes_list[idx].y1 + 0.5 < 0) else int(
-                candidate_boxes_list[idx].y1 + 0.5)
-        candidate_boxes_list[idx].x2 = int(hardware_preproc_info.img_width - 1) if (
-                candidate_boxes_list[idx].x2 + 0.5 > hardware_preproc_info.img_width - 1) else int(candidate_boxes_list[idx].x2 + 0.5)
-        candidate_boxes_list[idx].y2 = int(hardware_preproc_info.img_height - 1) if (
-                candidate_boxes_list[idx].y2 + 0.5 > hardware_preproc_info.img_height - 1) else int(candidate_boxes_list[idx].y2 + 0.5)
-
-    return ExampleYoloResult(
-        class_count=predict_bboxes.shape[1] - 5,
-        box_count=len(candidate_boxes_list),
-        box_list=candidate_boxes_list
-    )
-
-
-def post_process_yolo_v5(inference_float_node_output_list: List[kp.InferenceFloatNodeOutput],
-                         hardware_preproc_info: kp.HwPreProcInfo,
-                         thresh_value: float,
-                         with_sigmoid: bool = True) -> ExampleYoloResult:
-    """
-    YOLO V5 post-processing function.
-
-    Parameters
-    ----------
-    inference_float_node_output_list : List[kp.InferenceFloatNodeOutput]
-        A floating-point output node list, it should come from
-        'kp.inference.generic_inference_retrieve_float_node()'.
-    hardware_preproc_info : kp.HwPreProcInfo
-        Information of Hardware Pre Process.
-    thresh_value : float
-        The threshold of YOLO postprocessing, range from 0.0 ~ 1.0
-    with_sigmoid: bool, default=True
-        Do sigmoid operation before postprocessing.
-
-    Returns
-    -------
-    yolo_result : utils.ExampleValue.ExampleYoloResult
-        YoloResult object contained the post-processed result.
-
-    See Also
-    --------
-    kp.core.connect_devices : To connect multiple (including one) Kneron devices.
-    kp.inference.generic_inference_retrieve_float_node : Retrieve single node output data from raw output buffer.
-    kp.InferenceFloatNodeOutput
-    kp.HwPreProcInfo
-    utils.ExampleValue.ExampleYoloResult
-    """
-    feature_map_list = []
-    candidate_boxes_list = []
-
-    for i in range(len(inference_float_node_output_list)):
-        anchor_offset = int(inference_float_node_output_list[i].shape[1] / YOLO_V3_CELL_BOX_NUM)
-        feature_map = inference_float_node_output_list[i].ndarray.transpose((0, 2, 3, 1))
-        feature_map = _sigmoid(feature_map) if with_sigmoid else feature_map
-        feature_map = feature_map.reshape((feature_map.shape[0],
-                                           feature_map.shape[1],
-                                           feature_map.shape[2],
-                                           YOLO_V3_CELL_BOX_NUM,
-                                           anchor_offset))
-
-        ratio_w = hardware_preproc_info.model_input_width / inference_float_node_output_list[i].shape[3]
-        ratio_h = hardware_preproc_info.model_input_height / inference_float_node_output_list[i].shape[2]
-        nrows = inference_float_node_output_list[i].shape[2]
-        ncols = inference_float_node_output_list[i].shape[3]
-        grids = np.expand_dims(np.stack(np.meshgrid(np.arange(ncols), np.arange(nrows)), 2), axis=0)
-
-        for anchor_idx in range(YOLO_V3_CELL_BOX_NUM):
-            feature_map[..., anchor_idx, 0:2] = (feature_map[..., anchor_idx, 0:2] * 2. - 0.5 + grids) * np.array(
-                [ratio_h, ratio_w])
-            feature_map[..., anchor_idx, 2:4] = (feature_map[..., anchor_idx, 2:4] * 2) ** 2 * YOLO_V5_ANCHERS[i][
-                anchor_idx]
-
-            feature_map[..., anchor_idx, 0:2] = feature_map[..., anchor_idx, 0:2] - (
-                    feature_map[..., anchor_idx, 2:4] / 2.)
-            feature_map[..., anchor_idx, 2:4] = feature_map[..., anchor_idx, 0:2] + feature_map[..., anchor_idx, 2:4]
-
-        feature_map = _boxes_scale(boxes=feature_map,
-                                   hardware_preproc_info=hardware_preproc_info)
-
-        feature_map_list.append(feature_map)
-
-    predict_bboxes = np.concatenate(
-        [np.reshape(feature_map, (-1, feature_map.shape[-1])) for feature_map in feature_map_list], axis=0)
-    predict_bboxes[..., 5:] = np.repeat(predict_bboxes[..., 4][..., np.newaxis],
-                                        predict_bboxes[..., 5:].shape[1],
-                                        axis=1) * predict_bboxes[..., 5:]
-    predict_bboxes_mask = (predict_bboxes[..., 5:] > thresh_value).sum(axis=1)
-    predict_bboxes = predict_bboxes[predict_bboxes_mask >= 1]
-
-    # nms
-    for class_idx in range(5, predict_bboxes.shape[1]):
-        candidate_boxes_mask = predict_bboxes[..., class_idx] > thresh_value
-        class_good_box_count = candidate_boxes_mask.sum()
-        if class_good_box_count == 1:
-            candidate_boxes_list.append(
-                ExampleBoundingBox(
-                    x1=round(float(predict_bboxes[candidate_boxes_mask, 0][0]), 4),
-                    y1=round(float(predict_bboxes[candidate_boxes_mask, 1][0]), 4),
-                    x2=round(float(predict_bboxes[candidate_boxes_mask, 2][0]), 4),
-                    y2=round(float(predict_bboxes[candidate_boxes_mask, 3][0]), 4),
-                    score=round(float(predict_bboxes[candidate_boxes_mask, class_idx][0]), 4),
-                    class_num=class_idx - 5
-                )
-            )
-        elif class_good_box_count > 1:
-            candidate_boxes = predict_bboxes[candidate_boxes_mask].copy()
-            candidate_boxes = candidate_boxes[candidate_boxes[:, class_idx].argsort()][::-1]
-
-            for candidate_box_idx in range(candidate_boxes.shape[0] - 1):
-                if 0 != candidate_boxes[candidate_box_idx][class_idx]:
-                    remove_mask = _iou(box_src=candidate_boxes[candidate_box_idx],
-                                       boxes_dst=candidate_boxes[candidate_box_idx + 1:]) > NMS_THRESH_YOLOV5
-                    candidate_boxes[candidate_box_idx + 1:][remove_mask, class_idx] = 0
-
-            good_count = 0
-            for candidate_box_idx in range(candidate_boxes.shape[0]):
-                if candidate_boxes[candidate_box_idx, class_idx] > 0:
-                    candidate_boxes_list.append(
-                        ExampleBoundingBox(
-                            x1=round(float(candidate_boxes[candidate_box_idx, 0]), 4),
-                            y1=round(float(candidate_boxes[candidate_box_idx, 1]), 4),
-                            x2=round(float(candidate_boxes[candidate_box_idx, 2]), 4),
-                            y2=round(float(candidate_boxes[candidate_box_idx, 3]), 4),
-                            score=round(float(candidate_boxes[candidate_box_idx, class_idx]), 4),
-                            class_num=class_idx - 5
-                        )
-                    )
-                    good_count += 1
-
-                    if YOLO_MAX_DETECTION_PER_CLASS == good_count:
-                        break
-
-    for idx, candidate_boxes in enumerate(candidate_boxes_list):
-        candidate_boxes_list[idx].x1 = 0 if (candidate_boxes_list[idx].x1 + 0.5 < 0) else int(
-                candidate_boxes_list[idx].x1 + 0.5)
-        candidate_boxes_list[idx].y1 = 0 if (candidate_boxes_list[idx].y1 + 0.5 < 0) else int(
-                candidate_boxes_list[idx].y1 + 0.5)
-        candidate_boxes_list[idx].x2 = int(hardware_preproc_info.img_width - 1) if (
-                candidate_boxes_list[idx].x2 + 0.5 > hardware_preproc_info.img_width - 1) else int(candidate_boxes_list[idx].x2 + 0.5)
-        candidate_boxes_list[idx].y2 = int(hardware_preproc_info.img_height - 1) if (
-                candidate_boxes_list[idx].y2 + 0.5 > hardware_preproc_info.img_height - 1) else int(candidate_boxes_list[idx].y2 + 0.5)
-
-    return ExampleYoloResult(
-        class_count=predict_bboxes.shape[1] - 5,
-        box_count=len(candidate_boxes_list),
-        box_list=candidate_boxes_list
-    )

example_utils/ExampleValue.py

@@ -1,126 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2022. Kneron Inc. All rights reserved.                        *
-# ******************************************************************************
-from typing import List
-
-import os
-import sys
-
-PWD = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(1, os.path.join(PWD, '../..'))
-
-from kp.KPBaseClass.ValueBase import ValueRepresentBase
-
-
-class ExampleBoundingBox(ValueRepresentBase):
-    """
-    Example Bounding box descriptor.
-
-    Attributes
-    ----------
-    x1 : int, default=0
-        X coordinate of bounding box top-left corner.
-    y1 : int, default=0
-        Y coordinate of bounding box top-left corner.
-    x2 : int, default=0
-        X coordinate of bounding box bottom-right corner.
-    y2 : int, default=0
-        Y coordinate of bounding box bottom-right corner.
-    score : float, default=0
-        Probability score.
-    class_num : int, default=0
-        Class # (of many) with highest probability.
-    """
-
-    def __init__(self,
-                 x1: int = 0,
-                 y1: int = 0,
-                 x2: int = 0,
-                 y2: int = 0,
-                 score: float = 0,
-                 class_num: int = 0):
-        """
-        Example Bounding box descriptor.
-
-        Parameters
-        ----------
-        x1 : int, default=0
-            X coordinate of bounding box top-left corner.
-        y1 : int, default=0
-            Y coordinate of bounding box top-left corner.
-        x2 : int, default=0
-            X coordinate of bounding box bottom-right corner.
-        y2 : int, default=0
-            Y coordinate of bounding box bottom-right corner.
-        score : float, default=0
-            Probability score.
-        class_num : int, default=0
-            Class # (of many) with highest probability.
-        """
-
-        self.x1 = x1
-        self.y1 = y1
-        self.x2 = x2
-        self.y2 = y2
-        self.score = score
-        self.class_num = class_num
-
-    def get_member_variable_dict(self) -> dict:
-        return {
-            'x1': self.x1,
-            'y1': self.y1,
-            'x2': self.x2,
-            'y2': self.y2,
-            'score': self.score,
-            'class_num': self.class_num
-        }
-
-
-class ExampleYoloResult(ValueRepresentBase):
-    """
-    Example YOLO output result descriptor.
-
-    Attributes
-    ----------
-    class_count : int, default=0
-        Total detectable class count.
-    box_count : int, default=0
-        Total bounding box number.
-    box_list : List[ExampleBoundingBox], default=[]
-        bounding boxes.
-    """
-
-    def __init__(self,
-                 class_count: int = 0,
-                 box_count: int = 0,
-                 box_list: List[ExampleBoundingBox] = []):
-        """
-        Example YOLO output result descriptor.
-
-        Parameters
-        ----------
-        class_count : int, default=0
-            Total detectable class count.
-        box_count : int, default=0
-            Total bounding box number.
-        box_list : List[ExampleBoundingBox], default=[]
-            bounding boxes.
-        """
-        self.class_count = class_count
-        self.box_count = box_count
-        self.box_list = box_list
-
-    def _cast_element_buffer(self) -> None:
-        pass
-
-    def get_member_variable_dict(self) -> dict:
-        member_variable_dict = {
-            'class_count': self.class_count,
-            'box_count': self.box_count,
-            'box_list': {}
-        }
-
-        for idx, box_element in enumerate(self.box_list):
-            member_variable_dict['box_list'][idx] = box_element.get_member_variable_dict()
-
-        return member_variable_dict

example_utils/__init__.py

@@ -1,4 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2021-2022. Kneron Inc. All rights reserved.                   *
-# ******************************************************************************
-

example_utils/postprocess/__init__.py

@@ -1,4 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2021-2022. Kneron Inc. All rights reserved.                   *
-# ******************************************************************************
-

example_utils/postprocess/basetrack.py

@@ -1,56 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2022. Kneron Inc. All rights reserved.                        *
-# ******************************************************************************
-import numpy as np
-from collections import OrderedDict
-
-
-class TrackState(object):
-    New = 0
-    Tracked = 1
-    Lost = 2
-    Removed = 3
-    #Overlap_candidate = 4
-
-
-class BaseTrack(object):
-    _count = 0
-
-    track_id = 0
-    is_activated = False
-    state = TrackState.New
-
-    history = OrderedDict()
-    features = []
-    curr_feature = None
-    score = 0
-    start_frame = 0
-    frame_id = 0
-    time_since_update = 0
-
-    # multi-camera
-    location = (np.inf, np.inf)
-
-    @property
-    def end_frame(self):
-        return self.frame_id
-
-    @staticmethod
-    def next_id():
-        BaseTrack._count += 1
-        return BaseTrack._count
-
-    def activate(self, *args):
-        raise NotImplementedError
-
-    def predict(self):
-        raise NotImplementedError
-
-    def update(self, *args, **kwargs):
-        raise NotImplementedError
-
-    def mark_lost(self):
-        self.state = TrackState.Lost
-
-    def mark_removed(self):
-        self.state = TrackState.Removed

example_utils/postprocess/bytetrack_postprocess.py

@@ -1,383 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2022. Kneron Inc. All rights reserved.                        *
-# ******************************************************************************
-import numpy as np
-from .kalman_filter import KalmanFilter
-from . import matching
-from .basetrack import BaseTrack, TrackState
-
-
-class STrack(BaseTrack):
-    shared_kalman = KalmanFilter()
-    def __init__(self, tlwh, score):
-
-        # wait activate
-        self._tlwh = np.asarray(tlwh, dtype=np.float32)
-        self.kalman_filter = None
-        self.mean, self.covariance = None, None
-        self.is_activated = False
-
-        self.score = score
-        self.tracklet_len = 0
-
-    def predict(self):
-        mean_state = self.mean.copy()
-        if self.state != TrackState.Tracked:
-            mean_state[7] = 0
-        self.mean, self.covariance = self.kalman_filter.predict(mean_state, self.covariance)
-
-    @staticmethod
-    def multi_predict(stracks):
-        if len(stracks) > 0:
-            multi_mean = np.asarray([st.mean.copy() for st in stracks])
-            multi_covariance = np.asarray([st.covariance for st in stracks])
-            for i, st in enumerate(stracks):
-                if st.state != TrackState.Tracked:
-                    multi_mean[i][7] = 0
-            multi_mean, multi_covariance = STrack.shared_kalman.multi_predict(multi_mean, multi_covariance)
-            for i, (mean, cov) in enumerate(zip(multi_mean, multi_covariance)):
-                stracks[i].mean = mean
-                stracks[i].covariance = cov
-
-    # NOTE  is activated is not triggered
-    def activate(self, kalman_filter, frame_id): # new-> track
-        """Start a new tracklet"""
-        self.kalman_filter = kalman_filter
-        self.track_id = self.next_id()
-        self.mean, self.covariance = self.kalman_filter.initiate(self.tlwh_to_xyah(self._tlwh))
-
-        self.tracklet_len = 0
-        self.state = TrackState.Tracked
-        if frame_id == 1: # only frame 1
-            self.is_activated = True
-        #self.is_activated = True
-        self.frame_id = frame_id
-        self.start_frame = frame_id
-
-    def re_activate(self, new_track, frame_id, new_id=False): # lost-> track
-        self.mean, self.covariance = self.kalman_filter.update(
-            self.mean, self.covariance, self.tlwh_to_xyah(new_track.tlwh)
-        )
-
-        self.tracklet_len = 0
-        self.state = TrackState.Tracked
-        self.is_activated = True
-        self.frame_id = frame_id
-        if new_id:
-            self.track_id = self.next_id()
-        self.score = new_track.score
-
-    def update(self, new_track, frame_id): # track-> track
-        """
-        Update a matched track
-        :type new_track: STrack
-        :type frame_id: int
-        :return:
-        """
-        self.frame_id = frame_id
-        self.tracklet_len += 1
-
-        new_tlwh = new_track.tlwh
-        self.mean, self.covariance = self.kalman_filter.update(
-            self.mean, self.covariance, self.tlwh_to_xyah(new_tlwh))
-        self.state = TrackState.Tracked
-        self.is_activated = True
-
-        self.score = new_track.score
-
-    @property
-    # @jit(nopython=True)
-    def tlwh(self):
-        """Get current position in bounding box format `(top left x, top left y,
-                width, height)`.
-        """
-        if self.mean is None:
-            return self._tlwh.copy()
-        ret = self.mean[:4].copy()
-        ret[2] *= ret[3]
-        ret[:2] -= ret[2:] / 2
-        return ret
-
-    @property
-    # @jit(nopython=True)
-    def tlbr(self):
-        """Convert bounding box to format `(min x, min y, max x, max y)`, i.e.,
-        `(top left, bottom right)`.
-        """
-        ret = self.tlwh.copy()
-        ret[2:] += ret[:2]
-        return ret
-
-    @property
-    # @jit(nopython=True)
-    def center(self):
-        """Convert bounding box to center
-        """
-        ret = self.tlwh.copy()
-        return ret[:2] + (ret[2:]/2)
-
-    @staticmethod
-    # @jit(nopython=True)
-    def tlwh_to_xyah(tlwh):
-        """Convert bounding box to format `(center x, center y, aspect ratio,
-        height)`, where the aspect ratio is `width / height`.
-        """
-        ret = np.asarray(tlwh).copy()
-        ret[:2] += ret[2:] / 2
-        ret[2] /= ret[3]
-        return ret
-
-    def to_xyah(self):
-        return self.tlwh_to_xyah(self.tlwh)
-
-    @staticmethod
-    # @jit(nopython=True)
-    def tlbr_to_tlwh(tlbr):
-        ret = np.asarray(tlbr).copy()
-        ret[2:] -= ret[:2]
-        return ret
-
-    @staticmethod
-    # @jit(nopython=True)
-    def tlwh_to_tlbr(tlwh):
-        ret = np.asarray(tlwh).copy()
-        ret[2:] += ret[:2]
-        return ret
-
-    def __repr__(self):
-        return 'OT_{}_({}-{})'.format(self.track_id, self.start_frame, self.end_frame)
-
-
-
-class BYTETracker(object): #
-    """
-    YTE tracker
-    :track_thresh: tau_high as defined in ByteTrack paper, this value separates the high/low score for tracking,
-    :              set to 0.6 in original paper, but for demo is set to 0.5
-    :              This value also has an impact on the det_thresh
-    :match_thresh: set to 0.9 in original paper, but for demo is set to 0.8
-    :frame_rate  : frame rate of input sequences
-    :track_buffer: how long we shall buffer the track
-    :max_time_lost: number of frames that keep in lost state, after that state: Lost-> Removed
-    :max_per_image: max number of output objects
-
-    """
-    def __init__(self, track_thresh = 0.6, match_thresh = 0.9, frame_rate=30, track_buffer = 120):
-
-        self.tracked_stracks = []  # type: list[STrack]
-        self.lost_stracks = []  # type: list[STrack]
-        self.removed_stracks = []  # type: list[STrack]
-
-        self.frame_id = 0
-        self.track_thresh = track_thresh
-        self.match_thresh = match_thresh
-        self.det_thresh = track_thresh + 0.1
-        self.buffer_size = int(frame_rate / 30.0 * track_buffer)
-        self.max_time_lost = self.buffer_size
-        self.mot20 = False #may open if high surveilance scenarios? (no fuse score)
-        self.kalman_filter = KalmanFilter()
-
-    def update(self, output_results):
-        '''
-        dets: list of bbox information [x, y, w, h, score, class]
-        '''
-
-        self.frame_id += 1
-        activated_starcks = []
-        refind_stracks = []
-        lost_stracks = []
-        removed_stracks = []
-
-
-        dets = []
-        dets_second = []
-        if len(output_results) > 0:
-            output_results = np.array(output_results)
-            #if output_results.ndim == 2:
-
-            scores = output_results[:, 4]
-            bboxes = output_results[:, :4]
-
-            ''' Step 1: get detections '''
-
-            remain_inds = scores > self.track_thresh
-            inds_low = scores > 0.1 # tau_Low
-            inds_high = scores < self.track_thresh
-
-            inds_second = np.logical_and(inds_low, inds_high)
-            dets_second = bboxes[inds_second] #D_low
-            dets = bboxes[remain_inds] #D_high
-            scores_keep = scores[remain_inds] #D_high_score
-            scores_second = scores[inds_second] #D_low_score
-
-        if len(dets) > 0:
-            '''Detections'''
-            detections = [STrack(tlwh, s) for
-                          (tlwh, s) in zip(dets, scores_keep)]
-        else:
-            detections = []
-
-        ''' Add newly detected tracklets to tracked_stracks'''
-        unconfirmed = []
-        tracked_stracks = []  # type: list[STrack]
-        for track in self.tracked_stracks:
-            if not track.is_activated:
-                unconfirmed.append(track)
-            else:
-                tracked_stracks.append(track)
-
-
-        ''' Step 2: First association, with high score detection boxes'''
-        strack_pool = joint_stracks(tracked_stracks, self.lost_stracks)
-        # Predict the current location with KF
-        STrack.multi_predict(strack_pool)
-        # for fairmot, it is with embedding distance and fuse_motion (kalman filter gating distance)
-        # for bytetrack, the distance is computed with IOU * detection scores
-        # which mean the matching
-        dists = matching.iou_distance(strack_pool, detections)
-        if not self.mot20:
-            dists = matching.fuse_score(dists, detections)
-        matches, u_track, u_detection = matching.linear_assignment(dists, thresh=self.match_thresh)
-
-        for itracked, idet in matches:
-            track = strack_pool[itracked]
-            det = detections[idet]
-            if track.state == TrackState.Tracked:
-                track.update(detections[idet], self.frame_id)
-                activated_starcks.append(track)
-            else:
-                track.re_activate(det, self.frame_id, new_id=False)
-                refind_stracks.append(track)
-
-        ''' Step 3: Second association, with low score detection boxes'''
-        # association the untrack to the low score detections
-
-        if len(dets_second) > 0:
-            '''Detections'''
-            detections_second = [STrack(tlwh, s) for
-                          (tlwh, s) in zip(dets_second, scores_second)]
-        else:
-            detections_second = []
-        r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]
-        dists = matching.iou_distance(r_tracked_stracks, detections_second)
-        matches, u_track, u_detection_second = matching.linear_assignment(dists, thresh=0.5)
-        for itracked, idet in matches:
-            track = r_tracked_stracks[itracked]
-            det = detections_second[idet]
-            if track.state == TrackState.Tracked:
-                track.update(det, self.frame_id)
-                activated_starcks.append(track)
-            else:
-                track.re_activate(det, self.frame_id, new_id=False)
-                refind_stracks.append(track)
-
-        for it in u_track:
-            track = r_tracked_stracks[it]
-            if not track.state == TrackState.Lost:
-                track.mark_lost()
-                lost_stracks.append(track)
-
-        '''Deal with unconfirmed tracks, usually tracks with only one beginning frame'''
-        detections = [detections[i] for i in u_detection]
-        dists = matching.iou_distance(unconfirmed, detections)
-        if not self.mot20:
-            dists = matching.fuse_score(dists, detections)
-        matches, u_unconfirmed, u_detection = matching.linear_assignment(dists, thresh=0.7)
-        for itracked, idet in matches:
-            unconfirmed[itracked].update(detections[idet], self.frame_id)
-            activated_starcks.append(unconfirmed[itracked])
-        for it in u_unconfirmed:
-            track = unconfirmed[it]
-            track.mark_removed()
-            removed_stracks.append(track)
-
-        """ Step 4: Init new stracks"""
-        for inew in u_detection:
-            track = detections[inew]
-            if track.score < self.det_thresh:
-                continue
-            track.activate(self.kalman_filter, self.frame_id)
-            activated_starcks.append(track)
-
-
-        """ Step 5: Update state"""
-        for track in self.lost_stracks:
-            if self.frame_id - track.end_frame > self.max_time_lost:
-                track.mark_removed()
-                removed_stracks.append(track)
-
-        self.tracked_stracks = [t for t in self.tracked_stracks if t.state == TrackState.Tracked]
-        self.tracked_stracks = joint_stracks(self.tracked_stracks, activated_starcks)
-        self.tracked_stracks = joint_stracks(self.tracked_stracks, refind_stracks)
-        self.lost_stracks = sub_stracks(self.lost_stracks, self.tracked_stracks)
-        self.lost_stracks.extend(lost_stracks)
-        self.lost_stracks = sub_stracks(self.lost_stracks, self.removed_stracks)
-        self.removed_stracks.extend(removed_stracks)
-        self.tracked_stracks, self.lost_stracks = remove_duplicate_stracks(self.tracked_stracks, self.lost_stracks)
-
-        # get scores of lost tracks
-        output_stracks = [track for track in self.tracked_stracks if track.is_activated]
-
-
-        return output_stracks
-
-
-def postprocess_(dets, tracker, min_box_area = 120, **kwargs):
-
-    '''
-    return: frame with bboxs
-    '''
-
-    online_targets = tracker.update(dets)
-    online_tlwhs = []
-    online_ids = []
-    for t in online_targets:
-        tlwh = t.tlwh
-        tid = t.track_id
-        #vertical = tlwh[2] / tlwh[3] > 1.6
-        #if tlwh[2] * tlwh[3] > min_box_area and not vertical:
-        online_tlwhs.append(np.round(tlwh, 2))
-        online_ids.append(tid)
-    return online_tlwhs, online_ids
-
-
-
-def joint_stracks(tlista, tlistb):
-    exists = {}
-    res = []
-    for t in tlista:
-        exists[t.track_id] = 1
-        res.append(t)
-    for t in tlistb:
-        tid = t.track_id
-        if not exists.get(tid, 0):
-            exists[tid] = 1
-            res.append(t)
-    return res
-
-# remove tlisb items from tlist a
-def sub_stracks(tlista, tlistb):
-    stracks = {}
-    for t in tlista:
-        stracks[t.track_id] = t
-    for t in tlistb:
-        tid = t.track_id
-        if stracks.get(tid, 0):
-            del stracks[tid]
-    return list(stracks.values())
-
-
-def remove_duplicate_stracks(stracksa, stracksb): # remove track overlap with 85 %
-    pdist = matching.iou_distance(stracksa, stracksb)
-    pairs = np.where(pdist < 0.15)
-    dupa, dupb = list(), list()
-    for p, q in zip(*pairs):
-        timep = stracksa[p].frame_id - stracksa[p].start_frame
-        timeq = stracksb[q].frame_id - stracksb[q].start_frame
-        if timep > timeq:
-            dupb.append(q)
-        else:
-            dupa.append(p)
-    resa = [t for i, t in enumerate(stracksa) if not i in dupa]
-    resb = [t for i, t in enumerate(stracksb) if not i in dupb]
-    return resa, resb

example_utils/postprocess/kalman_filter.py

@@ -1,274 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2022. Kneron Inc. All rights reserved.                        *
-# ******************************************************************************
-
-# vim: expandtab:ts=4:sw=4
-import numpy as np
-import scipy.linalg
-
-
-"""
-Table for the 0.95 quantile of the chi-square distribution with N degrees of
-freedom (contains values for N=1, ..., 9). Taken from MATLAB/Octave's chi2inv
-function and used as Mahalanobis gating threshold.
-"""
-chi2inv95 = {
-    1: 3.8415,
-    2: 5.9915,
-    3: 7.8147,
-    4: 9.4877,
-    5: 11.070,
-    6: 12.592,
-    7: 14.067,
-    8: 15.507,
-    9: 16.919}
-
-
-class KalmanFilter(object):
-    """
-    A simple Kalman filter for tracking bounding boxes in image space.
-
-    The 8-dimensional state space
-
-        x, y, a, h, vx, vy, va, vh
-
-    contains the bounding box center position (x, y), aspect ratio a, height h,
-    and their respective velocities.
-
-    Object motion follows a constant velocity model. The bounding box location
-    (x, y, a, h) is taken as direct observation of the state space (linear
-    observation model).
-
-    """
-
-    def __init__(self):
-        ndim, dt = 4, 1.
-
-        # Create Kalman filter model matrices.
-        self._motion_mat = np.eye(2 * ndim, 2 * ndim)
-        for i in range(ndim):
-            self._motion_mat[i, ndim + i] = dt
-        self._update_mat = np.eye(ndim, 2 * ndim)
-
-        # Motion and observation uncertainty are chosen relative to the current
-        # state estimate. These weights control the amount of uncertainty in
-        # the model. This is a bit hacky.
-        self._std_weight_position = 1. / 20
-        self._std_weight_velocity = 1. / 160
-
-    def initiate(self, measurement):
-        """Create track from unassociated measurement.
-
-        Parameters
-        ----------
-        measurement : ndarray
-            Bounding box coordinates (x, y, a, h) with center position (x, y),
-            aspect ratio a, and height h.
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the mean vector (8 dimensional) and covariance matrix (8x8
-            dimensional) of the new track. Unobserved velocities are initialized
-            to 0 mean.
-
-        """
-        mean_pos = measurement
-        mean_vel = np.zeros_like(mean_pos)
-        mean = np.r_[mean_pos, mean_vel]
-
-        std = [
-            2 * self._std_weight_position * measurement[3],
-            2 * self._std_weight_position * measurement[3],
-            1e-2,
-            2 * self._std_weight_position * measurement[3],
-            10 * self._std_weight_velocity * measurement[3],
-            10 * self._std_weight_velocity * measurement[3],
-            1e-5,
-            10 * self._std_weight_velocity * measurement[3]]
-        covariance = np.diag(np.square(std))
-        return mean, covariance
-
-    def predict(self, mean, covariance):
-        """Run Kalman filter prediction step.
-
-        Parameters
-        ----------
-        mean : ndarray
-            The 8 dimensional mean vector of the object state at the previous
-            time step.
-        covariance : ndarray
-            The 8x8 dimensional covariance matrix of the object state at the
-            previous time step.
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the mean vector and covariance matrix of the predicted
-            state. Unobserved velocities are initialized to 0 mean.
-
-        """
-        std_pos = [
-            self._std_weight_position * mean[3],
-            self._std_weight_position * mean[3],
-            1e-2,
-            self._std_weight_position * mean[3]]
-        std_vel = [
-            self._std_weight_velocity * mean[3],
-            self._std_weight_velocity * mean[3],
-            1e-5,
-            self._std_weight_velocity * mean[3]]
-        motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
-
-        #mean = np.dot(self._motion_mat, mean)
-        mean = np.dot(mean, self._motion_mat.T)
-        covariance = np.linalg.multi_dot((
-            self._motion_mat, covariance, self._motion_mat.T)) + motion_cov
-
-        return mean, covariance
-
-    def project(self, mean, covariance):
-        """Project state distribution to measurement space.
-
-        Parameters
-        ----------
-        mean : ndarray
-            The state's mean vector (8 dimensional array).
-        covariance : ndarray
-            The state's covariance matrix (8x8 dimensional).
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the projected mean and covariance matrix of the given state
-            estimate.
-
-        """
-        std = [
-            self._std_weight_position * mean[3],
-            self._std_weight_position * mean[3],
-            1e-1,
-            self._std_weight_position * mean[3]]
-        innovation_cov = np.diag(np.square(std))
-
-        mean = np.dot(self._update_mat, mean)
-        covariance = np.linalg.multi_dot((
-            self._update_mat, covariance, self._update_mat.T))
-        return mean, covariance + innovation_cov
-
-    def multi_predict(self, mean, covariance):
-        """Run Kalman filter prediction step (Vectorized version).
-        Parameters
-        ----------
-        mean : ndarray
-            The Nx8 dimensional mean matrix of the object states at the previous
-            time step.
-        covariance : ndarray
-            The Nx8x8 dimensional covariance matrics of the object states at the
-            previous time step.
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the mean vector and covariance matrix of the predicted
-            state. Unobserved velocities are initialized to 0 mean.
-        """
-        std_pos = [
-            self._std_weight_position * mean[:, 3],
-            self._std_weight_position * mean[:, 3],
-            1e-2 * np.ones_like(mean[:, 3]),
-            self._std_weight_position * mean[:, 3]]
-        std_vel = [
-            self._std_weight_velocity * mean[:, 3],
-            self._std_weight_velocity * mean[:, 3],
-            1e-5 * np.ones_like(mean[:, 3]),
-            self._std_weight_velocity * mean[:, 3]]
-        sqr = np.square(np.r_[std_pos, std_vel]).T
-
-        motion_cov = []
-        for i in range(len(mean)):
-            motion_cov.append(np.diag(sqr[i]))
-        motion_cov = np.asarray(motion_cov)
-
-        mean = np.dot(mean, self._motion_mat.T)
-        left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
-        covariance = np.dot(left, self._motion_mat.T) + motion_cov
-
-        return mean, covariance
-
-    def update(self, mean, covariance, measurement):
-        """Run Kalman filter correction step.
-
-        Parameters
-        ----------
-        mean : ndarray
-            The predicted state's mean vector (8 dimensional).
-        covariance : ndarray
-            The state's covariance matrix (8x8 dimensional).
-        measurement : ndarray
-            The 4 dimensional measurement vector (x, y, a, h), where (x, y)
-            is the center position, a the aspect ratio, and h the height of the
-            bounding box.
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the measurement-corrected state distribution.
-
-        """
-        projected_mean, projected_cov = self.project(mean, covariance)
-
-        chol_factor, lower = scipy.linalg.cho_factor(
-            projected_cov, lower=True, check_finite=False)
-        kalman_gain = scipy.linalg.cho_solve(
-            (chol_factor, lower), np.dot(covariance, self._update_mat.T).T,
-            check_finite=False).T
-        innovation = measurement - projected_mean
-
-        new_mean = mean + np.dot(innovation, kalman_gain.T)
-        new_covariance = covariance - np.linalg.multi_dot((
-            kalman_gain, projected_cov, kalman_gain.T))
-        return new_mean, new_covariance
-
-    def gating_distance(self, mean, covariance, measurements,
-                        only_position=False, metric='maha'):
-        """Compute gating distance between state distribution and measurements.
-        A suitable distance threshold can be obtained from `chi2inv95`. If
-        `only_position` is False, the chi-square distribution has 4 degrees of
-        freedom, otherwise 2.
-        Parameters
-        ----------
-        mean : ndarray
-            Mean vector over the state distribution (8 dimensional).
-        covariance : ndarray
-            Covariance of the state distribution (8x8 dimensional).
-        measurements : ndarray
-            An Nx4 dimensional matrix of N measurements, each in
-            format (x, y, a, h) where (x, y) is the bounding box center
-            position, a the aspect ratio, and h the height.
-        only_position : Optional[bool]
-            If True, distance computation is done with respect to the bounding
-            box center position only.
-        Returns
-        -------
-        ndarray
-            Returns an array of length N, where the i-th element contains the
-            squared Mahalanobis distance between (mean, covariance) and
-            `measurements[i]`.
-        """
-        mean, covariance = self.project(mean, covariance)
-        if only_position:
-            mean, covariance = mean[:2], covariance[:2, :2]
-            measurements = measurements[:, :2]
-
-        d = measurements - mean
-        if metric == 'gaussian':
-            return np.sum(d * d, axis=1)
-        elif metric == 'maha':
-            cholesky_factor = np.linalg.cholesky(covariance)
-            z = scipy.linalg.solve_triangular(
-                cholesky_factor, d.T, lower=True, check_finite=False,
-                overwrite_b=True)
-            squared_maha = np.sum(z * z, axis=0)
-            return squared_maha
-        else:
-            raise ValueError('invalid distance metric')

example_utils/postprocess/matching.py

@@ -1,481 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2022. Kneron Inc. All rights reserved.                        *
-# ******************************************************************************
-import cv2
-import numpy as np
-#import scipy
-from scipy.spatial.distance import cdist
-
-#from cython_bbox import bbox_overlaps as bbox_ious
-#import lap
-
-def linear_sum_assignment(cost_matrix,
-                          extend_cost=False,
-                          cost_limit=np.inf,
-                          return_cost=True):
-    """Solve the linear sum assignment problem.
-    The linear sum assignment problem is also known as minimum weight matching
-    in bipartite graphs. A problem instance is described by a matrix C, where
-    each C[i,j] is the cost of matching vertex i of the first partite set
-    (a "worker") and vertex j of the second set (a "job"). The goal is to find
-    a complete assignment of workers to jobs of minimal cost.
-    Formally, let X be a boolean matrix where :math:`X[i,j] = 1` iff row i is
-    assigned to column j. Then the optimal assignment has cost
-    .. math::
-        \min \sum_i \sum_j C_{i,j} X_{i,j}
-    s.t. each row is assignment to at most one column, and each column to at
-    most one row.
-    This function can also solve a generalization of the classic assignment
-    problem where the cost matrix is rectangular. If it has more rows than
-    columns, then not every row needs to be assigned to a column, and vice
-    versa.
-    The method used is the Hungarian algorithm, also known as the Munkres or
-    Kuhn-Munkres algorithm.
-    Parameters
-    ----------
-    cost_matrix : array
-        The cost matrix of the bipartite graph.
-    Returns
-    -------
-    row_ind, col_ind : array
-        An array of row indices and one of corresponding column indices giving
-        the optimal assignment. The cost of the assignment can be computed
-        as ``cost_matrix[row_ind, col_ind].sum()``. The row indices will be
-        sorted; in the case of a square cost matrix they will be equal to
-        ``numpy.arange(cost_matrix.shape[0])``.
-    Notes
-    -----
-    .. versionadded:: 0.17.0
-    Examples
-    --------
-    >>> cost = np.array([[4, 1, 3], [2, 0, 5], [3, 2, 2]])
-    >>> from scipy.optimize import linear_sum_assignment
-    >>> row_ind, col_ind = linear_sum_assignment(cost)
-    >>> col_ind
-    array([1, 0, 2])
-    >>> cost[row_ind, col_ind].sum()
-    5
-    References
-    ----------
-    1. http://csclab.murraystate.edu/bob.pilgrim/445/munkres.html
-    2. Harold W. Kuhn. The Hungarian Method for the assignment problem.
-       *Naval Research Logistics Quarterly*, 2:83-97, 1955.
-    3. Harold W. Kuhn. Variants of the Hungarian method for assignment
-       problems. *Naval Research Logistics Quarterly*, 3: 253-258, 1956.
-    4. Munkres, J. Algorithms for the Assignment and Transportation Problems.
-       *J. SIAM*, 5(1):32-38, March, 1957.
-    5. https://en.wikipedia.org/wiki/Hungarian_algorithm
-    """
-    cost_c = cost_matrix
-    n_rows = cost_c.shape[0]
-    n_cols = cost_c.shape[1]
-    n = 0
-    if n_rows == n_cols:
-        n = n_rows
-    else:
-        if not extend_cost:
-            raise ValueError(
-                'Square cost array expected. If cost is intentionally '
-                'non-square, pass extend_cost=True.')
-
-    if extend_cost or cost_limit < np.inf:
-        n = n_rows + n_cols
-        cost_c_extended = np.empty((n, n), dtype=np.double)
-        if cost_limit < np.inf:
-            cost_c_extended[:] = cost_limit / 2.
-        else:
-            cost_c_extended[:] = cost_c.max() + 1
-        cost_c_extended[n_rows:, n_cols:] = 0
-        cost_c_extended[:n_rows, :n_cols] = cost_c
-        cost_matrix = cost_c_extended
-
-    cost_matrix = np.asarray(cost_matrix)
-    if len(cost_matrix.shape) != 2:
-        raise ValueError("expected a matrix (2-d array), got a %r array" %
-                         (cost_matrix.shape, ))
-
-    # The algorithm expects more columns than rows in the cost matrix.
-    if cost_matrix.shape[1] < cost_matrix.shape[0]:
-        cost_matrix = cost_matrix.T
-        transposed = True
-    else:
-        transposed = False
-
-    state = _Hungary(cost_matrix)
-
-    # No need to bother with assignments if one of the dimensions
-    # of the cost matrix is zero-length.
-    step = None if 0 in cost_matrix.shape else _step1
-
-    while step is not None:
-        step = step(state)
-
-    if transposed:
-        marked = state.marked.T
-    else:
-        marked = state.marked
-    return np.where(marked == 1)
-
-
-class _Hungary(object):
-    """State of the Hungarian algorithm.
-    Parameters
-    ----------
-    cost_matrix : 2D matrix
-        The cost matrix. Must have shape[1] >= shape[0].
-    """
-
-    def __init__(self, cost_matrix):
-        self.C = cost_matrix.copy()
-
-        n, m = self.C.shape
-        self.row_uncovered = np.ones(n, dtype=bool)
-        self.col_uncovered = np.ones(m, dtype=bool)
-        self.Z0_r = 0
-        self.Z0_c = 0
-        self.path = np.zeros((n + m, 2), dtype=int)
-        self.marked = np.zeros((n, m), dtype=int)
-
-    def _clear_covers(self):
-        """Clear all covered matrix cells"""
-        self.row_uncovered[:] = True
-        self.col_uncovered[:] = True
-
-
-# Individual steps of the algorithm follow, as a state machine: they return
-# the next step to be taken (function to be called), if any.
-
-
-def _step1(state):
-    """Steps 1 and 2 in the Wikipedia page."""
-
-    # Step 1: For each row of the matrix, find the smallest element and
-    # subtract it from every element in its row.
-    state.C -= state.C.min(axis=1)[:, np.newaxis]
-    # Step 2: Find a zero (Z) in the resulting matrix. If there is no
-    # starred zero in its row or column, star Z. Repeat for each element
-    # in the matrix.
-    for i, j in zip(*np.where(state.C == 0)):
-        if state.col_uncovered[j] and state.row_uncovered[i]:
-            state.marked[i, j] = 1
-            state.col_uncovered[j] = False
-            state.row_uncovered[i] = False
-
-    state._clear_covers()
-    return _step3
-
-
-def _step3(state):
-    """
-    Cover each column containing a starred zero. If n columns are covered,
-    the starred zeros describe a complete set of unique assignments.
-    In this case, Go to DONE, otherwise, Go to Step 4.
-    """
-    marked = (state.marked == 1)
-    state.col_uncovered[np.any(marked, axis=0)] = False
-
-    if marked.sum() < state.C.shape[0]:
-        return _step4
-
-
-def _step4(state):
-    """
-    Find a noncovered zero and prime it. If there is no starred zero
-    in the row containing this primed zero, Go to Step 5. Otherwise,
-    cover this row and uncover the column containing the starred
-    zero. Continue in this manner until there are no uncovered zeros
-    left. Save the smallest uncovered value and Go to Step 6.
-    """
-    # We convert to int as numpy operations are faster on int
-    C = (state.C == 0).astype(int)
-    covered_C = C * state.row_uncovered[:, np.newaxis]
-    covered_C *= np.asarray(state.col_uncovered, dtype=int)
-    n = state.C.shape[0]
-    m = state.C.shape[1]
-
-    while True:
-        # Find an uncovered zero
-        row, col = np.unravel_index(np.argmax(covered_C), (n, m))
-        if covered_C[row, col] == 0:
-            return _step6
-        else:
-            state.marked[row, col] = 2
-            # Find the first starred element in the row
-            star_col = np.argmax(state.marked[row] == 1)
-            if state.marked[row, star_col] != 1:
-                # Could not find one
-                state.Z0_r = row
-                state.Z0_c = col
-                return _step5
-            else:
-                col = star_col
-                state.row_uncovered[row] = False
-                state.col_uncovered[col] = True
-                covered_C[:,
-                          col] = C[:, col] * (np.asarray(state.row_uncovered,
-                                                         dtype=int))
-                covered_C[row] = 0
-
-
-def _step5(state):
-    """
-    Construct a series of alternating primed and starred zeros as follows.
-    Let Z0 represent the uncovered primed zero found in Step 4.
-    Let Z1 denote the starred zero in the column of Z0 (if any).
-    Let Z2 denote the primed zero in the row of Z1 (there will always be one).
-    Continue until the series terminates at a primed zero that has no starred
-    zero in its column. Unstar each starred zero of the series, star each
-    primed zero of the series, erase all primes and uncover every line in the
-    matrix. Return to Step 3
-    """
-    count = 0
-    path = state.path
-    path[count, 0] = state.Z0_r
-    path[count, 1] = state.Z0_c
-
-    while True:
-        # Find the first starred element in the col defined by
-        # the path.
-        row = np.argmax(state.marked[:, path[count, 1]] == 1)
-        if state.marked[row, path[count, 1]] != 1:
-            # Could not find one
-            break
-        else:
-            count += 1
-            path[count, 0] = row
-            path[count, 1] = path[count - 1, 1]
-
-        # Find the first prime element in the row defined by the
-        # first path step
-        col = np.argmax(state.marked[path[count, 0]] == 2)
-        if state.marked[row, col] != 2:
-            col = -1
-        count += 1
-        path[count, 0] = path[count - 1, 0]
-        path[count, 1] = col
-
-    # Convert paths
-    for i in range(count + 1):
-        if state.marked[path[i, 0], path[i, 1]] == 1:
-            state.marked[path[i, 0], path[i, 1]] = 0
-        else:
-            state.marked[path[i, 0], path[i, 1]] = 1
-
-    state._clear_covers()
-    # Erase all prime markings
-    state.marked[state.marked == 2] = 0
-    return _step3
-
-
-def _step6(state):
-    """
-    Add the value found in Step 4 to every element of each covered row,
-    and subtract it from every element of each uncovered column.
-    Return to Step 4 without altering any stars, primes, or covered lines.
-    """
-    # the smallest uncovered value in the matrix
-    if np.any(state.row_uncovered) and np.any(state.col_uncovered):
-        minval = np.min(state.C[state.row_uncovered], axis=0)
-        minval = np.min(minval[state.col_uncovered])
-        state.C[~state.row_uncovered] += minval
-        state.C[:, state.col_uncovered] -= minval
-    return _step4
-
-
-def bbox_ious(boxes, query_boxes):
-    """
-    Parameters
-    ----------
-    boxes: (N, 4) ndarray of float
-    query_boxes: (K, 4) ndarray of float
-    Returns
-    -------
-    overlaps: (N, K) ndarray of overlap between boxes and query_boxes
-    """
-    DTYPE = np.float32
-    N = boxes.shape[0]
-    K = query_boxes.shape[0]
-    overlaps = np.zeros((N, K), dtype=DTYPE)
-
-    for k in range(K):
-        box_area = ((query_boxes[k, 2] - query_boxes[k, 0] + 1) *
-                    (query_boxes[k, 3] - query_boxes[k, 1] + 1))
-        for n in range(N):
-            iw = (min(boxes[n, 2], query_boxes[k, 2]) -
-                  max(boxes[n, 0], query_boxes[k, 0]) + 1)
-            if iw > 0:
-                ih = (min(boxes[n, 3], query_boxes[k, 3]) -
-                      max(boxes[n, 1], query_boxes[k, 1]) + 1)
-                if ih > 0:
-                    ua = float((boxes[n, 2] - boxes[n, 0] + 1) *
-                               (boxes[n, 3] - boxes[n, 1] + 1) + box_area -
-                               iw * ih)
-                    overlaps[n, k] = iw * ih / ua
-    return overlaps
-
-
-   
-chi2inv95 = {
-    1: 3.8415,
-    2: 5.9915,
-    3: 7.8147,
-    4: 9.4877,
-    5: 11.070,
-    6: 12.592,
-    7: 14.067,
-    8: 15.507,
-    9: 16.919}
-
-def linear_assignment(cost_matrix, thresh):
-    if cost_matrix.size == 0:
-        return np.empty((0, 2), dtype=int), tuple(range(cost_matrix.shape[0])), tuple(range(cost_matrix.shape[1]))
-    '''
-    matches, unmatched_a, unmatched_b = [], [], []
-    # https://blog.csdn.net/u014386899/article/details/109224746
-    #https://github.com/gatagat/lap
-    # https://github.com/gatagat/lap/blob/c2b6309ba246d18205a71228cdaea67210e1a039/lap/lapmod.py
-    cost, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh)
-    #extend_cost: whether or not extend a non-square matrix [default: False]
-    #cost_limit: an upper limit for a cost of a single assignment
-    #            [default: np.inf]
-    for ix, mx in enumerate(x):
-        if mx >= 0:
-            matches.append([ix, mx])
-    unmatched_a = np.where(x < 0)[0]
-    unmatched_b = np.where(y < 0)[0]
-    matches = np.asarray(matches)
-    return matches, unmatched_a, unmatched_b
-    '''
-    cost_matrix_r, cost_matrix_c = cost_matrix.shape[:2]
-    r, c = linear_sum_assignment(cost_matrix,
-                                 extend_cost=True,
-                                 cost_limit=thresh)
-
-    sorted_c = sorted(range(len(c)), key=lambda k: c[k])
-    sorted_c = sorted_c[:cost_matrix_c]
-    sorted_c = np.asarray(sorted_c)
-    matches_c = []
-    for ix, mx in enumerate(c):
-        if mx < cost_matrix_c and ix < cost_matrix_r:
-            matches_c.append([ix, mx])
-    cut_c = c[:cost_matrix_r]
-    unmatched_r = np.where(cut_c >= cost_matrix_c)[0]
-    unmatched_c = np.where(sorted_c >= cost_matrix_r)[0]
-    matches_c = np.asarray(matches_c)
-    return matches_c, unmatched_r, unmatched_c
-        
-
-
-def computeIOU(rec1, rec2):
-    cx1, cy1, cx2, cy2 = rec1
-    gx1, gy1, gx2, gy2 = rec2
-    S_rec1 = (cx2 - cx1 + 1) * (cy2 - cy1 + 1)
-    S_rec2 = (gx2 - gx1 + 1) * (gy2 - gy1 + 1)
-    x1 = max(cx1, gx1)
-    y1 = max(cy1, gy1)
-    x2 = min(cx2, gx2)
-    y2 = min(cy2, gy2)
-
-    w = max(0, x2 - x1 + 1)
-    h = max(0, y2 - y1 + 1)
-    area = w * h
-    iou = area / (S_rec1 + S_rec2 - area)
-    return iou
-
-
-def ious(atlbrs, btlbrs):
-    """
-    Compute cost based on IoU
-    :type atlbrs: list[tlbr] | np.ndarray
-    :type atlbrs: list[tlbr] | np.ndarray
-
-    :rtype ious np.ndarray
-    """
-    ious = np.zeros((len(atlbrs), len(btlbrs)), dtype=np.float32)
-    if ious.size == 0:
-        return ious
-
-    ious = bbox_ious(
-        np.ascontiguousarray(atlbrs, dtype=np.float32),
-        np.ascontiguousarray(btlbrs, dtype=np.float32)
-    )
-
-    return ious
-
-
-def iou_distance(atracks, btracks):
-    """
-    Compute cost based on IoU
-    :type atracks: list[STrack]
-    :type btracks: list[STrack]
-
-    :rtype cost_matrix np.ndarray
-    """
-
-    if (len(atracks)>0 and isinstance(atracks[0], np.ndarray)) or (len(btracks) > 0 and isinstance(btracks[0], np.ndarray)):
-        atlbrs = atracks
-        btlbrs = btracks
-    else:
-        atlbrs = [track.tlbr for track in atracks]
-        btlbrs = [track.tlbr for track in btracks]
-    _ious = ious(atlbrs, btlbrs)
-    cost_matrix = 1 - _ious
-
-    return cost_matrix
-
-#https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.cdist.html
-
-def embedding_distance(tracks, detections, metric='cosine'):
-    """
-    :param tracks: list[STrack]
-    :param detections: list[BaseTrack]
-    :param metric:
-    :return: cost_matrix np.ndarray
-    """
-
-    cost_matrix = np.zeros((len(tracks), len(detections)), dtype=np.float32)
-    if cost_matrix.size == 0:
-        return cost_matrix
-    det_features = np.asarray([track.curr_feat for track in detections], dtype=np.float32)
-    #for i, track in enumerate(tracks):
-        #cost_matrix[i, :] = np.maximum(0.0, cdist(track.smooth_feat.reshape(1,-1), det_features, metric))
-    track_features = np.asarray([track.smooth_feat for track in tracks], dtype=np.float32)
-    cost_matrix = np.maximum(0.0, cdist(track_features, det_features, metric))  # Nomalized features
-    return cost_matrix
-
-
-def gate_cost_matrix(kf, cost_matrix, tracks, detections, only_position=False):
-    if cost_matrix.size == 0:
-        return cost_matrix
-    gating_dim = 2 if only_position else 4
-    gating_threshold = chi2inv95[gating_dim]
-    measurements = np.asarray([det.to_xyah() for det in detections])
-    for row, track in enumerate(tracks):
-        gating_distance = kf.gating_distance(
-            track.mean, track.covariance, measurements, only_position)
-        cost_matrix[row, gating_distance > gating_threshold] = np.inf
-    return cost_matrix
-
-
-def fuse_motion(kf, cost_matrix, tracks, detections, only_position=False, lambda_=0.98):
-    if cost_matrix.size == 0:
-        return cost_matrix
-    gating_dim = 2 if only_position else 4
-    gating_threshold = chi2inv95[gating_dim]
-    measurements = np.asarray([det.to_xyah() for det in detections])
-    for row, track in enumerate(tracks):
-        gating_distance = kf.gating_distance(
-            track.mean, track.covariance, measurements, only_position, metric='maha')
-        cost_matrix[row, gating_distance > gating_threshold] = np.inf
-        cost_matrix[row] = lambda_ * cost_matrix[row] + (1 - lambda_) * gating_distance
-    return cost_matrix
-
-def fuse_score(cost_matrix, detections):
-    if cost_matrix.size == 0:
-        return cost_matrix
-    iou_sim = 1 - cost_matrix
-    det_scores = np.array([det.score for det in detections])
-    det_scores = np.expand_dims(det_scores, axis=0).repeat(cost_matrix.shape[0], axis=0)
-    fuse_sim = iou_sim * det_scores
-    fuse_cost = 1 - fuse_sim
-    return fuse_cost

force_cleanup.py

@@ -1,142 +0,0 @@
-"""
-Force cleanup of all app data and processes
-"""
-
-import psutil
-import os
-import sys
-import time
-import tempfile
-
-def kill_all_python_processes():
-    """Force kill ALL Python processes (use with caution)"""
-    killed_processes = []
-    
-    for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
-        try:
-            if 'python' in proc.info['name'].lower():
-                print(f"Killing Python process: {proc.info['pid']} - {proc.info['name']}")
-                proc.kill()
-                killed_processes.append(proc.info['pid'])
-        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-            pass
-    
-    if killed_processes:
-        print(f"Killed {len(killed_processes)} Python processes")
-        time.sleep(3)  # Give more time for cleanup
-    else:
-        print("No Python processes found")
-
-def clear_shared_memory():
-    """Clear Qt shared memory"""
-    try:
-        from PyQt5.QtCore import QSharedMemory
-        app_names = ["Cluster4NPU", "cluster4npu", "main"]
-        
-        for app_name in app_names:
-            shared_mem = QSharedMemory(app_name)
-            if shared_mem.attach():
-                shared_mem.detach()
-                print(f"Cleared shared memory for: {app_name}")
-    except Exception as e:
-        print(f"Could not clear shared memory: {e}")
-
-def clean_all_temp_files():
-    """Remove all possible lock and temp files"""
-    possible_files = [
-        'app.lock',
-        '.app.lock',
-        'cluster4npu.lock',
-        '.cluster4npu.lock',
-        'main.lock',
-        '.main.lock'
-    ]
-    
-    # Check in current directory
-    current_dir_files = []
-    for filename in possible_files:
-        filepath = os.path.join(os.getcwd(), filename)
-        if os.path.exists(filepath):
-            try:
-                os.remove(filepath)
-                current_dir_files.append(filepath)
-                print(f"Removed: {filepath}")
-            except Exception as e:
-                print(f"Could not remove {filepath}: {e}")
-    
-    # Check in temp directory
-    temp_dir = tempfile.gettempdir()
-    temp_files = []
-    for filename in possible_files:
-        filepath = os.path.join(temp_dir, filename)
-        if os.path.exists(filepath):
-            try:
-                os.remove(filepath)
-                temp_files.append(filepath)
-                print(f"Removed: {filepath}")
-            except Exception as e:
-                print(f"Could not remove {filepath}: {e}")
-    
-    # Check in user home directory
-    home_dir = os.path.expanduser('~')
-    home_files = []
-    for filename in possible_files:
-        filepath = os.path.join(home_dir, filename)
-        if os.path.exists(filepath):
-            try:
-                os.remove(filepath)
-                home_files.append(filepath)
-                print(f"Removed: {filepath}")
-            except Exception as e:
-                print(f"Could not remove {filepath}: {e}")
-    
-    total_removed = len(current_dir_files) + len(temp_files) + len(home_files)
-    if total_removed == 0:
-        print("No lock files found")
-
-def force_unlock_files():
-    """Try to unlock any locked files"""
-    try:
-        # On Windows, try to reset file handles
-        import subprocess
-        result = subprocess.run(['tasklist', '/FI', 'IMAGENAME eq python.exe'], 
-                               capture_output=True, text=True, timeout=10)
-        if result.returncode == 0:
-            lines = result.stdout.strip().split('\n')
-            for line in lines[3:]:  # Skip header lines
-                if 'python.exe' in line:
-                    parts = line.split()
-                    if len(parts) >= 2:
-                        pid = parts[1]
-                        try:
-                            subprocess.run(['taskkill', '/F', '/PID', pid], timeout=5)
-                            print(f"Force killed PID: {pid}")
-                        except:
-                            pass
-    except Exception as e:
-        print(f"Could not force unlock files: {e}")
-
-if __name__ == '__main__':
-    print("FORCE CLEANUP - This will kill ALL Python processes!")
-    print("=" * 60)
-    
-    response = input("Are you sure? This will close ALL Python programs (y/N): ")
-    if response.lower() in ['y', 'yes']:
-        print("\n1. Killing all Python processes...")
-        kill_all_python_processes()
-        
-        print("\n2. Clearing shared memory...")
-        clear_shared_memory()
-        
-        print("\n3. Removing lock files...")
-        clean_all_temp_files()
-        
-        print("\n4. Force unlocking files...")
-        force_unlock_files()
-        
-        print("\n" + "=" * 60)
-        print("FORCE CLEANUP COMPLETE!")
-        print("All Python processes killed and lock files removed.")
-        print("You can now start the app with 'python main.py'")
-    else:
-        print("Cleanup cancelled.")

gentle_cleanup.py

@@ -1,121 +0,0 @@
-"""
-Gentle cleanup of app data (safer approach)
-"""
-
-import psutil
-import os
-import sys
-import time
-
-def find_and_kill_app_processes():
-    """Find and kill only the Cluster4NPU app processes"""
-    killed_processes = []
-    
-    for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'cwd']):
-        try:
-            if 'python' in proc.info['name'].lower():
-                cmdline = proc.info['cmdline']
-                cwd = proc.info['cwd']
-                
-                # Check if this is our app
-                if (cmdline and 
-                    (any('main.py' in arg for arg in cmdline) or
-                     any('cluster4npu' in arg.lower() for arg in cmdline) or
-                     (cwd and 'cluster4npu' in cwd.lower()))):
-                    
-                    print(f"Found app process: {proc.info['pid']}")
-                    print(f"  Command: {' '.join(cmdline) if cmdline else 'N/A'}")
-                    print(f"  Working dir: {cwd}")
-                    
-                    # Try gentle termination first
-                    proc.terminate()
-                    time.sleep(2)
-                    
-                    # If still running, force kill
-                    if proc.is_running():
-                        proc.kill()
-                        print(f"  Force killed: {proc.info['pid']}")
-                    else:
-                        print(f"  Gently terminated: {proc.info['pid']}")
-                    
-                    killed_processes.append(proc.info['pid'])
-                    
-        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-            pass
-    
-    if killed_processes:
-        print(f"\nKilled {len(killed_processes)} app processes")
-        time.sleep(2)
-    else:
-        print("No app processes found")
-
-def clear_app_locks():
-    """Remove only app-specific lock files"""
-    app_specific_locks = [
-        'cluster4npu.lock',
-        '.cluster4npu.lock',
-        'Cluster4NPU.lock',
-        'main.lock',
-        '.main.lock'
-    ]
-    
-    locations = [
-        os.getcwd(),  # Current directory
-        os.path.expanduser('~'),  # User home
-        os.path.join(os.path.expanduser('~'), '.cluster4npu'),  # App data dir
-        'C:\\temp' if os.name == 'nt' else '/tmp',  # System temp
-    ]
-    
-    removed_files = []
-    
-    for location in locations:
-        if not os.path.exists(location):
-            continue
-            
-        for lock_name in app_specific_locks:
-            lock_path = os.path.join(location, lock_name)
-            if os.path.exists(lock_path):
-                try:
-                    os.remove(lock_path)
-                    removed_files.append(lock_path)
-                    print(f"Removed lock: {lock_path}")
-                except Exception as e:
-                    print(f"Could not remove {lock_path}: {e}")
-    
-    if not removed_files:
-        print("No lock files found")
-
-def reset_shared_memory():
-    """Reset Qt shared memory for the app"""
-    try:
-        from PyQt5.QtCore import QSharedMemory
-        
-        shared_mem = QSharedMemory("Cluster4NPU")
-        if shared_mem.attach():
-            print("Found shared memory, detaching...")
-            shared_mem.detach()
-        
-        # Try to create and destroy to fully reset
-        if shared_mem.create(1):
-            shared_mem.detach()
-            print("Reset shared memory")
-            
-    except Exception as e:
-        print(f"Could not reset shared memory: {e}")
-
-if __name__ == '__main__':
-    print("Gentle App Cleanup")
-    print("=" * 30)
-    
-    print("\n1. Looking for app processes...")
-    find_and_kill_app_processes()
-    
-    print("\n2. Clearing app locks...")
-    clear_app_locks()
-    
-    print("\n3. Resetting shared memory...")
-    reset_shared_memory()
-    
-    print("\n" + "=" * 30)
-    print("Cleanup complete!")
-    print("You can now start the app with 'python main.py'")

kill_app_processes.py

@@ -1,66 +0,0 @@
-"""
-Kill any running app processes and clean up locks
-"""
-
-import psutil
-import os
-import sys
-import time
-
-def kill_python_processes():
-    """Kill any Python processes that might be running the app"""
-    killed_processes = []
-    
-    for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
-        try:
-            # Check if it's a Python process
-            if 'python' in proc.info['name'].lower():
-                cmdline = proc.info['cmdline']
-                if cmdline and any('main.py' in arg for arg in cmdline):
-                    print(f"Killing process: {proc.info['pid']} - {' '.join(cmdline)}")
-                    proc.kill()
-                    killed_processes.append(proc.info['pid'])
-        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
-            pass
-    
-    if killed_processes:
-        print(f"Killed {len(killed_processes)} Python processes")
-        time.sleep(2)  # Give processes time to cleanup
-    else:
-        print("No running app processes found")
-
-def clean_lock_files():
-    """Remove any lock files that might prevent app startup"""
-    possible_lock_files = [
-        'app.lock',
-        '.app.lock',
-        'cluster4npu.lock',
-        os.path.expanduser('~/.cluster4npu.lock'),
-        '/tmp/cluster4npu.lock',
-        'C:\\temp\\cluster4npu.lock'
-    ]
-    
-    removed_files = []
-    for lock_file in possible_lock_files:
-        try:
-            if os.path.exists(lock_file):
-                os.remove(lock_file)
-                removed_files.append(lock_file)
-                print(f"Removed lock file: {lock_file}")
-        except Exception as e:
-            print(f"Could not remove {lock_file}: {e}")
-    
-    if removed_files:
-        print(f"Removed {len(removed_files)} lock files")
-    else:
-        print("No lock files found")
-
-if __name__ == '__main__':
-    print("Cleaning up app processes and lock files...")
-    print("=" * 50)
-    
-    kill_python_processes()
-    clean_lock_files()
-    
-    print("=" * 50)
-    print("Cleanup complete! You can now start the app with 'python main.py'")

main.py

@@ -24,7 +24,7 @@ import os
 import tempfile
 from PyQt5.QtWidgets import QApplication, QMessageBox
 from PyQt5.QtGui import QFont
-from PyQt5.QtCore import Qt, QSharedMemory, QCoreApplication
+from PyQt5.QtCore import Qt, QSharedMemory
 
 # Import fcntl only on Unix-like systems
 try:
@@ -41,194 +41,119 @@ from ui.windows.login import DashboardLogin
 
 
 class SingleInstance:
-    """Enhanced single instance handler with better error recovery."""
+    """Ensure only one instance of the application can run."""
     
     def __init__(self, app_name="Cluster4NPU"):
         self.app_name = app_name
         self.shared_memory = QSharedMemory(app_name)
         self.lock_file = None
         self.lock_fd = None
-        self.process_check_enabled = True
+        
+    def _cleanup_stale_lock(self):
+        """Clean up stale lock files from previous crashes."""
+        try:
+            lock_path = os.path.join(tempfile.gettempdir(), f"{self.app_name}.lock")
+            if os.path.exists(lock_path):
+                # Try to remove stale lock file
+                if HAS_FCNTL:
+                    # On Unix systems, try to acquire lock to check if process is still alive
+                    try:
+                        test_fd = os.open(lock_path, os.O_RDWR)
+                        fcntl.lockf(test_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                        # If we got the lock, previous process is dead
+                        os.close(test_fd)
+                        os.unlink(lock_path)
+                    except (OSError, IOError):
+                        # Lock is held by another process
+                        pass
+                else:
+                    # On Windows, just try to remove the file
+                    # If it's locked by another process, this will fail
+                    try:
+                        os.unlink(lock_path)
+                    except OSError:
+                        pass
+        except Exception:
+            pass
         
     def is_running(self):
-        """Check if another instance is already running with recovery mechanisms."""
-        # First, try to detect and clean up stale instances
-        if self._detect_and_cleanup_stale_instances():
-            print("Cleaned up stale application instances")
+        """Check if another instance is already running."""
+        # First, clean up any stale locks
+        self._cleanup_stale_lock()
         
-        # Try shared memory approach
-        if self._check_shared_memory():
-            return True
-            
-        # Try file locking approach
-        if self._check_file_lock():
-            return True
-            
-        return False
-    
-    def _detect_and_cleanup_stale_instances(self):
-        """Detect and clean up stale instances that might have crashed."""
-        cleaned_up = False
-        
-        try:
-            import psutil
-            
-            # Check if there are any actual running processes
-            app_processes = []
-            for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'create_time']):
-                try:
-                    if 'python' in proc.info['name'].lower():
-                        cmdline = proc.info['cmdline']
-                        if cmdline and any('main.py' in arg for arg in cmdline):
-                            app_processes.append(proc)
-                except (psutil.NoSuchProcess, psutil.AccessDenied):
-                    continue
-            
-            # If no actual app processes are running, clean up stale locks
-            if not app_processes:
-                cleaned_up = self._force_cleanup_locks()
-                
-        except ImportError:
-            # psutil not available, try basic cleanup
-            cleaned_up = self._force_cleanup_locks()
-        except Exception as e:
-            print(f"Warning: Could not detect stale instances: {e}")
-            
-        return cleaned_up
-    
-    def _force_cleanup_locks(self):
-        """Force cleanup of stale locks."""
-        cleaned_up = False
-        
-        # Try to clean up shared memory
-        try:
-            if self.shared_memory.attach():
+        # Try to attach to existing shared memory
+        if self.shared_memory.attach():
+            # Try to write to shared memory to verify it's valid
+            try:
+                # If we can attach but can't access, it might be stale
                 self.shared_memory.detach()
-                cleaned_up = True
-        except:
-            pass
-            
-        # Try to clean up lock file
-        try:
-            lock_file = os.path.join(tempfile.gettempdir(), f"{self.app_name}.lock")
-            if os.path.exists(lock_file):
-                os.unlink(lock_file)
-                cleaned_up = True
-        except:
-            pass
-            
-        return cleaned_up
-    
-    def _check_shared_memory(self):
-        """Check shared memory for running instance."""
-        try:
-            # Try to attach to existing shared memory
-            if self.shared_memory.attach():
-                # Check if the shared memory is actually valid
-                try:
-                    # Try to read from it to verify it's not corrupted
-                    data = self.shared_memory.data()
-                    if data is not None:
-                        return True  # Valid instance found
-                    else:
-                        # Corrupted shared memory, clean it up
-                        self.shared_memory.detach()
-                except:
-                    # Error reading, clean up
-                    self.shared_memory.detach()
-            
-            # Try to create new shared memory
+                # Try to create new shared memory
+                if self.shared_memory.create(1):
+                    # Successfully created, no other instance
+                    pass
+                else:
+                    # Failed to create, another instance exists
+                    return True
+            except:
+                # Shared memory is stale, try to create new one
+                if not self.shared_memory.create(1):
+                    return True
+        else:
+            # Try to create the shared memory
             if not self.shared_memory.create(1):
-                # Could not create, but attachment failed too - might be corruption
-                return False
+                # Failed to create, likely another instance exists
+                return True
             
-        except Exception as e:
-            print(f"Warning: Shared memory check failed: {e}")
-            return False
-            
-        return False
-    
-    def _check_file_lock(self):
-        """Check file lock for running instance."""
+        # Also use file locking as backup
         try:
             self.lock_file = os.path.join(tempfile.gettempdir(), f"{self.app_name}.lock")
-            
             if HAS_FCNTL:
-                # Unix-like systems
-                try:
-                    self.lock_fd = os.open(self.lock_file, os.O_CREAT | os.O_EXCL | os.O_RDWR)
-                    fcntl.lockf(self.lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                    return False  # Successfully locked, no other instance
-                except (OSError, IOError):
-                    return True  # Could not lock, another instance exists
+                self.lock_fd = os.open(self.lock_file, os.O_CREAT | os.O_WRONLY, 0o644)
+                fcntl.lockf(self.lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                # Write PID to lock file
+                os.write(self.lock_fd, str(os.getpid()).encode())
+                os.fsync(self.lock_fd)
             else:
-                # Windows
-                try:
-                    self.lock_fd = os.open(self.lock_file, os.O_CREAT | os.O_EXCL | os.O_RDWR)
-                    return False  # Successfully created, no other instance
-                except (OSError, IOError):
-                    # File exists, but check if the process that created it is still running
-                    if self._is_lock_file_stale():
-                        # Stale lock file, remove it and try again
-                        try:
-                            os.unlink(self.lock_file)
-                            self.lock_fd = os.open(self.lock_file, os.O_CREAT | os.O_EXCL | os.O_RDWR)
-                            return False
-                        except:
-                            pass
-                    return True
+                # On Windows, use exclusive create
+                self.lock_fd = os.open(self.lock_file, os.O_CREAT | os.O_EXCL | os.O_RDWR)
+                os.write(self.lock_fd, str(os.getpid()).encode())
+        except (OSError, IOError):
+            # Another instance is running or we can't create lock
+            self._cleanup_on_error()
+            return True
             
-        except Exception as e:
-            print(f"Warning: File lock check failed: {e}")
-            return False
+        return False
     
-    def _is_lock_file_stale(self):
-        """Check if the lock file is from a stale process."""
-        try:
-            if not os.path.exists(self.lock_file):
-                return True
-                
-            # Check file age - if older than 5 minutes, consider it stale
-            import time
-            file_age = time.time() - os.path.getmtime(self.lock_file)
-            if file_age > 300:  # 5 minutes
-                return True
-                
-            # On Windows, we can't easily check if the process is still running
-            # without additional information, so we rely on age check
-            return False
-            
-        except:
-            return True  # If we can't check, assume it's stale
-    
-    def cleanup(self):
-        """Enhanced cleanup with better error handling."""
+    def _cleanup_on_error(self):
+        """Clean up resources when instance check fails."""
         try:
             if self.shared_memory.isAttached():
                 self.shared_memory.detach()
-        except Exception as e:
-            print(f"Warning: Could not detach shared memory: {e}")
-            
-        try:
-            if self.lock_fd is not None:
-                if HAS_FCNTL:
-                    fcntl.lockf(self.lock_fd, fcntl.LOCK_UN)
+            if self.lock_fd:
                 os.close(self.lock_fd)
                 self.lock_fd = None
-        except Exception as e:
-            print(f"Warning: Could not close lock file descriptor: {e}")
+        except:
+            pass
     
+    def cleanup(self):
+        """Clean up resources."""
         try:
-            if self.lock_file and os.path.exists(self.lock_file):
-                os.unlink(self.lock_file)
-        except Exception as e:
-            print(f"Warning: Could not remove lock file: {e}")
+            if self.shared_memory.isAttached():
+                self.shared_memory.detach()
                 
-    def force_cleanup(self):
-        """Force cleanup of all locks (use when app crashed)."""
-        print("Force cleaning up application locks...")
-        self._force_cleanup_locks()
-        print("Force cleanup completed")
+            if self.lock_fd:
+                try:
+                    if HAS_FCNTL:
+                        fcntl.lockf(self.lock_fd, fcntl.LOCK_UN)
+                    os.close(self.lock_fd)
+                    if self.lock_file and os.path.exists(self.lock_file):
+                        os.unlink(self.lock_file)
+                except Exception:
+                    pass
+                finally:
+                    self.lock_fd = None
+        except Exception:
+            pass
 
 
 def setup_application():
@@ -259,64 +184,24 @@ def setup_application():
 
 def main():
     """Main application entry point."""
-    # Ensure high DPI attributes are set BEFORE any QApplication is created
+    single_instance = None
+    
     try:
-        QCoreApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
-        QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
-    except Exception:
-        pass
-    # Check for command line arguments
-    if '--force-cleanup' in sys.argv or '--cleanup' in sys.argv:
-        print("Force cleanup mode enabled")
+        # Create a minimal QApplication first for the message box
+        temp_app = QApplication(sys.argv) if not QApplication.instance() else QApplication.instance()
+        
+        # Check for single instance
         single_instance = SingleInstance()
-        single_instance.force_cleanup()
-        print("Cleanup completed. You can now start the application normally.")
-        sys.exit(0)
         
-    # Check for help argument
-    if '--help' in sys.argv or '-h' in sys.argv:
-        print("Cluster4NPU Application")
-        print("Usage: python main.py [options]")
-        print("Options:")
-        print("  --force-cleanup, --cleanup    Force cleanup of stale application locks")
-        print("  --help, -h                    Show this help message")
-        sys.exit(0)
-    
-    # Create a minimal QApplication first for the message box (attributes already set above)
-    temp_app = QApplication(sys.argv) if not QApplication.instance() else QApplication.instance()
-    
-    # Check for single instance
-    single_instance = SingleInstance()
-    
-    if single_instance.is_running():
-        reply = QMessageBox.question(
-            None,
-            "Application Already Running",
-            "Cluster4NPU is already running. \n\n"
-            "Would you like to:\n"
-            "• Click 'Yes' to force cleanup and restart\n"
-            "• Click 'No' to cancel startup",
-            QMessageBox.Yes | QMessageBox.No,
-            QMessageBox.No
-        )
-        
-        if reply == QMessageBox.Yes:
-            print("User requested force cleanup...")
-            single_instance.force_cleanup()
-            print("Cleanup completed, proceeding with startup...")
-            # Create a new instance checker after cleanup
-            single_instance = SingleInstance()
-            if single_instance.is_running():
-                QMessageBox.critical(
-                    None,
-                    "Cleanup Failed",
-                    "Could not clean up the existing instance. Please restart your computer."
-                )
-                sys.exit(1)
-        else:
+        if single_instance.is_running():
+            QMessageBox.warning(
+                None,
+                "Application Already Running",
+                "Cluster4NPU is already running. Please check your taskbar or system tray.",
+            )
+            single_instance.cleanup()
             sys.exit(0)
         
-    try:
         # Setup the full application
         app = setup_application()
         
@@ -324,18 +209,37 @@ def main():
         dashboard = DashboardLogin()
         dashboard.show()
         
-        # Clean up single instance on app exit
+        # Set up cleanup handlers
         app.aboutToQuit.connect(single_instance.cleanup)
         
+        # Also handle system signals for cleanup
+        import signal
+        def signal_handler(signum, frame):
+            print(f"Received signal {signum}, cleaning up...")
+            single_instance.cleanup()
+            sys.exit(0)
+        
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+        
         # Start the application event loop
-        sys.exit(app.exec_())
+        exit_code = app.exec_()
+        
+        # Ensure cleanup even if aboutToQuit wasn't called
+        single_instance.cleanup()
+        sys.exit(exit_code)
         
     except Exception as e:
         print(f"Error starting application: {e}")
         import traceback
         traceback.print_exc()
-        single_instance.cleanup()
+        if single_instance:
+            single_instance.cleanup()
         sys.exit(1)
+    finally:
+        # Final cleanup attempt
+        if single_instance:
+            single_instance.cleanup()
 
 
 if __name__ == '__main__':

main.spec

@@ -1,38 +0,0 @@
-# -*- mode: python ; coding: utf-8 -*-
-
-
-a = Analysis(
-    ['main.py'],
-    pathex=[],
-    binaries=[],
-    datas=[('config', 'config'), ('core', 'core'), ('resources', 'resources'), ('ui', 'ui'), ('utils', 'utils'), ('C:\\Users\\mason\\miniconda3\\envs\\cluster\\Lib\\site-packages\\kp', 'kp\\')],
-    hiddenimports=['json', 'base64', 'os', 'pathlib', 'NodeGraphQt', 'threading', 'queue', 'collections', 'datetime', 'cv2', 'numpy', 'PyQt5.QtCore', 'PyQt5.QtWidgets', 'PyQt5.QtGui', 'sys', 'traceback', 'io', 'contextlib'],
-    hookspath=[],
-    hooksconfig={},
-    runtime_hooks=[],
-    excludes=[],
-    noarchive=False,
-    optimize=0,
-)
-pyz = PYZ(a.pure)
-
-exe = EXE(
-    pyz,
-    a.scripts,
-    a.binaries,
-    a.datas,
-    [],
-    name='main',
-    debug=False,
-    bootloader_ignore_signals=False,
-    strip=False,
-    upx=True,
-    upx_exclude=[],
-    runtime_tmpdir=None,
-    console=False,
-    disable_windowed_traceback=False,
-    argv_emulation=False,
-    target_arch=None,
-    codesign_identity=None,
-    entitlements_file=None,
-)

mutliseries.py

@@ -0,0 +1,193 @@
+import kp
+from collections import defaultdict
+from typing import Union
+import os
+import sys
+import argparse
+import time
+import threading
+import queue
+import numpy as np
+import cv2
+
+# PWD = os.path.dirname(os.path.abspath(__file__))
+# sys.path.insert(1, os.path.join(PWD, '..'))
+IMAGE_FILE_PATH = r"c:\Users\mason\Downloads\kneron_plus_v3.1.2\kneron_plus\res\images\people_talk_in_street_640x640.bmp"
+LOOP_TIME = 100
+
+
+def _image_send_function(_device_group: kp.DeviceGroup,
+                         _loop_time: int,
+                         _generic_inference_input_descriptor: kp.GenericImageInferenceDescriptor,
+                         _image: Union[bytes, np.ndarray],
+                         _image_format: kp.ImageFormat) -> None:
+    for _loop in range(_loop_time):
+        try:
+            _generic_inference_input_descriptor.inference_number = _loop
+            _generic_inference_input_descriptor.input_node_image_list = [kp.GenericInputNodeImage(
+                image=_image,
+                image_format=_image_format,
+                resize_mode=kp.ResizeMode.KP_RESIZE_ENABLE,
+                padding_mode=kp.PaddingMode.KP_PADDING_CORNER,
+                normalize_mode=kp.NormalizeMode.KP_NORMALIZE_KNERON
+            )]
+
+            kp.inference.generic_image_inference_send(device_group=device_groups[1],
+                                                      generic_inference_input_descriptor=_generic_inference_input_descriptor)
+        except kp.ApiKPException as exception:
+            print(' - Error: inference failed, error = {}'.format(exception))
+            exit(0)
+
+
+def _result_receive_function(_device_group: kp.DeviceGroup,
+                             _loop_time: int,
+                             _result_queue: queue.Queue) -> None:
+    _generic_raw_result = None
+
+    for _loop in range(_loop_time):
+        try:
+            _generic_raw_result = kp.inference.generic_image_inference_receive(device_group=device_groups[1])
+
+            if _generic_raw_result.header.inference_number != _loop:
+                print(' - Error: incorrect inference_number {} at frame {}'.format(
+                    _generic_raw_result.header.inference_number, _loop))
+
+            print('.', end='', flush=True)
+
+        except kp.ApiKPException as exception:
+            print(' - Error: inference failed, error = {}'.format(exception))
+            exit(0)
+
+    _result_queue.put(_generic_raw_result)
+
+model_path = ["C:\\Users\\mason\\Downloads\\kneron_plus_v3.1.2\\kneron_plus\\res\\models\\KL520\\yolov5-noupsample_w640h640_kn-model-zoo\\kl520_20005_yolov5-noupsample_w640h640.nef", r"C:\Users\mason\Downloads\kneron_plus_v3.1.2\kneron_plus\res\models\KL720\yolov5-noupsample_w640h640_kn-model-zoo\kl720_20005_yolov5-noupsample_w640h640.nef"]
+SCPU_FW_PATH_520 = "C:\\Users\\mason\\Downloads\\kneron_plus_v3.1.2\\kneron_plus\\res\\firmware\\KL520\\fw_scpu.bin"
+NCPU_FW_PATH_520 = "C:\\Users\\mason\\Downloads\\kneron_plus_v3.1.2\\kneron_plus\\res\\firmware\\KL520\\fw_ncpu.bin"
+SCPU_FW_PATH_720 = "C:\\Users\\mason\\Downloads\\kneron_plus_v3.1.2\\kneron_plus\\res\\firmware\\KL720\\fw_scpu.bin"
+NCPU_FW_PATH_720 = "C:\\Users\\mason\\Downloads\\kneron_plus_v3.1.2\\kneron_plus\\res\\firmware\\KL720\\fw_ncpu.bin"
+device_list = kp.core.scan_devices()
+
+grouped_devices = defaultdict(list)
+
+for device in device_list.device_descriptor_list:
+    grouped_devices[device.product_id].append(device.usb_port_id)
+    
+print(f"Found device groups: {dict(grouped_devices)}")
+
+device_groups = []
+
+for product_id, usb_port_id in grouped_devices.items():
+    try:
+        group = kp.core.connect_devices(usb_port_id)
+        device_groups.append(group)
+        print(f"Successfully connected to group for product ID {product_id} with ports{usb_port_id}")
+    except kp.ApiKPException as e:
+        print(f"Failed to connect to group for product ID {product_id}: {e}")
+        
+print(device_groups)
+
+print('[Set Device Timeout]')
+kp.core.set_timeout(device_group=device_groups[0], milliseconds=5000)
+kp.core.set_timeout(device_group=device_groups[1], milliseconds=5000)
+print(' - Success')
+
+try:
+    print('[Upload Firmware]')
+    kp.core.load_firmware_from_file(device_group=device_groups[0],
+                                    scpu_fw_path=SCPU_FW_PATH_520,
+                                    ncpu_fw_path=NCPU_FW_PATH_520)
+    kp.core.load_firmware_from_file(device_group=device_groups[1],
+                                    scpu_fw_path=SCPU_FW_PATH_720,
+                                    ncpu_fw_path=NCPU_FW_PATH_720)
+    print(' - Success')
+except kp.ApiKPException as exception:
+    print('Error: upload firmware failed, error = \'{}\''.format(str(exception)))
+    exit(0)
+
+print('[Upload Model]')
+model_nef_descriptors = []
+# for group in device_groups:
+model_nef_descriptor = kp.core.load_model_from_file(device_group=device_groups[0], file_path=model_path[0])
+model_nef_descriptors.append(model_nef_descriptor)
+model_nef_descriptor = kp.core.load_model_from_file(device_group=device_groups[1], file_path=model_path[1])
+model_nef_descriptors.append(model_nef_descriptor)
+print(' - Success')
+
+"""
+prepare the image
+"""
+print('[Read Image]')
+img = cv2.imread(filename=IMAGE_FILE_PATH)
+img_bgr565 = cv2.cvtColor(src=img, code=cv2.COLOR_BGR2BGR565)
+print(' - Success')
+
+"""
+prepare generic image inference input descriptor
+"""
+print(model_nef_descriptors)
+generic_inference_input_descriptor = kp.GenericImageInferenceDescriptor(
+    model_id=model_nef_descriptors[1].models[0].id,
+)
+
+"""
+starting inference work
+"""
+print('[Starting Inference Work]')
+print(' - Starting inference loop {} times'.format(LOOP_TIME))
+print(' - ', end='')
+result_queue = queue.Queue()
+
+send_thread = threading.Thread(target=_image_send_function, args=(device_groups[1],
+                                                                    LOOP_TIME,
+                                                                    generic_inference_input_descriptor,
+                                                                    img_bgr565,
+                                                                    kp.ImageFormat.KP_IMAGE_FORMAT_RGB565))
+
+receive_thread = threading.Thread(target=_result_receive_function, args=(device_groups[1],
+                                                                            LOOP_TIME,
+                                                                            result_queue))
+
+start_inference_time = time.time()
+
+send_thread.start()
+receive_thread.start()
+
+try:
+    while send_thread.is_alive():
+        send_thread.join(1)
+
+    while receive_thread.is_alive():
+        receive_thread.join(1)
+except (KeyboardInterrupt, SystemExit):
+    print('\n - Received keyboard interrupt, quitting threads.')
+    exit(0)
+
+end_inference_time = time.time()
+time_spent = end_inference_time - start_inference_time
+
+try:
+    generic_raw_result = result_queue.get(timeout=3)
+except Exception as exception:
+    print('Error: Result queue is empty !')
+    exit(0)
+print()
+
+print('[Result]')
+print(" - Total inference {} images".format(LOOP_TIME))
+print(" - Time spent: {:.2f} secs, FPS = {:.1f}".format(time_spent, LOOP_TIME / time_spent))
+
+"""
+retrieve inference node output 
+"""
+print('[Retrieve Inference Node Output ]')
+inf_node_output_list = []
+for node_idx in range(generic_raw_result.header.num_output_node):
+    inference_float_node_output = kp.inference.generic_inference_retrieve_float_node(node_idx=node_idx,
+                                                                                        generic_raw_result=generic_raw_result,
+                                                                                        channels_ordering=kp.ChannelOrdering.KP_CHANNEL_ORDERING_CHW)
+    inf_node_output_list.append(inference_float_node_output)
+
+print(' - Success')
+
+print('[Result]')
+print(inf_node_output_list)

test_multi_series_integration.py

@@ -0,0 +1,347 @@
+"""
+Test Multi-Series Dongle Integration
+
+This test script validates the complete multi-series dongle integration
+including the enhanced model node, converter, and pipeline components.
+
+Usage:
+    python test_multi_series_integration.py
+
+This will create a test assets folder structure and validate all components.
+"""
+
+import os
+import sys
+import json
+import tempfile
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+def test_exact_model_node():
+    """Test the enhanced ExactModelNode functionality"""
+    print("🧪 Testing ExactModelNode...")
+    
+    try:
+        from core.nodes.exact_nodes import ExactModelNode, NODEGRAPH_AVAILABLE
+        
+        if not NODEGRAPH_AVAILABLE:
+            print("⚠️  NodeGraphQt not available, testing limited functionality")
+            # Test basic instantiation
+            node = ExactModelNode()
+            print("✅ ExactModelNode basic instantiation works")
+            return True
+        
+        # Create node and test properties
+        node = ExactModelNode()
+        
+        # Test single-series mode (default)
+        assert node.get_property('multi_series_mode') == False
+        assert node.get_property('dongle_series') == '520'
+        assert node.get_property('max_queue_size') == 100
+        
+        # Test property display logic
+        display_props = node.get_display_properties()
+        expected_single_series = [
+            'multi_series_mode', 'model_path', 'scpu_fw_path', 'ncpu_fw_path', 
+            'dongle_series', 'num_dongles', 'port_id', 'upload_fw'
+        ]
+        assert display_props == expected_single_series
+        
+        # Test multi-series mode
+        node.set_property('multi_series_mode', True)
+        display_props = node.get_display_properties()
+        expected_multi_series = [
+            'multi_series_mode', 'assets_folder', 'enabled_series', 
+            'max_queue_size', 'result_buffer_size', 'batch_size',
+            'enable_preprocessing', 'enable_postprocessing'
+        ]
+        assert display_props == expected_multi_series
+        
+        # Test inference config generation
+        config = node.get_inference_config()
+        assert config['multi_series_mode'] == True
+        assert 'enabled_series' in config
+        
+        # Test hardware requirements
+        hw_req = node.get_hardware_requirements()
+        assert hw_req['multi_series_mode'] == True
+        
+        print("✅ ExactModelNode functionality tests passed")
+        return True
+        
+    except Exception as e:
+        print(f"❌ ExactModelNode test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_multi_series_setup_utility():
+    """Test the multi-series setup utility"""
+    print("🧪 Testing multi-series setup utility...")
+    
+    try:
+        from utils.multi_series_setup import MultiSeriesSetup
+        
+        # Create temporary directory for testing
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Test folder structure creation
+            success = MultiSeriesSetup.create_folder_structure(temp_dir, ['520', '720'])
+            assert success, "Failed to create folder structure"
+            
+            assets_path = os.path.join(temp_dir, 'Assets')
+            assert os.path.exists(assets_path), "Assets folder not created"
+            
+            # Check structure
+            firmware_path = os.path.join(assets_path, 'Firmware')
+            models_path = os.path.join(assets_path, 'Models')
+            assert os.path.exists(firmware_path), "Firmware folder not created"
+            assert os.path.exists(models_path), "Models folder not created"
+            
+            # Check series folders
+            for series in ['520', '720']:
+                series_fw = os.path.join(firmware_path, f'KL{series}')
+                series_model = os.path.join(models_path, f'KL{series}')
+                assert os.path.exists(series_fw), f"KL{series} firmware folder not created"
+                assert os.path.exists(series_model), f"KL{series} models folder not created"
+            
+            # Test validation (should fail initially - no files)
+            is_valid, issues = MultiSeriesSetup.validate_folder_structure(assets_path)
+            assert not is_valid, "Validation should fail with empty folders"
+            assert len(issues) > 0, "Should have validation issues"
+            
+            # Test series listing
+            series_info = MultiSeriesSetup.list_available_series(assets_path)
+            assert len(series_info) == 0, "Should have no valid series initially"
+            
+        print("✅ Multi-series setup utility tests passed")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Multi-series setup utility test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_multi_series_converter():
+    """Test the multi-series MFlow converter"""
+    print("🧪 Testing multi-series converter...")
+    
+    try:
+        from core.functions.multi_series_mflow_converter import MultiSeriesMFlowConverter
+        
+        # Create test mflow data
+        test_mflow_data = {
+            "project_name": "Test Multi-Series Pipeline",
+            "description": "Test pipeline with multi-series configuration",
+            "nodes": [
+                {
+                    "id": "input_1",
+                    "name": "Input Node",
+                    "type": "input_node",
+                    "custom": {
+                        "source_type": "Camera",
+                        "resolution": "640x480"
+                    }
+                },
+                {
+                    "id": "model_1", 
+                    "name": "Multi-Series Model",
+                    "type": "model_node",
+                    "custom": {
+                        "multi_series_mode": True,
+                        "assets_folder": "/test/assets",
+                        "enabled_series": ["520", "720"],
+                        "max_queue_size": 100,
+                        "result_buffer_size": 1000
+                    }
+                },
+                {
+                    "id": "output_1",
+                    "name": "Output Node", 
+                    "type": "output_node",
+                    "custom": {
+                        "output_type": "Display"
+                    }
+                }
+            ],
+            "connections": [
+                {"input_node": "input_1", "output_node": "model_1"},
+                {"input_node": "model_1", "output_node": "output_1"}
+            ]
+        }
+        
+        # Test converter instantiation
+        converter = MultiSeriesMFlowConverter()
+        
+        # Test basic conversion (will fail validation due to missing files, but should parse)
+        try:
+            config = converter._convert_mflow_to_enhanced_config(test_mflow_data)
+            
+            # Check basic structure
+            assert config.pipeline_name == "Test Multi-Series Pipeline"
+            assert len(config.stage_configs) > 0
+            assert config.has_multi_series == True
+            assert config.multi_series_count == 1
+            
+            print("✅ Multi-series converter basic parsing works")
+            
+        except ValueError as e:
+            # Expected to fail validation due to missing assets folder
+            if "not found" in str(e):
+                print("✅ Multi-series converter correctly validates missing assets")
+            else:
+                raise
+        
+        print("✅ Multi-series converter tests passed")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Multi-series converter test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_pipeline_components():
+    """Test multi-series pipeline components"""
+    print("🧪 Testing pipeline components...")
+    
+    try:
+        from core.functions.multi_series_pipeline import (
+            MultiSeriesStageConfig, 
+            MultiSeriesPipelineStage,
+            create_multi_series_config_from_model_node
+        )
+        
+        # Test MultiSeriesStageConfig creation
+        config = MultiSeriesStageConfig(
+            stage_id="test_stage",
+            multi_series_mode=True,
+            firmware_paths={"KL520": {"scpu": "test.bin", "ncpu": "test.bin"}},
+            model_paths={"KL520": "test.nef"},
+            max_queue_size=100
+        )
+        
+        assert config.stage_id == "test_stage"
+        assert config.multi_series_mode == True
+        assert config.max_queue_size == 100
+        
+        # Test config creation from model node
+        model_config = {
+            'multi_series_mode': True,
+            'node_name': 'test_node',
+            'firmware_paths': {"KL520": {"scpu": "test.bin", "ncpu": "test.bin"}},
+            'model_paths': {"KL520": "test.nef"},
+            'max_queue_size': 50
+        }
+        
+        stage_config = create_multi_series_config_from_model_node(model_config)
+        assert stage_config.multi_series_mode == True
+        assert stage_config.stage_id == 'test_node'
+        
+        print("✅ Pipeline components tests passed")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Pipeline components test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def create_test_assets_structure():
+    """Create a complete test assets structure for manual testing"""
+    print("🏗️  Creating test assets structure...")
+    
+    try:
+        from utils.multi_series_setup import MultiSeriesSetup
+        
+        # Create test structure in project directory
+        test_assets_path = os.path.join(project_root, "test_assets")
+        
+        if os.path.exists(test_assets_path):
+            import shutil
+            shutil.rmtree(test_assets_path)
+        
+        # Create structure
+        success = MultiSeriesSetup.create_folder_structure(
+            project_root, 
+            series_list=['520', '720', '730']
+        )
+        
+        if success:
+            assets_full_path = os.path.join(project_root, "Assets")
+            print(f"✅ Test assets structure created at: {assets_full_path}")
+            print("\n📋 To complete the setup:")
+            print("1. Copy your firmware files to Assets/Firmware/KLxxx/ folders")
+            print("2. Copy your model files to Assets/Models/KLxxx/ folders")
+            print("3. Run validation: python -m utils.multi_series_setup validate --path Assets")
+            print("4. Configure your model node to use the Assets folder")
+            
+            return assets_full_path
+        else:
+            print("❌ Failed to create test assets structure")
+            return None
+            
+    except Exception as e:
+        print(f"❌ Error creating test assets structure: {e}")
+        return None
+
+def run_all_tests():
+    """Run all integration tests"""
+    print("🚀 Starting Multi-Series Dongle Integration Tests\n")
+    
+    tests = [
+        ("ExactModelNode", test_exact_model_node),
+        ("Setup Utility", test_multi_series_setup_utility), 
+        ("Converter", test_multi_series_converter),
+        ("Pipeline Components", test_pipeline_components)
+    ]
+    
+    results = {}
+    
+    for test_name, test_func in tests:
+        print(f"\n{'='*50}")
+        print(f"Testing: {test_name}")
+        print(f"{'='*50}")
+        
+        try:
+            result = test_func()
+            results[test_name] = result
+        except Exception as e:
+            print(f"❌ {test_name} test crashed: {e}")
+            results[test_name] = False
+        
+        print()
+    
+    # Print summary
+    print(f"\n{'='*50}")
+    print("📊 TEST SUMMARY")
+    print(f"{'='*50}")
+    
+    passed = sum(1 for r in results.values() if r)
+    total = len(results)
+    
+    for test_name, result in results.items():
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"{test_name:<20} {status}")
+    
+    print(f"\nResults: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed! Multi-series integration is ready.")
+        
+        # Offer to create test structure
+        response = input("\n❓ Create test assets structure for manual testing? (y/n): ")
+        if response.lower() in ['y', 'yes']:
+            create_test_assets_structure()
+        
+        return True
+    else:
+        print("⚠️  Some tests failed. Check the output above for details.")
+        return False
+
+if __name__ == "__main__":
+    success = run_all_tests()
+    sys.exit(0 if success else 1)

test_ui_folder_selection.py

@@ -0,0 +1,167 @@
+"""
+Test UI Folder Selection
+
+Simple test to verify that the folder selection UI works correctly
+for the assets_folder property in multi-series mode.
+
+Usage:
+    python test_ui_folder_selection.py
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Add project root to path
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+try:
+    from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QLabel
+    from PyQt5.QtCore import Qt
+    PYQT_AVAILABLE = True
+except ImportError:
+    PYQT_AVAILABLE = False
+
+def test_folder_selection_ui():
+    """Test the folder selection UI components"""
+    
+    if not PYQT_AVAILABLE:
+        print("❌ PyQt5 not available, cannot test UI components")
+        return False
+    
+    try:
+        from core.nodes.exact_nodes import ExactModelNode, NODEGRAPH_AVAILABLE
+        
+        if not NODEGRAPH_AVAILABLE:
+            print("❌ NodeGraphQt not available, cannot test node properties UI")
+            return False
+        
+        # Create QApplication
+        app = QApplication(sys.argv) if not QApplication.instance() else QApplication.instance()
+        
+        # Create test node
+        node = ExactModelNode()
+        
+        # Enable multi-series mode
+        node.set_property('multi_series_mode', True)
+        
+        # Test property access
+        assets_folder = node.get_property('assets_folder')
+        enabled_series = node.get_property('enabled_series')
+        
+        print(f"✅ Node created successfully")
+        print(f"   - assets_folder: '{assets_folder}'")
+        print(f"   - enabled_series: {enabled_series}")
+        print(f"   - multi_series_mode: {node.get_property('multi_series_mode')}")
+        
+        # Get property options
+        property_options = node._property_options
+        assets_folder_options = property_options.get('assets_folder', {})
+        enabled_series_options = property_options.get('enabled_series', {})
+        
+        print(f"✅ Property options configured correctly")
+        print(f"   - assets_folder type: {assets_folder_options.get('type')}")
+        print(f"   - enabled_series type: {enabled_series_options.get('type')}")
+        print(f"   - enabled_series options: {enabled_series_options.get('options')}")
+        
+        # Test display properties
+        display_props = node.get_display_properties()
+        print(f"✅ Display properties for multi-series mode: {display_props}")
+        
+        # Verify multi-series specific properties are included
+        expected_props = ['assets_folder', 'enabled_series']
+        missing_props = [prop for prop in expected_props if prop not in display_props]
+        
+        if missing_props:
+            print(f"❌ Missing properties in display: {missing_props}")
+            return False
+        
+        print(f"✅ All multi-series properties present in UI")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def create_test_assets_folder():
+    """Create a test assets folder for UI testing"""
+    try:
+        from utils.multi_series_setup import MultiSeriesSetup
+        
+        test_path = os.path.join(project_root, "test_ui_assets")
+        
+        # Remove existing test folder
+        if os.path.exists(test_path):
+            import shutil
+            shutil.rmtree(test_path)
+        
+        # Create new test structure
+        success = MultiSeriesSetup.create_folder_structure(
+            project_root.parent,  # Create in parent directory to avoid clutter
+            series_list=['520', '720']
+        )
+        
+        if success:
+            assets_path = os.path.join(project_root.parent, "Assets")
+            print(f"✅ Test assets folder created: {assets_path}")
+            print("📋 You can now:")
+            print("1. Run your UI application")
+            print("2. Create a Model Node")
+            print("3. Enable 'Multi-Series Mode'")
+            print("4. Use 'Browse Folder' button for 'Assets Folder'")
+            print(f"5. Select the folder: {assets_path}")
+            return assets_path
+        else:
+            print("❌ Failed to create test assets folder")
+            return None
+            
+    except Exception as e:
+        print(f"❌ Error creating test assets: {e}")
+        return None
+
+def main():
+    """Main test function"""
+    print("🧪 Testing UI Folder Selection for Multi-Series Configuration\n")
+    
+    # Test 1: Node property configuration
+    print("=" * 50)
+    print("Test 1: Node Property Configuration")
+    print("=" * 50)
+    
+    success = test_folder_selection_ui()
+    
+    if not success:
+        print("❌ UI component test failed")
+        return False
+    
+    # Test 2: Create test assets folder
+    print("\n" + "=" * 50)
+    print("Test 2: Create Test Assets Folder")
+    print("=" * 50)
+    
+    assets_path = create_test_assets_folder()
+    
+    if assets_path:
+        print("\n🎉 UI folder selection test completed successfully!")
+        print("\n📋 Manual Testing Steps:")
+        print("1. Run: python main.py")
+        print("2. Create a new pipeline")
+        print("3. Add a Model Node")
+        print("4. In properties panel, enable 'Multi-Series Mode'")
+        print("5. Click 'Browse Folder' for 'Assets Folder'")
+        print(f"6. Select folder: {assets_path}")
+        print("7. Configure 'Enabled Series' checkboxes")
+        print("8. Save and deploy pipeline")
+        
+        return True
+    else:
+        print("❌ Test assets creation failed")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

tests/KL520KnModelZooGenericImageInferenceYolov5.py

@@ -1,185 +0,0 @@
-# ******************************************************************************
-#  Copyright (c) 2021-2022. Kneron Inc. All rights reserved.                   *
-# ******************************************************************************
-
-import os
-import sys
-import argparse
-
-PWD = os.path.dirname(os.path.abspath(__file__))
-sys.path.insert(1, os.path.join(PWD, '..'))
-sys.path.insert(1, os.path.join(PWD, '../example/'))
-
-from example_utils.ExampleHelper import get_device_usb_speed_by_port_id
-from example_utils.ExamplePostProcess import post_process_yolo_v5
-import kp
-import cv2
-
-SCPU_FW_PATH = os.path.join(PWD, '../../res/firmware/KL520/fw_scpu.bin')
-NCPU_FW_PATH = os.path.join(PWD, '../../res/firmware/KL520/fw_ncpu.bin')
-MODEL_FILE_PATH = os.path.join(PWD,
-                               '../../res/models/KL520/yolov5-noupsample_w640h640_kn-model-zoo/kl520_20005_yolov5-noupsample_w640h640.nef')
-IMAGE_FILE_PATH = os.path.join(PWD, '../../res/images/people_talk_in_street_1500x1500.bmp')
-LOOP_TIME = 1
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='KL520 Kneron Model Zoo Generic Image Inference Example - YoloV5.')
-    parser.add_argument('-p',
-                        '--port_id',
-                        help='Using specified port ID for connecting device (Default: port ID of first scanned Kneron '
-                             'device)',
-                        default=0,
-                        type=int)
-    parser.add_argument('-m',
-                        '--model',
-                        help='Model file path (.nef) (Default: {})'.format(MODEL_FILE_PATH),
-                        default=MODEL_FILE_PATH,
-                        type=str)
-    parser.add_argument('-i',
-                        '--img',
-                        help='Image file path (Default: {})'.format(IMAGE_FILE_PATH),
-                        default=IMAGE_FILE_PATH,
-                        type=str)
-    args = parser.parse_args()
-
-    usb_port_id = args.port_id
-    MODEL_FILE_PATH = args.model
-    IMAGE_FILE_PATH = args.img
-
-    """
-    check device USB speed (Recommend run KL520 at high speed)
-    """
-    try:
-        if kp.UsbSpeed.KP_USB_SPEED_HIGH != get_device_usb_speed_by_port_id(usb_port_id=usb_port_id):
-            print('\033[91m' + '[Warning] Device is not run at high speed.' + '\033[0m')
-    except Exception as exception:
-        print('Error: check device USB speed fail, port ID = \'{}\', error msg: [{}]'.format(usb_port_id,
-                                                                                             str(exception)))
-        exit(0)
-
-    """
-    connect the device
-    """
-    try:
-        print('[Connect Device]')
-        device_group = kp.core.connect_devices(usb_port_ids=[usb_port_id])
-        print(' - Success')
-    except kp.ApiKPException as exception:
-        print('Error: connect device fail, port ID = \'{}\', error msg: [{}]'.format(usb_port_id,
-                                                                                     str(exception)))
-        exit(0)
-
-    """
-    setting timeout of the usb communication with the device
-    """
-    print('[Set Device Timeout]')
-    kp.core.set_timeout(device_group=device_group, milliseconds=5000)
-    print(' - Success')
-
-    """
-    upload firmware to device
-    """
-    try:
-        print('[Upload Firmware]')
-        kp.core.load_firmware_from_file(device_group=device_group,
-                                        scpu_fw_path=SCPU_FW_PATH,
-                                        ncpu_fw_path=NCPU_FW_PATH)
-        print(' - Success')
-    except kp.ApiKPException as exception:
-        print('Error: upload firmware failed, error = \'{}\''.format(str(exception)))
-        exit(0)
-
-    """
-    upload model to device
-    """
-    try:
-        print('[Upload Model]')
-        model_nef_descriptor = kp.core.load_model_from_file(device_group=device_group,
-                                                            file_path=MODEL_FILE_PATH)
-        print(' - Success')
-    except kp.ApiKPException as exception:
-        print('Error: upload model failed, error = \'{}\''.format(str(exception)))
-        exit(0)
-
-    """
-    prepare the image
-    """
-    print('[Read Image]')
-    img = cv2.imread(filename=IMAGE_FILE_PATH)
-    img_bgr565 = cv2.cvtColor(src=img, code=cv2.COLOR_BGR2BGR565)
-    print(' - Success')
-
-    """
-    prepare generic image inference input descriptor
-    """
-    generic_inference_input_descriptor = kp.GenericImageInferenceDescriptor(
-        model_id=model_nef_descriptor.models[0].id,
-        inference_number=0,
-        input_node_image_list=[
-            kp.GenericInputNodeImage(
-                image=img_bgr565,
-                image_format=kp.ImageFormat.KP_IMAGE_FORMAT_RGB565,
-                resize_mode=kp.ResizeMode.KP_RESIZE_ENABLE,
-                padding_mode=kp.PaddingMode.KP_PADDING_CORNER,
-                normalize_mode=kp.NormalizeMode.KP_NORMALIZE_KNERON
-            )
-        ]
-    )
-
-    """
-    starting inference work
-    """
-    print('[Starting Inference Work]')
-    print(' - Starting inference loop {} times'.format(LOOP_TIME))
-    print(' - ', end='')
-    for i in range(LOOP_TIME):
-        try:
-            kp.inference.generic_image_inference_send(device_group=device_group,
-                                                      generic_inference_input_descriptor=generic_inference_input_descriptor)
-
-            generic_raw_result = kp.inference.generic_image_inference_receive(device_group=device_group)
-        except kp.ApiKPException as exception:
-            print(' - Error: inference failed, error = {}'.format(exception))
-            exit(0)
-
-        print('.', end='', flush=True)
-    print()
-
-    """
-    retrieve inference node output 
-    """
-    print('[Retrieve Inference Node Output ]')
-    inf_node_output_list = []
-    for node_idx in range(generic_raw_result.header.num_output_node):
-        inference_float_node_output = kp.inference.generic_inference_retrieve_float_node(node_idx=node_idx,
-                                                                                         generic_raw_result=generic_raw_result,
-                                                                                         channels_ordering=kp.ChannelOrdering.KP_CHANNEL_ORDERING_CHW
-                                                                                         )
-        inf_node_output_list.append(inference_float_node_output)
-
-    print(' - Success')
-
-    yolo_result = post_process_yolo_v5(inference_float_node_output_list=inf_node_output_list,
-                                       hardware_preproc_info=generic_raw_result.header.hw_pre_proc_info_list[0],
-                                       thresh_value=0.2)
-
-    print('[Result]')
-    print(' - Number of boxes detected')
-    print(' - ' + str(len(yolo_result.box_list)))
-    output_img_name = 'output_{}'.format(os.path.basename(IMAGE_FILE_PATH))
-    print(' - Output bounding boxes on \'{}\''.format(output_img_name))
-    print(" - Bounding boxes info (xmin,ymin,xmax,ymax):")
-    for yolo_box_result in yolo_result.box_list:
-        b = 100 + (25 * yolo_box_result.class_num) % 156
-        g = 100 + (80 + 40 * yolo_box_result.class_num) % 156
-        r = 100 + (120 + 60 * yolo_box_result.class_num) % 156
-        color = (b, g, r)
-
-        cv2.rectangle(img=img,
-                      pt1=(int(yolo_box_result.x1), int(yolo_box_result.y1)),
-                      pt2=(int(yolo_box_result.x2), int(yolo_box_result.y2)),
-                      color=color,
-                      thickness=2)
-        print("(" + str(yolo_box_result.x1) + "," + str(yolo_box_result.y1) + ',' + str(yolo_box_result.x2) + ',' + str(
-            yolo_box_result.y2) + ")")
-    cv2.imwrite(os.path.join(PWD, './{}'.format(output_img_name)), img=img)

tests/debug_detection_issues.py

@@ -1,149 +0,0 @@
-#!/usr/bin/env python3
-"""
-Debug script to investigate abnormal detection results.
-檢查異常偵測結果的調試腳本。
-"""
-
-import sys
-import os
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-from core.functions.Multidongle import BoundingBox, ObjectDetectionResult
-
-def analyze_detection_result(result: ObjectDetectionResult):
-    """分析偵測結果，找出異常情況"""
-    print("=== DETECTION RESULT ANALYSIS ===")
-    print(f"Class count: {result.class_count}")
-    print(f"Box count: {result.box_count}")
-    
-    if not result.box_list:
-        print("No bounding boxes found.")
-        return
-    
-    # 統計分析
-    class_counts = {}
-    coordinate_issues = []
-    score_issues = []
-    
-    for i, box in enumerate(result.box_list):
-        # 統計每個類別的數量
-        class_counts[box.class_name] = class_counts.get(box.class_name, 0) + 1
-        
-        # 檢查座標問題
-        if box.x1 < 0 or box.y1 < 0 or box.x2 < 0 or box.y2 < 0:
-            coordinate_issues.append(f"Box {i}: Negative coordinates ({box.x1},{box.y1},{box.x2},{box.y2})")
-        
-        if box.x1 >= box.x2 or box.y1 >= box.y2:
-            coordinate_issues.append(f"Box {i}: Invalid box dimensions ({box.x1},{box.y1},{box.x2},{box.y2})")
-        
-        if box.x1 == box.x2 and box.y1 == box.y2:
-            coordinate_issues.append(f"Box {i}: Zero-area box ({box.x1},{box.y1},{box.x2},{box.y2})")
-        
-        # 檢查分數問題
-        if box.score < 0 or box.score > 1:
-            score_issues.append(f"Box {i}: Unusual score {box.score} for {box.class_name}")
-    
-    # 報告結果
-    print("\n--- CLASS DISTRIBUTION ---")
-    for class_name, count in sorted(class_counts.items()):
-        if count > 50:  # 標記異常高的數量
-            print(f"⚠ {class_name}: {count} (ABNORMALLY HIGH)")
-        else:
-            print(f"✓ {class_name}: {count}")
-    
-    print(f"\n--- COORDINATE ISSUES ({len(coordinate_issues)}) ---")
-    for issue in coordinate_issues[:10]:  # 只顯示前10個
-        print(f"⚠ {issue}")
-    if len(coordinate_issues) > 10:
-        print(f"... and {len(coordinate_issues) - 10} more coordinate issues")
-    
-    print(f"\n--- SCORE ISSUES ({len(score_issues)}) ---")
-    for issue in score_issues[:10]:  # 只顯示前10個
-        print(f"⚠ {issue}")
-    if len(score_issues) > 10:
-        print(f"... and {len(score_issues) - 10} more score issues")
-    
-    # 建議
-    print("\n--- RECOMMENDATIONS ---")
-    if any(count > 50 for count in class_counts.values()):
-        print("⚠ Abnormally high detection counts suggest:")
-        print("  1. Model output format mismatch")
-        print("  2. Confidence threshold too low")
-        print("  3. Test/debug mode accidentally enabled")
-    
-    if coordinate_issues:
-        print("⚠ Coordinate issues suggest:")
-        print("  1. Coordinate transformation problems")
-        print("  2. Model output scaling issues")
-        print("  3. Hardware preprocessing info missing")
-    
-    if score_issues:
-        print("⚠ Score issues suggest:")
-        print("  1. Score values might be in log space")
-        print("  2. Wrong score interpretation")
-        print("  3. Need score normalization")
-
-def create_mock_problematic_result():
-    """創建一個模擬的有問題的偵測結果用於測試"""
-    boxes = []
-    
-    # 模擬您遇到的問題
-    class_names = ['person', 'bicycle', 'car', 'motorbike', 'aeroplane', 'bus', 'toothbrush', 'hair drier']
-    
-    # 添加大量異常的邊界框
-    for i in range(100):
-        box = BoundingBox(
-            x1=i % 5,  # 很小的座標
-            y1=(i + 1) % 4,
-            x2=(i + 2) % 6,
-            y2=(i + 3) % 5,
-            score=2.0 + (i * 0.1),  # 異常的分數值
-            class_num=i % len(class_names),
-            class_name=class_names[i % len(class_names)]
-        )
-        boxes.append(box)
-    
-    return ObjectDetectionResult(
-        class_count=len(class_names),
-        box_count=len(boxes),
-        box_list=boxes
-    )
-
-def suggest_fixes():
-    """提供修復建議"""
-    print("\n=== SUGGESTED FIXES ===")
-    
-    print("\n1. 檢查模型配置:")
-    print("   - 確認使用正確的後處理類型（YOLO_V3, YOLO_V5, etc.）")
-    print("   - 檢查類別名稱列表是否正確")
-    print("   - 驗證信心閾值設定（建議 0.3-0.7）")
-    
-    print("\n2. 檢查座標轉換:")
-    print("   - 確認模型輸出格式（中心座標 vs 角點座標）")
-    print("   - 檢查圖片尺寸縮放")
-    print("   - 驗證硬體預處理信息")
-    
-    print("\n3. 添加結果過濾:")
-    print("   - 過濾無效座標的邊界框")
-    print("   - 限制每個類別的最大檢測數量")
-    print("   - 添加 NMS（非極大值抑制）")
-    
-    print("\n4. 調試步驟:")
-    print("   - 添加詳細的調試日誌")
-    print("   - 檢查原始模型輸出")
-    print("   - 測試不同的後處理參數")
-
-if __name__ == "__main__":
-    print("Detection Issues Debug Tool")
-    print("=" * 50)
-    
-    # 測試與您遇到類似問題的模擬結果
-    print("Testing with mock problematic result...")
-    mock_result = create_mock_problematic_result()
-    analyze_detection_result(mock_result)
-    
-    suggest_fixes()
-    
-    print("\nTo use this tool with real results:")
-    print("from debug_detection_issues import analyze_detection_result")
-    print("analyze_detection_result(your_detection_result)")

tests/emergency_filter.py

@@ -1,25 +0,0 @@
-
-def emergency_filter_detections(boxes, max_total=50, max_per_class=10):
-    """緊急過濾檢測結果"""
-    if len(boxes) <= max_total:
-        return boxes
-    
-    # 按類別分組
-    from collections import defaultdict
-    class_groups = defaultdict(list)
-    for box in boxes:
-        class_groups[box.class_name].append(box)
-    
-    # 每類保留最高分數的檢測
-    filtered = []
-    for class_name, class_boxes in class_groups.items():
-        class_boxes.sort(key=lambda x: x.score, reverse=True)
-        keep_count = min(len(class_boxes), max_per_class)
-        filtered.extend(class_boxes[:keep_count])
-    
-    # 總數限制
-    if len(filtered) > max_total:
-        filtered.sort(key=lambda x: x.score, reverse=True)
-        filtered = filtered[:max_total]
-    
-    return filtered

tests/fire_detection_520.py

@@ -1,201 +0,0 @@
-"""
-fire_detection_inference.py
-
-此模組提供火災檢測推論介面函式：
-    inference(frame, params={})
-    
-當作為主程式執行時，也可以使用命令列參數測試推論。
-"""
-
-import os
-import sys
-import time
-import argparse
-import cv2
-import numpy as np
-import kp
-
-# 固定路徑設定
-# SCPU_FW_PATH = r'external\res\firmware\KL520\fw_scpu.bin'
-# NCPU_FW_PATH = r'external\res\firmware\KL520\fw_ncpu.bin'
-# MODEL_FILE_PATH = r'src\utils\models\fire_detection_520.nef'
-# 若作為測試使用，預設的圖片檔案路徑（請根據實際環境調整）
-# IMAGE_FILE_PATH = r'test_images\fire4.jpeg'
-
-
-def preprocess_frame(frame):
-    """
-    將輸入的 numpy 陣列進行預處理：
-      1. 調整大小至 (128, 128)
-      2. 轉換為 BGR565 格式（KL520 常用格式）
-    """
-    if frame is None:
-        raise Exception("輸入的 frame 為 None")
-    
-    print("預處理步驟：")
-    print(f" - 原始 frame 大小: {frame.shape}")
-    
-    # 調整大小
-    frame_resized = cv2.resize(frame, (128, 128))
-    print(f" - 調整後大小: {frame_resized.shape}")
-    
-    # 轉換為 BGR565 格式
-    # 注意：cv2.cvtColor 直接轉換到 BGR565 並非 OpenCV 標準用法，但假設此方法在 kneron SDK 下有效
-    frame_bgr565 = cv2.cvtColor(frame_resized, cv2.COLOR_BGR2BGR565)
-    print(" - 轉換為 BGR565 格式")
-    
-    return frame_bgr565
-
-
-def postprocess(pre_output):
-    """
-    後處理函式：將模型輸出轉換為二元分類結果（這裡假設輸出為單一數值）
-    """
-    probability = pre_output[0]  # 假設模型輸出僅一個數值
-    return probability
-
-
-def inference(frame, params={}):
-    """
-    推論介面函式
-      - frame: numpy 陣列（BGR 格式），輸入的原始影像
-      - params: dict，包含額外參數，例如:
-          'port_id': (int) 預設 0
-          'model': (str) 模型檔案路徑，預設 MODEL_FILE_PATH
-    回傳一個 dict，內容包含：
-      - result: "Fire" 或 "No Fire"
-      - probability: 推論信心分數
-      - inference_time_ms: 推論耗時 (毫秒)
-    """
-    # 取得參數（若未提供則使用預設值）
-    port_id = params.get('usb_port_id', 0)
-    model_path = params.get('model')
-    IMAGE_FILE_PATH = params.get('file_path')
-    SCPU_FW_PATH = params.get('scpu_path')
-    NCPU_FW_PATH = params.get('ncpu_path')
-
-    print("Parameters received from main app:", params)
-    try:
-        # 1. 設備連接與初始化
-        print('[連接設備]')
-        device_group = kp.core.connect_devices(usb_port_ids=[port_id])
-        print(' - 成功')
-    
-        print('[設置超時]')
-        kp.core.set_timeout(device_group=device_group, milliseconds=5000)
-        print(' - 成功')
-    
-        print('[上傳韌體]')
-        kp.core.load_firmware_from_file(device_group=device_group,
-                                        scpu_fw_path=SCPU_FW_PATH,
-                                        ncpu_fw_path=NCPU_FW_PATH)
-        print(' - 成功')
-    
-        print('[上傳模型]')
-        model_descriptor = kp.core.load_model_from_file(device_group=device_group,
-                                                        file_path=model_path)
-        print(' - 成功')
-    
-        # 2. 圖像預處理：從 frame 轉換到符合 KL520 格式的輸入
-        print('[預處理影像]')
-        img_processed = preprocess_frame(frame)
-    
-        # 3. 建立推論描述物件
-        inference_input_descriptor = kp.GenericImageInferenceDescriptor(
-            model_id=model_descriptor.models[0].id,
-            inference_number=0,
-            input_node_image_list=[
-                kp.GenericInputNodeImage(
-                    image=img_processed,
-                    image_format=kp.ImageFormat.KP_IMAGE_FORMAT_RGB565,
-                    resize_mode=kp.ResizeMode.KP_RESIZE_ENABLE,
-                    padding_mode=kp.PaddingMode.KP_PADDING_CORNER,
-                    normalize_mode=kp.NormalizeMode.KP_NORMALIZE_KNERON
-                )
-            ]
-        )
-    
-        # 4. 執行推論
-        print('[執行推論]')
-        start_time = time.time()
-        kp.inference.generic_image_inference_send(
-            device_group=device_group,
-            generic_inference_input_descriptor=inference_input_descriptor
-        )
-        generic_raw_result = kp.inference.generic_image_inference_receive(
-            device_group=device_group
-        )
-        inference_time = (time.time() - start_time) * 1000  # 毫秒
-        print(f' - 推論耗時: {inference_time:.2f} ms')
-    
-        # 5. 處理推論結果
-        print('[處理結果]')
-        inf_node_output_list = []
-        for node_idx in range(generic_raw_result.header.num_output_node):
-            inference_float_node_output = kp.inference.generic_inference_retrieve_float_node(
-                node_idx=node_idx,
-                generic_raw_result=generic_raw_result,
-                channels_ordering=kp.ChannelOrdering.KP_CHANNEL_ORDERING_CHW
-            )
-            inf_node_output_list.append(inference_float_node_output.ndarray.copy())
-    
-        # 整理成一維陣列並後處理
-        probability = postprocess(np.array(inf_node_output_list).flatten())
-        result_str = "Fire" if probability > 0.5 else "No Fire"
-    
-        # 6. 斷開設備連接
-        kp.core.disconnect_devices(device_group=device_group)
-        print('[已斷開設備連接]')
-    
-        # 回傳結果
-        return {
-            "result": result_str,
-            "probability": probability,
-            "inference_time_ms": inference_time
-        }
-    
-    except Exception as e:
-        print(f"錯誤: {str(e)}")
-        # 嘗試斷開設備（若有連線）
-        try:
-            kp.core.disconnect_devices(device_group=device_group)
-        except Exception:
-            pass
-        raise
-
-
-# 若作為主程式執行，支援從命令列讀取圖片檔案並測試推論
-# if __name__ == '__main__':
-#     parser = argparse.ArgumentParser(
-#         description='KL520 Fire Detection Model Inference'
-#     )
-#     parser.add_argument(
-#         '-p', '--port_id', help='Port ID (Default: 0)', default=0, type=int
-#     )
-#     parser.add_argument(
-#         '-m', '--model', help='NEF model path', default=model_path, type=str
-#     )
-#     parser.add_argument(
-#         '-i', '--img', help='Image path', default=IMAGE_FILE_PATH, type=str
-#     )
-#     args = parser.parse_args()
-    
-#     # 讀取圖片（使用 cv2 讀取）
-#     test_image = cv2.imread(args.img)
-#     if test_image is None:
-#         print(f"無法讀取圖片: {args.img}")
-#         sys.exit(1)
-    
-#     # 構造參數字典
-#     params = {
-#         "port_id": args.port_id,
-#         "model": args.model
-#     }
-    
-#     # 呼叫推論介面函式
-#     result = inference(test_image, params)
-    
-#     print("\n結果摘要:")
-#     print(f"預測結果: {result['result']}")
-#     print(f"信心分數: {result['probability']:.4f}")
-#     print(f"推論時間: {result['inference_time_ms']:.2f} ms")

tests/fix_yolov5_postprocessing.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to fix YOLOv5 postprocessing configuration issues
-
-This script demonstrates how to properly configure YOLOv5 postprocessing
-to resolve negative probability values and incorrect result formatting.
-"""
-import sys
-import os
-
-# Add core functions to path
-sys.path.append(os.path.join(os.path.dirname(__file__), 'core', 'functions'))
-
-def create_yolov5_postprocessor_options():
-    """Create properly configured PostProcessorOptions for YOLOv5"""
-    from Multidongle import PostProcessType, PostProcessorOptions
-    
-    # COCO dataset class names (80 classes for YOLOv5)
-    yolo_class_names = [
-        "person", "bicycle", "car", "motorbike", "aeroplane", "bus", "train", "truck", "boat", 
-        "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", 
-        "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", 
-        "umbrella", "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", 
-        "kite", "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", 
-        "bottle", "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", 
-        "sandwich", "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", 
-        "sofa", "pottedplant", "bed", "diningtable", "toilet", "tvmonitor", "laptop", "mouse", 
-        "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", 
-        "book", "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"
-    ]
-    
-    # Create YOLOv5 postprocessor options
-    options = PostProcessorOptions(
-        postprocess_type=PostProcessType.YOLO_V5,
-        threshold=0.3,                      # Confidence threshold (0.3 is good for detection)
-        class_names=yolo_class_names,       # All 80 COCO classes
-        nms_threshold=0.5,                  # Non-Maximum Suppression threshold
-        max_detections_per_class=50         # Maximum detections per class
-    )
-    
-    return options
-
-def create_fire_detection_postprocessor_options():
-    """Create properly configured PostProcessorOptions for Fire Detection"""
-    from Multidongle import PostProcessType, PostProcessorOptions
-    
-    options = PostProcessorOptions(
-        postprocess_type=PostProcessType.FIRE_DETECTION,
-        threshold=0.5,                      # Fire detection threshold
-        class_names=["No Fire", "Fire"]     # Binary classification
-    )
-    
-    return options
-
-def test_postprocessor_options():
-    """Test both postprocessor configurations"""
-    
-    print("=" * 60)
-    print("Testing PostProcessorOptions Configuration")
-    print("=" * 60)
-    
-    # Test YOLOv5 configuration
-    print("\n1. YOLOv5 Configuration:")
-    try:
-        yolo_options = create_yolov5_postprocessor_options()
-        print(f"   ✓ Postprocess Type: {yolo_options.postprocess_type.value}")
-        print(f"   ✓ Confidence Threshold: {yolo_options.threshold}")
-        print(f"   ✓ NMS Threshold: {yolo_options.nms_threshold}")
-        print(f"   ✓ Max Detections: {yolo_options.max_detections_per_class}")
-        print(f"   ✓ Number of Classes: {len(yolo_options.class_names)}")
-        print(f"   ✓ Sample Classes: {yolo_options.class_names[:5]}...")
-    except Exception as e:
-        print(f"   ✗ YOLOv5 configuration failed: {e}")
-    
-    # Test Fire Detection configuration  
-    print("\n2. Fire Detection Configuration:")
-    try:
-        fire_options = create_fire_detection_postprocessor_options()
-        print(f"   ✓ Postprocess Type: {fire_options.postprocess_type.value}")
-        print(f"   ✓ Confidence Threshold: {fire_options.threshold}")
-        print(f"   ✓ Class Names: {fire_options.class_names}")
-    except Exception as e:
-        print(f"   ✗ Fire Detection configuration failed: {e}")
-
-def demonstrate_multidongle_creation():
-    """Demonstrate creating MultiDongle with correct postprocessing"""
-    from Multidongle import MultiDongle
-    
-    print("\n" + "=" * 60)
-    print("Creating MultiDongle with YOLOv5 Postprocessing")
-    print("=" * 60)
-    
-    # Create YOLOv5 postprocessor options
-    yolo_options = create_yolov5_postprocessor_options()
-    
-    # Example configuration (adjust paths to match your setup)
-    PORT_IDS = [28, 32]  # Your dongle port IDs
-    MODEL_PATH = "path/to/yolov5_model.nef"  # Your YOLOv5 model path
-    
-    print(f"Configuration:")
-    print(f"   Port IDs: {PORT_IDS}")
-    print(f"   Model Path: {MODEL_PATH}")
-    print(f"   Postprocess Type: {yolo_options.postprocess_type.value}")
-    print(f"   Confidence Threshold: {yolo_options.threshold}")
-    
-    # NOTE: Uncomment below to actually create MultiDongle instance
-    # (requires actual dongle hardware and valid paths)
-    """
-    try:
-        multidongle = MultiDongle(
-            port_id=PORT_IDS,
-            model_path=MODEL_PATH,
-            auto_detect=True,
-            postprocess_options=yolo_options  # This is the key fix!
-        )
-        
-        print("   ✓ MultiDongle created successfully with YOLOv5 postprocessing")
-        print("   ✓ This should resolve negative probability issues")
-        
-        # Initialize and start
-        multidongle.initialize()
-        multidongle.start()
-        
-        print("   ✓ MultiDongle initialized and started")
-        
-        # Don't forget to stop when done
-        multidongle.stop()
-        
-    except Exception as e:
-        print(f"   ✗ MultiDongle creation failed: {e}")
-    """
-    
-    print(f"\n   📝 To fix your current issue:")
-    print(f"      1. Change postprocess_type from 'fire_detection' to 'yolo_v5'")
-    print(f"      2. Set proper class names (80 COCO classes)")
-    print(f"      3. Adjust confidence threshold to 0.3 (instead of 0.5)")
-    print(f"      4. Set NMS threshold to 0.5")
-
-def show_configuration_summary():
-    """Show summary of configuration changes needed"""
-    
-    print("\n" + "=" * 60)
-    print("CONFIGURATION FIX SUMMARY")
-    print("=" * 60)
-    
-    print("\n🔧 Current Issue:")
-    print("   - YOLOv5 model with FIRE_DETECTION postprocessing")
-    print("   - Results in negative probabilities like -0.39")
-    print("   - Incorrect result formatting")
-    
-    print("\n✅ Solution:")
-    print("   1. Use PostProcessType.YOLO_V5 instead of FIRE_DETECTION")
-    print("   2. Set confidence threshold to 0.3 (good for object detection)")
-    print("   3. Use 80 COCO class names for YOLOv5")
-    print("   4. Set NMS threshold to 0.5 for proper object filtering")
-    
-    print("\n📁 File Changes Needed:")
-    print("   - multi_series_example.mflow: Add ExactPostprocessNode")
-    print("   - Set 'enable_postprocessing': true in model node")
-    print("   - Configure postprocess_type: 'yolo_v5'")
-    
-    print("\n🚀 Expected Result After Fix:")
-    print("   - Positive probabilities (0.0 to 1.0)")
-    print("   - Object detection results with bounding boxes")
-    print("   - Proper class names like 'person', 'car', etc.")
-    print("   - Multiple objects detected per frame")
-
-if __name__ == "__main__":
-    print("YOLOv5 Postprocessing Fix Utility")
-    print("=" * 60)
-    
-    try:
-        test_postprocessor_options()
-        demonstrate_multidongle_creation()
-        show_configuration_summary()
-        
-        print("\n🎉 Configuration examples completed successfully!")
-        print("   Use the fixed .mflow file or update your configuration.")
-        
-    except Exception as e:
-        print(f"\n❌ Script failed with error: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)

tests/improved_yolo_postprocessing.py

@@ -1,442 +0,0 @@
-#!/usr/bin/env python3
-"""
-Improved YOLO postprocessing with better error handling and filtering.
-改進的 YOLO 後處理，包含更好的錯誤處理和過濾機制。
-"""
-
-import numpy as np
-from typing import List
-from collections import defaultdict
-
-# 假設這些類別已經在原始檔案中定義
-from core.functions.Multidongle import BoundingBox, ObjectDetectionResult
-
-
-class ImprovedYOLOPostProcessor:
-    """改進的 YOLO 後處理器，包含異常檢測和過濾"""
-    
-    def __init__(self, options):
-        self.options = options
-        self.max_detections_total = 500  # 總檢測數量限制
-        self.max_detections_per_class = 50  # 每類檢測數量限制
-        self.min_box_area = 4  # 最小邊界框面積
-        self.max_score = 10.0  # 最大允許分數（用於檢測異常）
-        
-    def _is_valid_box(self, x1, y1, x2, y2, score, class_id):
-        """檢查邊界框是否有效"""
-        # 基本座標檢查
-        if x1 < 0 or y1 < 0 or x1 >= x2 or y1 >= y2:
-            return False, "Invalid coordinates"
-        
-        # 面積檢查
-        area = (x2 - x1) * (y2 - y1)
-        if area < self.min_box_area:
-            return False, f"Box too small (area={area})"
-        
-        # 分數檢查
-        if score <= 0 or score > self.max_score:
-            return False, f"Invalid score ({score})"
-        
-        # 類別檢查
-        if class_id < 0 or (self.options.class_names and class_id >= len(self.options.class_names)):
-            return False, f"Invalid class_id ({class_id})"
-        
-        return True, "Valid"
-    
-    def _filter_excessive_detections(self, boxes: List[BoundingBox]) -> List[BoundingBox]:
-        """過濾過多的檢測結果"""
-        if len(boxes) <= self.max_detections_total:
-            return boxes
-        
-        print(f"WARNING: Too many detections ({len(boxes)}), filtering to {self.max_detections_total}")
-        
-        # 按分數排序，保留最高分數的檢測
-        boxes.sort(key=lambda x: x.score, reverse=True)
-        return boxes[:self.max_detections_total]
-    
-    def _filter_by_class_count(self, boxes: List[BoundingBox]) -> List[BoundingBox]:
-        """限制每個類別的檢測數量"""
-        class_counts = defaultdict(list)
-        
-        # 按類別分組
-        for box in boxes:
-            class_counts[box.class_num].append(box)
-        
-        filtered_boxes = []
-        for class_id, class_boxes in class_counts.items():
-            # 按分數排序，保留最高分數的檢測
-            class_boxes.sort(key=lambda x: x.score, reverse=True)
-            
-            # 限制每個類別的數量
-            keep_count = min(len(class_boxes), self.max_detections_per_class)
-            if len(class_boxes) > self.max_detections_per_class:
-                class_name = class_boxes[0].class_name
-                print(f"WARNING: Too many {class_name} detections ({len(class_boxes)}), keeping top {keep_count}")
-            
-            filtered_boxes.extend(class_boxes[:keep_count])
-        
-        return filtered_boxes
-    
-    def _detect_anomalous_pattern(self, boxes: List[BoundingBox]) -> bool:
-        """檢測異常的檢測模式"""
-        if not boxes:
-            return False
-        
-        # 檢查是否有大量相同座標的檢測
-        coord_counts = defaultdict(int)
-        for box in boxes:
-            coord_key = (box.x1, box.y1, box.x2, box.y2)
-            coord_counts[coord_key] += 1
-        
-        max_coord_count = max(coord_counts.values())
-        if max_coord_count > 10:
-            print(f"WARNING: Anomalous pattern detected - {max_coord_count} boxes with same coordinates")
-            return True
-        
-        # 檢查分數分布
-        scores = [box.score for box in boxes]
-        if scores:
-            avg_score = np.mean(scores)
-            if avg_score > 2.0:  # 分數過高可能表示對數空間
-                print(f"WARNING: Unusually high average score: {avg_score:.3f}")
-                return True
-        
-        return False
-    
-    def process_yolo_output(self, inference_output_list: List, hardware_preproc_info=None, version="v3") -> ObjectDetectionResult:
-        """改進的 YOLO 輸出處理"""
-        boxes = []
-        invalid_box_count = 0
-        
-        try:
-            if not inference_output_list or len(inference_output_list) == 0:
-                return ObjectDetectionResult(
-                    class_count=len(self.options.class_names) if self.options.class_names else 0,
-                    box_count=0,
-                    box_list=[]
-                )
-            
-            print(f"DEBUG: Processing {len(inference_output_list)} YOLO output nodes")
-            
-            for i, output in enumerate(inference_output_list):
-                try:
-                    # 提取數組數據
-                    if hasattr(output, 'ndarray'):
-                        arr = output.ndarray
-                    elif hasattr(output, 'flatten'):
-                        arr = output
-                    elif isinstance(output, np.ndarray):
-                        arr = output
-                    else:
-                        print(f"WARNING: Unknown output type for node {i}: {type(output)}")
-                        continue
-                    
-                    # 檢查數組形狀
-                    if not hasattr(arr, 'shape'):
-                        print(f"WARNING: Output node {i} has no shape attribute")
-                        continue
-                    
-                    print(f"DEBUG: Output node {i} shape: {arr.shape}")
-                    
-                    # YOLOv5 格式處理: [batch, num_detections, features]
-                    if len(arr.shape) == 3:
-                        batch_size, num_detections, num_features = arr.shape
-                        print(f"DEBUG: YOLOv5 format: {batch_size}x{num_detections}x{num_features}")
-                        
-                        # 檢查異常大的檢測數量
-                        if num_detections > 10000:
-                            print(f"WARNING: Extremely high detection count: {num_detections}, limiting to 1000")
-                            num_detections = 1000
-                        
-                        detections = arr[0]  # 只處理第一批次
-                        
-                        for det_idx in range(min(num_detections, 1000)):  # 限制處理數量
-                            detection = detections[det_idx]
-                            
-                            try:
-                                # 提取座標和信心度
-                                x_center = float(detection[0])
-                                y_center = float(detection[1])
-                                width = float(detection[2])
-                                height = float(detection[3])
-                                obj_conf = float(detection[4])
-                                
-                                # 檢查是否是有效數值
-                                if not all(np.isfinite([x_center, y_center, width, height, obj_conf])):
-                                    invalid_box_count += 1
-                                    continue
-                                
-                                # 跳過低信心度檢測
-                                if obj_conf < self.options.threshold:
-                                    continue
-                                
-                                # 尋找最佳類別
-                                class_probs = detection[5:] if num_features > 5 else []
-                                if len(class_probs) > 0:
-                                    class_scores = class_probs * obj_conf
-                                    best_class = int(np.argmax(class_scores))
-                                    best_score = float(class_scores[best_class])
-                                    
-                                    if best_score < self.options.threshold:
-                                        continue
-                                else:
-                                    best_class = 0
-                                    best_score = obj_conf
-                                
-                                # 座標轉換
-                                x1 = int(x_center - width / 2)
-                                y1 = int(y_center - height / 2)
-                                x2 = int(x_center + width / 2)
-                                y2 = int(y_center + height / 2)
-                                
-                                # 驗證邊界框
-                                is_valid, reason = self._is_valid_box(x1, y1, x2, y2, best_score, best_class)
-                                if not is_valid:
-                                    invalid_box_count += 1
-                                    if invalid_box_count <= 5:  # 只報告前5個錯誤
-                                        print(f"DEBUG: Invalid box rejected: {reason}")
-                                    continue
-                                
-                                # 獲取類別名稱
-                                if self.options.class_names and best_class < len(self.options.class_names):
-                                    class_name = self.options.class_names[best_class]
-                                else:
-                                    class_name = f"Class_{best_class}"
-                                
-                                box = BoundingBox(
-                                    x1=max(0, x1),
-                                    y1=max(0, y1),
-                                    x2=x2,
-                                    y2=y2,
-                                    score=best_score,
-                                    class_num=best_class,
-                                    class_name=class_name
-                                )
-                                boxes.append(box)
-                                
-                            except Exception as e:
-                                invalid_box_count += 1
-                                if invalid_box_count <= 5:
-                                    print(f"DEBUG: Error processing detection {det_idx}: {e}")
-                                continue
-                    
-                    elif len(arr.shape) == 2:
-                        # 2D 格式處理
-                        print(f"DEBUG: 2D YOLO output: {arr.shape}")
-                        num_detections, num_features = arr.shape
-                        
-                        if num_detections > 1000:
-                            print(f"WARNING: Too many 2D detections: {num_detections}, limiting to 1000")
-                            num_detections = 1000
-                        
-                        for det_idx in range(min(num_detections, 1000)):
-                            detection = arr[det_idx]
-                            
-                            try:
-                                if num_features >= 6:
-                                    x_center = float(detection[0])
-                                    y_center = float(detection[1])
-                                    width = float(detection[2])
-                                    height = float(detection[3])
-                                    confidence = float(detection[4])
-                                    class_id = int(detection[5])
-                                    
-                                    if not all(np.isfinite([x_center, y_center, width, height, confidence])):
-                                        invalid_box_count += 1
-                                        continue
-                                    
-                                    if confidence > self.options.threshold:
-                                        x1 = int(x_center - width / 2)
-                                        y1 = int(y_center - height / 2)
-                                        x2 = int(x_center + width / 2)
-                                        y2 = int(y_center + height / 2)
-                                        
-                                        is_valid, reason = self._is_valid_box(x1, y1, x2, y2, confidence, class_id)
-                                        if not is_valid:
-                                            invalid_box_count += 1
-                                            continue
-                                        
-                                        class_name = self.options.class_names[class_id] if class_id < len(self.options.class_names) else f"Class_{class_id}"
-                                        
-                                        box = BoundingBox(
-                                            x1=max(0, x1), y1=max(0, y1), x2=x2, y2=y2,
-                                            score=confidence, class_num=class_id, class_name=class_name
-                                        )
-                                        boxes.append(box)
-                            except Exception as e:
-                                invalid_box_count += 1
-                                continue
-                    
-                    else:
-                        # 回退處理
-                        flat = arr.flatten()
-                        print(f"DEBUG: Fallback processing for flat array size: {len(flat)}")
-                        
-                        # 限制處理的數據量
-                        if len(flat) > 6000:  # 1000 boxes * 6 values
-                            print(f"WARNING: Large flat array ({len(flat)}), limiting processing")
-                            flat = flat[:6000]
-                        
-                        step = 6
-                        for j in range(0, len(flat) - step + 1, step):
-                            try:
-                                x1, y1, x2, y2, conf, cls = flat[j:j+6]
-                                
-                                if not all(np.isfinite([x1, y1, x2, y2, conf])):
-                                    invalid_box_count += 1
-                                    continue
-                                
-                                if conf > self.options.threshold:
-                                    class_id = int(cls)
-                                    
-                                    is_valid, reason = self._is_valid_box(x1, y1, x2, y2, conf, class_id)
-                                    if not is_valid:
-                                        invalid_box_count += 1
-                                        continue
-                                    
-                                    class_name = self.options.class_names[class_id] if class_id < len(self.options.class_names) else f"Class_{class_id}"
-                                    
-                                    box = BoundingBox(
-                                        x1=max(0, int(x1)), y1=max(0, int(y1)),
-                                        x2=int(x2), y2=int(y2),
-                                        score=float(conf), class_num=class_id, class_name=class_name
-                                    )
-                                    boxes.append(box)
-                            except Exception as e:
-                                invalid_box_count += 1
-                                continue
-                
-                except Exception as e:
-                    print(f"ERROR: Error processing output node {i}: {e}")
-                    continue
-            
-            # 報告統計信息
-            if invalid_box_count > 0:
-                print(f"INFO: Rejected {invalid_box_count} invalid detections")
-            
-            print(f"DEBUG: Raw detection count: {len(boxes)}")
-            
-            # 檢測異常模式
-            if self._detect_anomalous_pattern(boxes):
-                print("WARNING: Anomalous detection pattern detected, applying aggressive filtering")
-                # 更嚴格的過濾
-                boxes = [box for box in boxes if box.score < 2.0 and box.x1 != box.x2 and box.y1 != box.y2]
-            
-            # 應用過濾
-            boxes = self._filter_excessive_detections(boxes)
-            boxes = self._filter_by_class_count(boxes)
-            
-            # 應用 NMS
-            if boxes and len(boxes) > 1:
-                boxes = self._apply_nms(boxes)
-            
-            print(f"INFO: Final detection count: {len(boxes)}")
-            
-            # 創建統計報告
-            if boxes:
-                class_stats = defaultdict(int)
-                for box in boxes:
-                    class_stats[box.class_name] += 1
-                
-                print("Detection summary:")
-                for class_name, count in sorted(class_stats.items()):
-                    print(f"  {class_name}: {count}")
-            
-        except Exception as e:
-            print(f"ERROR: Critical error in YOLO postprocessing: {e}")
-            import traceback
-            traceback.print_exc()
-            boxes = []
-        
-        return ObjectDetectionResult(
-            class_count=len(self.options.class_names) if self.options.class_names else 1,
-            box_count=len(boxes),
-            box_list=boxes
-        )
-    
-    def _apply_nms(self, boxes: List[BoundingBox]) -> List[BoundingBox]:
-        """改進的非極大值抑制"""
-        if not boxes or len(boxes) <= 1:
-            return boxes
-        
-        try:
-            # 按類別分組
-            class_boxes = defaultdict(list)
-            for box in boxes:
-                class_boxes[box.class_num].append(box)
-            
-            final_boxes = []
-            
-            for class_id, class_box_list in class_boxes.items():
-                if len(class_box_list) <= 1:
-                    final_boxes.extend(class_box_list)
-                    continue
-                
-                # 按信心度排序
-                class_box_list.sort(key=lambda x: x.score, reverse=True)
-                
-                keep = []
-                while class_box_list and len(keep) < self.max_detections_per_class:
-                    current_box = class_box_list.pop(0)
-                    keep.append(current_box)
-                    
-                    # 移除高 IoU 的框
-                    remaining = []
-                    for box in class_box_list:
-                        iou = self._calculate_iou(current_box, box)
-                        if iou <= self.options.nms_threshold:
-                            remaining.append(box)
-                    class_box_list = remaining
-                
-                final_boxes.extend(keep)
-            
-            print(f"DEBUG: NMS reduced {len(boxes)} to {len(final_boxes)} boxes")
-            return final_boxes
-            
-        except Exception as e:
-            print(f"ERROR: NMS failed: {e}")
-            return boxes[:self.max_detections_total]  # 回退到簡單限制
-    
-    def _calculate_iou(self, box1: BoundingBox, box2: BoundingBox) -> float:
-        """計算兩個邊界框的 IoU"""
-        try:
-            # 計算交集
-            x1 = max(box1.x1, box2.x1)
-            y1 = max(box1.y1, box2.y1)
-            x2 = min(box1.x2, box2.x2)
-            y2 = min(box1.y2, box2.y2)
-            
-            if x2 <= x1 or y2 <= y1:
-                return 0.0
-            
-            intersection = (x2 - x1) * (y2 - y1)
-            
-            # 計算聯集
-            area1 = (box1.x2 - box1.x1) * (box1.y2 - box1.y1)
-            area2 = (box2.x2 - box2.x1) * (box2.y2 - box2.y1)
-            union = area1 + area2 - intersection
-            
-            if union <= 0:
-                return 0.0
-            
-            return intersection / union
-            
-        except Exception:
-            return 0.0
-
-
-# 測試函數
-if __name__ == "__main__":
-    from core.functions.Multidongle import PostProcessorOptions, PostProcessType
-    
-    # 創建測試選項
-    options = PostProcessorOptions(
-        postprocess_type=PostProcessType.YOLO_V5,
-        threshold=0.3,
-        class_names=["person", "bicycle", "car", "motorbike", "aeroplane"],
-        nms_threshold=0.45,
-        max_detections_per_class=20
-    )
-    
-    processor = ImprovedYOLOPostProcessor(options)
-    print("ImprovedYOLOPostProcessor initialized successfully!")

tests/quick_fix_detection_issues.py

@@ -1,150 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick fixes for detection result issues.
-快速修復偵測結果問題的補丁程式。
-"""
-
-import sys
-import os
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-def apply_quick_fixes():
-    """應用快速修復到檢測結果"""
-    
-    print("=== 快速修復偵測結果問題 ===")
-    print()
-    
-    # 修復建議
-    fixes = [
-        {
-            "issue": "過多的偵測結果 (100+ 物件)",
-            "cause": "可能的原因：模型輸出格式不匹配、閾值太低、測試模式",
-            "solutions": [
-                "1. 提高信心閾值到 0.5-0.7",
-                "2. 添加檢測數量限制",
-                "3. 檢查是否在測試/調試模式",
-                "4. 驗證模型輸出格式"
-            ]
-        },
-        {
-            "issue": "座標異常 (0,0 或負值)",
-            "cause": "可能的原因：座標轉換錯誤、輸出格式不匹配",
-            "solutions": [
-                "1. 檢查座標轉換邏輯",
-                "2. 驗證輸入圖片尺寸",
-                "3. 確認模型輸出格式",
-                "4. 添加座標有效性檢查"
-            ]
-        },
-        {
-            "issue": "LiveView 卡頓",
-            "cause": "可能的原因：處理過多檢測結果導致渲染瓶頸",
-            "solutions": [
-                "1. 限制顯示的檢測數量",
-                "2. 降低 FPS 或跳幀顯示",
-                "3. 異步處理檢測結果",
-                "4. 優化渲染代碼"
-            ]
-        }
-    ]
-    
-    for fix in fixes:
-        print(f"問題: {fix['issue']}")
-        print(f"原因: {fix['cause']}")
-        print("解決方案:")
-        for solution in fix['solutions']:
-            print(f"   {solution}")
-        print()
-    
-    # 立即可用的代碼修復
-    print("=== 立即可用的代碼修復 ===")
-    print()
-    
-    print("1. 在 Multidongle.py 的 _process_yolo_generic 函數開頭添加:")
-    print("""
-# 緊急修復：限制檢測數量
-MAX_DETECTIONS = 50
-if len(boxes) > MAX_DETECTIONS:
-    print(f"WARNING: Too many detections ({len(boxes)}), limiting to {MAX_DETECTIONS}")
-    boxes = sorted(boxes, key=lambda x: x.score, reverse=True)[:MAX_DETECTIONS]
-    """)
-    
-    print("\n2. 在創建 BoundingBox 之前添加驗證:")
-    print("""
-# 座標有效性檢查
-if x1 < 0 or y1 < 0 or x1 >= x2 or y1 >= y2:
-    continue  # 跳過無效的邊界框
-if (x2 - x1) * (y2 - y1) < 4:  # 最小面積
-    continue  # 跳過太小的框
-if best_score > 2.0:  # 檢查異常分數
-    continue  # 跳過異常分數
-    """)
-    
-    print("\n3. 在 PostProcessorOptions 中設置更嚴格的參數:")
-    print("""
-postprocess_options = PostProcessorOptions(
-    postprocess_type=PostProcessType.YOLO_V5,
-    threshold=0.6,  # 提高閾值
-    class_names=["person", "bicycle", "car", "motorbike", "aeroplane"],
-    nms_threshold=0.4,
-    max_detections_per_class=10  # 限制每類檢測數量
-)
-    """)
-    
-    print("\n4. 添加檢測結果統計和警告:")
-    print("""
-# 在函數結尾添加
-class_counts = {}
-for box in boxes:
-    class_counts[box.class_name] = class_counts.get(box.class_name, 0) + 1
-
-for class_name, count in class_counts.items():
-    if count > 20:
-        print(f"WARNING: Abnormally high count for {class_name}: {count}")
-    """)
-
-def create_emergency_filter():
-    """創建緊急過濾函數"""
-    
-    filter_code = '''
-def emergency_filter_detections(boxes, max_total=50, max_per_class=10):
-    """緊急過濾檢測結果"""
-    if len(boxes) <= max_total:
-        return boxes
-    
-    # 按類別分組
-    from collections import defaultdict
-    class_groups = defaultdict(list)
-    for box in boxes:
-        class_groups[box.class_name].append(box)
-    
-    # 每類保留最高分數的檢測
-    filtered = []
-    for class_name, class_boxes in class_groups.items():
-        class_boxes.sort(key=lambda x: x.score, reverse=True)
-        keep_count = min(len(class_boxes), max_per_class)
-        filtered.extend(class_boxes[:keep_count])
-    
-    # 總數限制
-    if len(filtered) > max_total:
-        filtered.sort(key=lambda x: x.score, reverse=True)
-        filtered = filtered[:max_total]
-    
-    return filtered
-'''
-    
-    with open("emergency_filter.py", "w", encoding="utf-8") as f:
-        f.write(filter_code)
-    
-    print("緊急過濾函數已保存到 emergency_filter.py")
-
-if __name__ == "__main__":
-    apply_quick_fixes()
-    create_emergency_filter()
-    
-    print("\n=== 下一步建議 ===")
-    print("1. 檢查當前的後處理配置")
-    print("2. 調整信心閾值和檢測限制")
-    print("3. 使用 debug_detection_issues.py 分析結果")
-    print("4. 考慮使用 improved_yolo_postprocessing.py 中的改進版本")
-    print("5. 如果問題持續，請檢查模型文件和配置")

tests/quick_test_deployment.py

@@ -1,187 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick test script for YOLOv5 pipeline deployment using fixed configuration
-"""
-import sys
-import os
-
-# Add paths
-sys.path.append(os.path.join(os.path.dirname(__file__), 'ui', 'dialogs'))
-sys.path.append(os.path.join(os.path.dirname(__file__), 'core', 'functions'))
-
-def test_mflow_loading():
-    """Test loading and parsing the fixed .mflow file"""
-    import json
-    
-    mflow_files = [
-        'multi_series_example.mflow',
-        'multi_series_yolov5_fixed.mflow',
-        'test.mflow'
-    ]
-    
-    print("=" * 60)
-    print("Testing .mflow Configuration Loading")
-    print("=" * 60)
-    
-    for mflow_file in mflow_files:
-        if os.path.exists(mflow_file):
-            print(f"\n📄 Loading {mflow_file}:")
-            try:
-                with open(mflow_file, 'r') as f:
-                    data = json.load(f)
-                
-                # Check for postprocess nodes
-                postprocess_nodes = [
-                    node for node in data.get('nodes', [])
-                    if node.get('type') == 'ExactPostprocessNode'
-                ]
-                
-                if postprocess_nodes:
-                    for node in postprocess_nodes:
-                        props = node.get('properties', {})
-                        postprocess_type = props.get('postprocess_type', 'NOT SET')
-                        confidence_threshold = props.get('confidence_threshold', 'NOT SET')
-                        class_names = props.get('class_names', 'NOT SET')
-                        
-                        print(f"   ✓ Found PostprocessNode: {node.get('name', 'Unnamed')}")
-                        print(f"     - Type: {postprocess_type}")
-                        print(f"     - Threshold: {confidence_threshold}")
-                        print(f"     - Classes: {len(class_names.split(',')) if isinstance(class_names, str) else 'N/A'} classes")
-                        
-                        if postprocess_type == 'yolo_v5':
-                            print(f"     ✅ Correctly configured for YOLOv5")
-                        else:
-                            print(f"     ❌ Still using: {postprocess_type}")
-                else:
-                    print(f"   ⚠ No ExactPostprocessNode found")
-                    
-            except Exception as e:
-                print(f"   ❌ Error loading file: {e}")
-        else:
-            print(f"\n📄 {mflow_file}: File not found")
-
-def test_deployment_direct():
-    """Test deployment using the deployment dialog directly"""
-    try:
-        from deployment import DeploymentDialog
-        from PyQt5.QtWidgets import QApplication
-        
-        print(f"\n" + "=" * 60)
-        print("Testing Direct Pipeline Deployment")
-        print("=" * 60)
-        
-        # Load the fixed configuration
-        import json
-        config_file = 'multi_series_yolov5_fixed.mflow'
-        
-        if not os.path.exists(config_file):
-            print(f"❌ Configuration file not found: {config_file}")
-            return
-        
-        with open(config_file, 'r') as f:
-            pipeline_data = json.load(f)
-        
-        print(f"✓ Loaded configuration: {pipeline_data.get('project_name', 'Unknown')}")
-        print(f"✓ Found {len(pipeline_data.get('nodes', []))} nodes")
-        
-        # Create minimal Qt app for testing
-        app = QApplication.instance()
-        if app is None:
-            app = QApplication(sys.argv)
-        
-        # Create deployment dialog
-        dialog = DeploymentDialog(pipeline_data)
-        print(f"✓ Created deployment dialog")
-        
-        # Test analysis
-        print(f"🔍 Testing pipeline analysis...")
-        
-        try:
-            from core.functions.mflow_converter import MFlowConverter
-            converter = MFlowConverter()
-            config = converter._convert_mflow_to_config(pipeline_data)
-            
-            print(f"✓ Pipeline conversion successful")
-            print(f"  - Pipeline name: {config.pipeline_name}")
-            print(f"  - Total stages: {len(config.stage_configs)}")
-            
-            # Check stage configurations
-            for i, stage_config in enumerate(config.stage_configs, 1):
-                print(f"  Stage {i}: {stage_config.stage_id}")
-                if hasattr(stage_config, 'postprocessor_options') and stage_config.postprocessor_options:
-                    print(f"    - Postprocess type: {stage_config.postprocessor_options.postprocess_type.value}")
-                    print(f"    - Threshold: {stage_config.postprocessor_options.threshold}")
-                    print(f"    - Classes: {len(stage_config.postprocessor_options.class_names)}")
-                    
-                    if stage_config.postprocessor_options.postprocess_type.value == 'yolo_v5':
-                        print(f"    ✅ YOLOv5 postprocessing configured correctly")
-                    else:
-                        print(f"    ❌ Postprocessing type: {stage_config.postprocessor_options.postprocess_type.value}")
-            
-        except Exception as e:
-            print(f"❌ Pipeline conversion failed: {e}")
-            import traceback
-            traceback.print_exc()
-        
-    except ImportError as e:
-        print(f"❌ Cannot import deployment components: {e}")
-        print(f"   This is expected if running outside the full application")
-    except Exception as e:
-        print(f"❌ Direct deployment test failed: {e}")
-        import traceback
-        traceback.print_exc()
-
-def show_fix_summary():
-    """Show summary of the fixes applied"""
-    print(f"\n" + "=" * 60)
-    print("FIX SUMMARY")
-    print("=" * 60)
-    
-    print(f"\n🔧 Applied Fixes:")
-    print(f"1. ✅ Fixed dashboard.py postprocess property loading")
-    print(f"   - Added missing 'postprocess_type' property")
-    print(f"   - Added all missing postprocess properties")
-    print(f"   - Location: ui/windows/dashboard.py:1203-1213")
-    
-    print(f"\n2. ✅ Enhanced YOLOv5 postprocessing in Multidongle.py")
-    print(f"   - Improved _process_yolo_generic method")
-    print(f"   - Added proper NMS (Non-Maximum Suppression)")
-    print(f"   - Enhanced live view display")
-    
-    print(f"\n3. ✅ Updated .mflow configurations")
-    print(f"   - multi_series_example.mflow: enable_postprocessing = true")
-    print(f"   - multi_series_yolov5_fixed.mflow: Complete YOLOv5 setup")
-    print(f"   - Added ExactPostprocessNode with yolo_v5 type")
-    
-    print(f"\n🎯 Expected Results After Fix:")
-    print(f"   - ❌ 'No Fire (Prob: -0.39)' → ✅ 'person detected (Conf: 0.85)'")
-    print(f"   - ❌ Negative probabilities → ✅ Positive probabilities (0.0-1.0)")
-    print(f"   - ❌ No bounding boxes → ✅ Colorful bounding boxes with labels")
-    print(f"   - ❌ Fire detection classes → ✅ COCO 80 classes (person, car, etc.)")
-    
-    print(f"\n💡 Usage Instructions:")
-    print(f"   1. Run: python main.py")
-    print(f"   2. Login to the dashboard")
-    print(f"   3. Load: multi_series_yolov5_fixed.mflow")
-    print(f"   4. Deploy the pipeline")
-    print(f"   5. Check Live View tab for enhanced bounding boxes")
-
-def main():
-    print("Quick YOLOv5 Deployment Test")
-    print("=" * 60)
-    
-    # Test configuration loading
-    test_mflow_loading()
-    
-    # Test direct deployment (if possible)
-    test_deployment_direct()
-    
-    # Show fix summary
-    show_fix_summary()
-    
-    print(f"\n🎉 Quick test completed!")
-    print(f"   Now try running: python main.py")
-    print(f"   And load: multi_series_yolov5_fixed.mflow")
-
-if __name__ == "__main__":
-    main()

tests/simple_test.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple test for port ID configuration
-"""
-
-import sys
-import os
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.insert(0, parent_dir)
-
-from core.nodes.exact_nodes import ExactModelNode
-
-def main():
-    print("Creating ExactModelNode...")
-    node = ExactModelNode()
-    
-    print("Testing property options...")
-    if hasattr(node, '_property_options'):
-        port_props = [k for k in node._property_options.keys() if 'port_ids' in k]
-        print(f"Found port ID properties: {port_props}")
-    else:
-        print("No _property_options found")
-    
-    print("Testing _build_multi_series_config method...")
-    if hasattr(node, '_build_multi_series_config'):
-        print("Method exists")
-        try:
-            config = node._build_multi_series_config()
-            print(f"Config result: {config}")
-        except Exception as e:
-            print(f"Error calling method: {e}")
-    else:
-        print("Method does not exist")
-    
-    print("Test completed!")
-
-if __name__ == "__main__":
-    main()

tests/test_classification_result_format.py

@@ -1,83 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify ClassificationResult formatting fix
-"""
-import sys
-import os
-
-# Add core functions to path
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.append(os.path.join(parent_dir, 'core', 'functions'))
-
-from Multidongle import ClassificationResult
-
-def test_classification_result_formatting():
-    """Test that ClassificationResult can be formatted without errors"""
-    
-    # Create a test classification result
-    result = ClassificationResult(
-        probability=0.85,
-        class_name="Fire",
-        class_num=1,
-        confidence_threshold=0.5
-    )
-    
-    print("Testing ClassificationResult formatting...")
-    
-    # Test __str__ method
-    print(f"str(result): {str(result)}")
-    
-    # Test __format__ method with empty format spec
-    print(f"format(result, ''): {format(result, '')}")
-    
-    # Test f-string formatting (this was causing the original error)
-    print(f"f-string: {result}")
-    
-    # Test string formatting that was likely causing the error
-    try:
-        formatted = f"Error updating inference results: {result}"
-        print(f"Complex formatting test: {formatted}")
-        print("✓ All formatting tests passed!")
-        return True
-    except Exception as e:
-        print(f"✗ Formatting test failed: {e}")
-        return False
-
-def test_is_positive_property():
-    """Test the is_positive property"""
-    
-    # Test positive case
-    positive_result = ClassificationResult(
-        probability=0.85,
-        class_name="Fire",
-        confidence_threshold=0.5
-    )
-    
-    # Test negative case  
-    negative_result = ClassificationResult(
-        probability=0.3,
-        class_name="No Fire", 
-        confidence_threshold=0.5
-    )
-    
-    print(f"\nTesting is_positive property...")
-    print(f"Positive result (0.85 > 0.5): {positive_result.is_positive}")
-    print(f"Negative result (0.3 > 0.5): {negative_result.is_positive}")
-    
-    assert positive_result.is_positive == True
-    assert negative_result.is_positive == False
-    print("✓ is_positive property tests passed!")
-
-if __name__ == "__main__":
-    print("Running ClassificationResult formatting tests...")
-    
-    try:
-        test_classification_result_formatting()
-        test_is_positive_property()
-        print("\n🎉 All tests passed! The format string error should be fixed.")
-    except Exception as e:
-        print(f"\n❌ Test failed with error: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)

tests/test_coordinate_scaling.py

@@ -1,129 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test coordinate scaling logic for small bounding boxes.
-測試小座標邊界框的縮放邏輯。
-"""
-
-def test_coordinate_scaling():
-    """測試座標縮放邏輯"""
-    
-    print("=== 測試座標縮放邏輯 ===")
-    
-    # 模擬您看到的小座標
-    test_boxes = [
-        {"name": "toothbrush", "coords": (0, 1, 2, 3), "score": 0.778},
-        {"name": "car", "coords": (0, 0, 2, 2), "score": 1.556}, 
-        {"name": "person", "coords": (0, 0, 2, 3), "score": 1.989}
-    ]
-    
-    # 圖片尺寸設定
-    img_width, img_height = 640, 480
-    
-    print(f"原始座標 -> 縮放後座標 (圖片尺寸: {img_width}x{img_height})")
-    print("-" * 60)
-    
-    for box in test_boxes:
-        x1, y1, x2, y2 = box["coords"]
-        
-        # 應用縮放邏輯
-        if x2 <= 10 and y2 <= 10:
-            # 檢查是否為歸一化座標
-            if x1 <= 1.0 and y1 <= 1.0 and x2 <= 1.0 and y2 <= 1.0:
-                # 歸一化座標縮放
-                scaled_x1 = int(x1 * img_width)
-                scaled_y1 = int(y1 * img_height)
-                scaled_x2 = int(x2 * img_width)
-                scaled_y2 = int(y2 * img_height)
-                method = "normalized scaling"
-            else:
-                # 小整數座標縮放
-                scale_factor = min(img_width, img_height) // 10  # = 48
-                scaled_x1 = x1 * scale_factor
-                scaled_y1 = y1 * scale_factor
-                scaled_x2 = x2 * scale_factor
-                scaled_y2 = y2 * scale_factor
-                method = f"integer scaling (x{scale_factor})"
-        else:
-            # 不需要縮放
-            scaled_x1, scaled_y1, scaled_x2, scaled_y2 = x1, y1, x2, y2
-            method = "no scaling needed"
-        
-        # 確保座標在圖片範圍內
-        scaled_x1 = max(0, min(scaled_x1, img_width - 1))
-        scaled_y1 = max(0, min(scaled_y1, img_height - 1))
-        scaled_x2 = max(scaled_x1 + 1, min(scaled_x2, img_width))
-        scaled_y2 = max(scaled_y1 + 1, min(scaled_y2, img_height))
-        
-        area = (scaled_x2 - scaled_x1) * (scaled_y2 - scaled_y1)
-        
-        print(f"{box['name']:10} | ({x1},{y1},{x2},{y2}) -> ({scaled_x1},{scaled_y1},{scaled_x2},{scaled_y2}) | Area: {area:4d} | {method}")
-
-def test_liveview_visibility():
-    """測試 LiveView 可見性"""
-    
-    print("\n=== LiveView 可見性分析 ===")
-    
-    # 原始座標（您看到的）
-    original_coords = [
-        (0, 1, 2, 3),  # toothbrush
-        (0, 0, 2, 2),  # car
-        (0, 0, 2, 3)   # person
-    ]
-    
-    # 縮放後的座標
-    scale_factor = 48  # 640//10 或 480//10
-    scaled_coords = [
-        (0*scale_factor, 1*scale_factor, 2*scale_factor, 3*scale_factor),
-        (0*scale_factor, 0*scale_factor, 2*scale_factor, 2*scale_factor),
-        (0*scale_factor, 0*scale_factor, 2*scale_factor, 3*scale_factor)
-    ]
-    
-    print("為什麼之前 LiveView 看不到邊界框：")
-    print("原始座標太小：")
-    for i, coords in enumerate(original_coords):
-        area = (coords[2] - coords[0]) * (coords[3] - coords[1])
-        print(f"  Box {i+1}: {coords} -> 面積: {area} 像素 (太小，幾乎看不見)")
-    
-    print("\n縮放後應該可見：")
-    for i, coords in enumerate(scaled_coords):
-        area = (coords[2] - coords[0]) * (coords[3] - coords[1])
-        print(f"  Box {i+1}: {coords} -> 面積: {area} 像素 (應該可見)")
-    
-    print("\n建議檢查：")
-    print("1. 確認 LiveView 使用正確的圖片尺寸")
-    print("2. 檢查邊界框繪製代碼是否正確處理座標")
-    print("3. 確認沒有其他過濾邏輯阻止顯示")
-
-def performance_analysis():
-    """分析性能改善"""
-    
-    print("\n=== 性能改善分析 ===")
-    
-    print("FPS 降低的可能原因：")
-    print("1. 座標縮放計算增加了處理時間")
-    print("2. 更詳細的調試輸出")
-    print("3. 可能的圖片尺寸獲取延遲")
-    
-    print("\n已應用的性能優化：")
-    print("✅ 減少檢測數量限制從 50 -> 20")
-    print("✅ 少於 5 個檢測時跳過 NMS")
-    print("✅ 更寬鬆的分數檢查 (<=10.0 而非 <=2.0)")
-    print("✅ 簡化的早期驗證")
-    
-    print("\n預期改善：")
-    print("- FPS 應該從 3.90 提升到 8-15")
-    print("- LiveView 應該顯示正確縮放的邊界框")
-    print("- 座標應該在合理範圍內 (0-640, 0-480)")
-
-if __name__ == "__main__":
-    test_coordinate_scaling()
-    test_liveview_visibility() 
-    performance_analysis()
-    
-    print("\n" + "=" * 60)
-    print("修復摘要：")
-    print("✅ 智能座標縮放：小座標會自動放大")
-    print("✅ 性能優化：減少處理量，提升 FPS")
-    print("✅ 更好的調試：顯示實際座標信息")
-    print("✅ 寬鬆驗證：不會過度過濾有效檢測")
-    print("\n重新測試您的 pipeline，應該會看到改善！")

tests/test_detection_fix.py

@@ -1,204 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify the detection result fixes.
-測試腳本以驗證偵測結果修復是否有效。
-"""
-
-import sys
-import os
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.append(parent_dir)
-
-from core.functions.Multidongle import BoundingBox, ObjectDetectionResult, PostProcessorOptions, PostProcessType
-
-def create_test_problematic_boxes():
-    """創建測試用的有問題的邊界框（模擬您遇到的問題）"""
-    boxes = []
-    
-    class_names = ['person', 'bicycle', 'car', 'motorbike', 'aeroplane', 'bus', 'toothbrush', 'hair drier']
-    
-    # 添加大量異常的邊界框（類似您的輸出）
-    for i in range(443):  # 模擬您的 443 個檢測結果
-        # 模擬您看到的異常座標和分數
-        x1 = i % 5  # 很小的座標值
-        y1 = (i + 1) % 4
-        x2 = (i + 2) % 6 if (i + 2) % 6 > x1 else x1 + 1
-        y2 = (i + 3) % 5 if (i + 3) % 5 > y1 else y1 + 1
-        
-        # 模擬異常分數（像您看到的 2.0+ 分數）
-        score = 2.0 + (i * 0.01)  
-        
-        class_id = i % len(class_names)
-        class_name = class_names[class_id]
-        
-        box = BoundingBox(
-            x1=x1,
-            y1=y1,
-            x2=x2,
-            y2=y2,
-            score=score,
-            class_num=class_id,
-            class_name=class_name
-        )
-        boxes.append(box)
-    
-    # 添加一些負座標的框（您報告的問題）
-    for i in range(10):
-        box = BoundingBox(
-            x1=-1,
-            y1=0,
-            x2=1,
-            y2=2,
-            score=1.5,
-            class_num=0,
-            class_name='person'
-        )
-        boxes.append(box)
-    
-    # 添加一些零面積的框
-    for i in range(5):
-        box = BoundingBox(
-            x1=0,
-            y1=0,
-            x2=0,
-            y2=0,
-            score=1.0,
-            class_num=1,
-            class_name='bicycle'
-        )
-        boxes.append(box)
-    
-    return boxes
-
-def test_emergency_filter():
-    """測試緊急過濾功能"""
-    print("=== 測試緊急過濾功能 ===")
-    
-    # 創建有問題的檢測結果
-    problematic_boxes = create_test_problematic_boxes()
-    print(f"原始檢測數量: {len(problematic_boxes)}")
-    
-    # 統計原始結果
-    class_counts_before = {}
-    for box in problematic_boxes:
-        class_counts_before[box.class_name] = class_counts_before.get(box.class_name, 0) + 1
-    
-    print("修復前的類別分布:")
-    for class_name, count in sorted(class_counts_before.items()):
-        print(f"  {class_name}: {count}")
-    
-    # 應用我們添加的過濾邏輯
-    boxes = problematic_boxes.copy()
-    original_count = len(boxes)
-    
-    # 第一步：移除無效的框
-    valid_boxes = []
-    for box in boxes:
-        # 座標有效性檢查
-        if box.x1 < 0 or box.y1 < 0 or box.x1 >= box.x2 or box.y1 >= box.y2:
-            continue
-        # 最小面積檢查
-        if (box.x2 - box.x1) * (box.y2 - box.y1) < 4:
-            continue
-        # 分數有效性檢查（異常分數表示對數空間或測試數據）
-        if box.score <= 0 or box.score > 2.0:
-            continue
-        valid_boxes.append(box)
-    
-    boxes = valid_boxes
-    print(f"有效性過濾後: {len(boxes)} （移除了 {original_count - len(boxes)} 個無效框）")
-    
-    # 第二步：限制總檢測數量
-    MAX_TOTAL_DETECTIONS = 50
-    if len(boxes) > MAX_TOTAL_DETECTIONS:
-        boxes = sorted(boxes, key=lambda x: x.score, reverse=True)[:MAX_TOTAL_DETECTIONS]
-        print(f"總數限制後: {len(boxes)}")
-    
-    # 第三步：限制每類檢測數量
-    from collections import defaultdict
-    class_groups = defaultdict(list)
-    for box in boxes:
-        class_groups[box.class_name].append(box)
-    
-    filtered_boxes = []
-    MAX_PER_CLASS = 10
-    for class_name, class_boxes in class_groups.items():
-        if len(class_boxes) > MAX_PER_CLASS:
-            class_boxes = sorted(class_boxes, key=lambda x: x.score, reverse=True)[:MAX_PER_CLASS]
-        filtered_boxes.extend(class_boxes)
-    
-    boxes = filtered_boxes
-    print(f"每類限制後: {len(boxes)}")
-    
-    # 統計最終結果
-    class_counts_after = {}
-    for box in boxes:
-        class_counts_after[box.class_name] = class_counts_after.get(box.class_name, 0) + 1
-    
-    print("\n修復後的類別分布:")
-    for class_name, count in sorted(class_counts_after.items()):
-        print(f"  {class_name}: {count}")
-    
-    print(f"\n✅ 過濾成功！從 {original_count} 個檢測減少到 {len(boxes)} 個有效檢測")
-    
-    return boxes
-
-def analyze_fix_effectiveness():
-    """分析修復效果"""
-    print("\n=== 修復效果分析 ===")
-    
-    filtered_boxes = test_emergency_filter()
-    
-    # 驗證所有框都是有效的
-    all_valid = True
-    for box in filtered_boxes:
-        if box.x1 < 0 or box.y1 < 0 or box.x1 >= box.x2 or box.y1 >= box.y2:
-            all_valid = False
-            print(f"❌ 發現無效座標: {box}")
-            break
-        if (box.x2 - box.x1) * (box.y2 - box.y1) < 4:
-            all_valid = False
-            print(f"❌ 發現過小面積: {box}")
-            break
-        if box.score <= 0 or box.score > 2.0:
-            all_valid = False
-            print(f"❌ 發現異常分數: {box}")
-            break
-    
-    if all_valid:
-        print("✅ 所有過濾後的邊界框都是有效的")
-    
-    # 檢查數量限制
-    class_counts = {}
-    for box in filtered_boxes:
-        class_counts[box.class_name] = class_counts.get(box.class_name, 0) + 1
-    
-    max_count = max(class_counts.values()) if class_counts else 0
-    if max_count <= 10:
-        print("✅ 每個類別的檢測數量都在限制內")
-    else:
-        print(f"❌ 某個類別超出限制: 最大數量 = {max_count}")
-    
-    if len(filtered_boxes) <= 50:
-        print("✅ 總檢測數量在限制內")
-    else:
-        print(f"❌ 總檢測數量超出限制: {len(filtered_boxes)}")
-
-if __name__ == "__main__":
-    print("偵測結果修復測試")
-    print("=" * 50)
-    
-    analyze_fix_effectiveness()
-    
-    print("\n" + "=" * 50)
-    print("測試完成！")
-    print("\n如果您看到上述 ✅ 標記，表示修復代碼應該能解決您的問題。")
-    print("現在您可以重新運行您的推理pipeline，應該會看到：")
-    print("1. 檢測數量大幅減少（從 443 降至 50 以下）")
-    print("2. 無效座標的框被過濾掉")
-    print("3. 異常分數的框被移除")
-    print("4. LiveView 性能改善")
-    
-    print(f"\n修復已應用到: F:\\cluster4npu\\core\\functions\\Multidongle.py")
-    print("您可以立即測試修復效果。")

tests/test_final_fix.py

@@ -1,193 +0,0 @@
-#!/usr/bin/env python3
-"""
-Final test to verify all fixes are working correctly
-"""
-import sys
-import os
-import json
-
-# Add paths
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.append(os.path.join(parent_dir, 'core', 'functions'))
-
-def test_converter_with_postprocessing():
-    """Test the mflow converter with postprocessing fixes"""
-    
-    print("=" * 60)
-    print("Testing MFlow Converter with Postprocessing Fixes")
-    print("=" * 60)
-    
-    try:
-        from mflow_converter import MFlowConverter
-        
-        # Test with the fixed mflow file
-        mflow_file = 'multi_series_yolov5_fixed.mflow'
-        
-        if not os.path.exists(mflow_file):
-            print(f"❌ Test file not found: {mflow_file}")
-            return False
-        
-        print(f"✓ Loading {mflow_file}...")
-        
-        converter = MFlowConverter()
-        config = converter.load_and_convert(mflow_file)
-        
-        print(f"✓ Conversion successful!")
-        print(f"  - Pipeline name: {config.pipeline_name}")
-        print(f"  - Total stages: {len(config.stage_configs)}")
-        
-        # Check each stage for postprocessor
-        for i, stage_config in enumerate(config.stage_configs, 1):
-            print(f"\n  Stage {i}: {stage_config.stage_id}")
-            
-            if stage_config.stage_postprocessor:
-                options = stage_config.stage_postprocessor.options
-                print(f"    ✅ Postprocessor found!")
-                print(f"       Type: {options.postprocess_type.value}")
-                print(f"       Threshold: {options.threshold}")
-                print(f"       Classes: {len(options.class_names)} ({options.class_names[:3]}...)")
-                print(f"       NMS Threshold: {options.nms_threshold}")
-                
-                if options.postprocess_type.value == 'yolo_v5':
-                    print(f"    🎉 YOLOv5 postprocessing correctly configured!")
-                else:
-                    print(f"    ⚠ Postprocessing type: {options.postprocess_type.value}")
-            else:
-                print(f"    ❌ No postprocessor found")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ Converter test failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def test_multidongle_postprocessing():
-    """Test MultiDongle postprocessing directly"""
-    
-    print(f"\n" + "=" * 60)
-    print("Testing MultiDongle Postprocessing")
-    print("=" * 60)
-    
-    try:
-        from Multidongle import MultiDongle, PostProcessorOptions, PostProcessType
-        
-        # Create YOLOv5 postprocessor options
-        options = PostProcessorOptions(
-            postprocess_type=PostProcessType.YOLO_V5,
-            threshold=0.3,
-            class_names=["person", "bicycle", "car", "motorbike", "aeroplane"],
-            nms_threshold=0.5,
-            max_detections_per_class=50
-        )
-        
-        print(f"✓ Created PostProcessorOptions:")
-        print(f"  - Type: {options.postprocess_type.value}")
-        print(f"  - Threshold: {options.threshold}")
-        print(f"  - Classes: {len(options.class_names)}")
-        
-        # Test with dummy MultiDongle
-        multidongle = MultiDongle(
-            port_id=[1],  # Dummy port
-            postprocess_options=options
-        )
-        
-        print(f"✓ Created MultiDongle with postprocessing")
-        print(f"  - Postprocess type: {multidongle.postprocess_options.postprocess_type.value}")
-        
-        # Test set_postprocess_options method
-        new_options = PostProcessorOptions(
-            postprocess_type=PostProcessType.YOLO_V5,
-            threshold=0.25,
-            class_names=["person", "car", "truck"],
-            nms_threshold=0.4
-        )
-        
-        multidongle.set_postprocess_options(new_options)
-        print(f"✓ Updated postprocess options:")
-        print(f"  - New threshold: {multidongle.postprocess_options.threshold}")
-        print(f"  - New classes: {len(multidongle.postprocess_options.class_names)}")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ MultiDongle test failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-def show_fix_summary():
-    """Show comprehensive fix summary"""
-    
-    print(f"\n" + "=" * 60)
-    print("COMPREHENSIVE FIX SUMMARY")
-    print("=" * 60)
-    
-    print(f"\n🔧 Applied Fixes:")
-    print(f"1. ✅ Fixed ui/windows/dashboard.py:")
-    print(f"   - Added missing 'postprocess_type' in fallback logic")
-    print(f"   - Added all postprocessing properties")
-    print(f"   - Lines: 1203-1213")
-    
-    print(f"\n2. ✅ Enhanced core/functions/Multidongle.py:")
-    print(f"   - Improved YOLOv5 postprocessing implementation")
-    print(f"   - Added proper NMS (Non-Maximum Suppression)")
-    print(f"   - Enhanced live view display with corner markers")
-    print(f"   - Better result string generation")
-    
-    print(f"\n3. ✅ Fixed core/functions/mflow_converter.py:")
-    print(f"   - Added connection mapping for postprocessing nodes")
-    print(f"   - Extract postprocessing config from ExactPostprocessNode")
-    print(f"   - Create PostProcessor instances for each stage")
-    print(f"   - Attach stage_postprocessor to StageConfig")
-    
-    print(f"\n4. ✅ Enhanced core/functions/InferencePipeline.py:")
-    print(f"   - Apply stage_postprocessor during initialization")
-    print(f"   - Set postprocessor options to MultiDongle")
-    print(f"   - Debug logging for postprocessor application")
-    
-    print(f"\n5. ✅ Updated .mflow configurations:")
-    print(f"   - multi_series_example.mflow: enable_postprocessing = true")
-    print(f"   - multi_series_yolov5_fixed.mflow: Complete YOLOv5 setup")
-    print(f"   - Proper node connections: Input → Model → Postprocess → Output")
-    
-    print(f"\n🎯 Expected Results:")
-    print(f"   ❌ 'No Fire (Prob: -0.39)' → ✅ 'person detected (Conf: 0.85)'")
-    print(f"   ❌ Negative probabilities → ✅ Positive probabilities (0.0-1.0)")
-    print(f"   ❌ Fire detection output → ✅ COCO object detection")
-    print(f"   ❌ No bounding boxes → ✅ Enhanced bounding boxes in live view")
-    print(f"   ❌ Simple terminal output → ✅ Detailed object statistics")
-    
-    print(f"\n🚀 How the Fix Works:")
-    print(f"   1. UI loads .mflow file with yolo_v5 postprocess_type")
-    print(f"   2. dashboard.py now includes postprocess_type in properties")
-    print(f"   3. mflow_converter.py extracts postprocessing config")
-    print(f"   4. Creates PostProcessor with YOLOv5 options")
-    print(f"   5. InferencePipeline applies postprocessor to MultiDongle")
-    print(f"   6. MultiDongle processes with correct YOLOv5 settings")
-    print(f"   7. Enhanced live view shows proper object detection")
-
-def main():
-    print("Final Fix Verification Test")
-    print("=" * 60)
-    
-    # Run tests
-    converter_ok = test_converter_with_postprocessing()
-    multidongle_ok = test_multidongle_postprocessing()
-    
-    # Show summary
-    show_fix_summary()
-    
-    if converter_ok and multidongle_ok:
-        print(f"\n🎉 ALL TESTS PASSED!")
-        print(f"   The YOLOv5 postprocessing fix should now work correctly.")
-        print(f"   Run: python main.py")
-        print(f"   Load: multi_series_yolov5_fixed.mflow")
-        print(f"   Deploy and check for positive probabilities!")
-    else:
-        print(f"\n❌ Some tests failed. Please check the output above.")
-
-if __name__ == "__main__":
-    main()

tests/test_folder_selection.py

@@ -1,71 +0,0 @@
-"""
-Test tkinter folder selection functionality
-"""
-
-import sys
-import os
-
-# Add project root to path
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.insert(0, parent_dir)
-
-from utils.folder_dialog import select_folder, select_assets_folder
-
-def test_basic_folder_selection():
-    """Test basic folder selection"""
-    print("Testing basic folder selection...")
-    
-    folder = select_folder("Select any folder for testing")
-    if folder:
-        print(f"Selected folder: {folder}")
-        print(f"   Exists: {os.path.exists(folder)}")
-        print(f"   Is directory: {os.path.isdir(folder)}")
-        return True
-    else:
-        print("No folder selected")
-        return False
-
-def test_assets_folder_selection():
-    """Test Assets folder selection with validation"""
-    print("\nTesting Assets folder selection...")
-    
-    result = select_assets_folder()
-    
-    print(f"Selected path: {result['path']}")
-    print(f"Valid: {result['valid']}")
-    print(f"Message: {result['message']}")
-    
-    if 'details' in result:
-        details = result['details']
-        print(f"Details:")
-        print(f"  Has Firmware folder: {details.get('has_firmware_folder', False)}")
-        print(f"  Has Models folder: {details.get('has_models_folder', False)}")
-        print(f"  Firmware series: {details.get('firmware_series', [])}")
-        print(f"  Models series: {details.get('models_series', [])}")
-        print(f"  Available series: {details.get('available_series', [])}")
-        print(f"  Series with files: {details.get('series_with_files', [])}")
-    
-    return result['valid']
-
-if __name__ == "__main__":
-    print("Testing Folder Selection Dialog")
-    print("=" * 40)
-    
-    # Test basic functionality
-    basic_works = test_basic_folder_selection()
-    
-    # Test Assets folder functionality
-    assets_works = test_assets_folder_selection()
-    
-    print("\n" + "=" * 40)
-    print("Test Results:")
-    print(f"Basic folder selection: {'PASS' if basic_works else 'FAIL'}")
-    print(f"Assets folder selection: {'PASS' if assets_works else 'FAIL'}")
-    
-    if basic_works:
-        print("\ntkinter folder selection is working!")
-        print("You can now use this in your ExactModelNode.")
-    else:
-        print("\ntkinter might not be available or there's an issue.")
-        print("Consider using PyQt5 QFileDialog as fallback.")

tests/test_multi_series_fix.py

@@ -1,136 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify multi-series configuration fix
-"""
-
-import sys
-import os
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.insert(0, parent_dir)
-
-# Test the mflow_converter functionality
-def test_multi_series_config_building():
-    """Test building multi-series config from properties"""
-    print("Testing multi-series config building...")
-    
-    from core.functions.mflow_converter import MFlowConverter
-    
-    # Create converter instance
-    converter = MFlowConverter(default_fw_path='.')
-    
-    # Mock properties data that would come from a node
-    test_properties = {
-        'multi_series_mode': True,
-        'enabled_series': ['520', '720'],
-        'kl520_port_ids': '28,32',
-        'kl720_port_ids': '4',
-        'assets_folder': '',  # Empty for this test
-        'max_queue_size': 100
-    }
-    
-    # Test building config
-    config = converter._build_multi_series_config_from_properties(test_properties)
-    
-    print(f"Generated config: {config}")
-    
-    if config:
-        # Verify structure
-        assert 'KL520' in config, "KL520 should be in config"
-        assert 'KL720' in config, "KL720 should be in config"
-        
-        # Check KL520 config
-        kl520_config = config['KL520']
-        assert 'port_ids' in kl520_config, "KL520 should have port_ids"
-        assert kl520_config['port_ids'] == [28, 32], f"KL520 port_ids should be [28, 32], got {kl520_config['port_ids']}"
-        
-        # Check KL720 config
-        kl720_config = config['KL720']
-        assert 'port_ids' in kl720_config, "KL720 should have port_ids"
-        assert kl720_config['port_ids'] == [4], f"KL720 port_ids should be [4], got {kl720_config['port_ids']}"
-        
-        print("[OK] Multi-series config structure is correct")
-    else:
-        print("[ERROR] Config building returned None")
-        return False
-    
-    # Test with invalid port IDs
-    invalid_properties = {
-        'multi_series_mode': True,
-        'enabled_series': ['520'],
-        'kl520_port_ids': 'invalid,port,ids',
-        'assets_folder': ''
-    }
-    
-    invalid_config = converter._build_multi_series_config_from_properties(invalid_properties)
-    assert invalid_config is None, "Invalid port IDs should result in None config"
-    print("[OK] Invalid port IDs handled correctly")
-    
-    return True
-
-def test_stage_config():
-    """Test StageConfig with multi-series support"""
-    print("\\nTesting StageConfig with multi-series...")
-    
-    from core.functions.InferencePipeline import StageConfig
-    
-    # Test creating StageConfig with multi-series
-    multi_series_config = {
-        "KL520": {"port_ids": [28, 32]},
-        "KL720": {"port_ids": [4]}
-    }
-    
-    stage_config = StageConfig(
-        stage_id="test_stage",
-        port_ids=[],  # Not used in multi-series mode
-        scpu_fw_path='',
-        ncpu_fw_path='',
-        model_path='',
-        upload_fw=False,
-        multi_series_mode=True,
-        multi_series_config=multi_series_config
-    )
-    
-    print(f"Created StageConfig with multi_series_mode: {stage_config.multi_series_mode}")
-    print(f"Multi-series config: {stage_config.multi_series_config}")
-    
-    assert stage_config.multi_series_mode == True, "multi_series_mode should be True"
-    assert stage_config.multi_series_config == multi_series_config, "multi_series_config should match"
-    
-    print("[OK] StageConfig supports multi-series configuration")
-    return True
-
-def main():
-    """Run all tests"""
-    print("Testing Multi-Series Configuration Fix")
-    print("=" * 50)
-    
-    try:
-        # Test config building
-        if not test_multi_series_config_building():
-            print("[ERROR] Config building test failed")
-            return False
-        
-        # Test StageConfig
-        if not test_stage_config():
-            print("[ERROR] StageConfig test failed")
-            return False
-        
-        print("\\n" + "=" * 50)
-        print("[SUCCESS] All tests passed!")
-        print("\\nThe fix should now properly:")
-        print("1. Detect multi_series_mode from node properties")
-        print("2. Build multi_series_config from series-specific port IDs")
-        print("3. Pass the config to MultiDongle for true multi-series operation")
-        
-        return True
-        
-    except Exception as e:
-        print(f"[ERROR] Test failed with exception: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == "__main__":
-    success = main()
-    sys.exit(0 if success else 1)

tests/test_multi_series_integration_final.py

@@ -1,205 +0,0 @@
-"""
-Final Integration Test for Multi-Series Multidongle
-
-Comprehensive test suite for the completed multi-series integration
-"""
-
-import unittest
-import sys
-import os
-
-# Add project root (core/functions) to path
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.insert(0, os.path.join(parent_dir, 'core', 'functions'))
-
-from Multidongle import MultiDongle, DongleSeriesSpec
-
-class TestMultiSeriesIntegration(unittest.TestCase):
-    
-    def setUp(self):
-        """Set up test fixtures"""
-        self.multi_series_config = {
-            "KL520": {
-                "port_ids": [28, 32],
-                "model_path": "/path/to/kl520_model.nef",
-                "firmware_paths": {
-                    "scpu": "/path/to/kl520_scpu.bin",
-                    "ncpu": "/path/to/kl520_ncpu.bin"
-                }
-            },
-            "KL720": {
-                "port_ids": [40, 44],
-                "model_path": "/path/to/kl720_model.nef",
-                "firmware_paths": {
-                    "scpu": "/path/to/kl720_scpu.bin",
-                    "ncpu": "/path/to/kl720_ncpu.bin"
-                }
-            }
-        }
-    
-    def test_multi_series_initialization_success(self):
-        """Test that multi-series initialization works correctly"""
-        multidongle = MultiDongle(multi_series_config=self.multi_series_config)
-        
-        # Should be in multi-series mode
-        self.assertTrue(multidongle.multi_series_mode)
-        
-        # Should have series groups configured
-        self.assertIsNotNone(multidongle.series_groups)
-        self.assertIn("KL520", multidongle.series_groups)
-        self.assertIn("KL720", multidongle.series_groups)
-        
-        # Should have correct configuration for each series
-        kl520_config = multidongle.series_groups["KL520"]
-        self.assertEqual(kl520_config["port_ids"], [28, 32])
-        self.assertEqual(kl520_config["model_path"], "/path/to/kl520_model.nef")
-        
-        kl720_config = multidongle.series_groups["KL720"]
-        self.assertEqual(kl720_config["port_ids"], [40, 44])
-        self.assertEqual(kl720_config["model_path"], "/path/to/kl720_model.nef")
-        
-        # Should have GOPS weights calculated
-        self.assertIsNotNone(multidongle.gops_weights)
-        self.assertIn("KL520", multidongle.gops_weights)
-        self.assertIn("KL720", multidongle.gops_weights)
-        
-        # KL720 should have higher weight due to higher GOPS (28 vs 3 GOPS)
-        # But since both have 2 devices: KL520=3*2=6 total GOPS, KL720=28*2=56 total GOPS
-        # Total = 62 GOPS, so KL520 weight = 6/62 ≈ 0.097, KL720 weight = 56/62 ≈ 0.903
-        self.assertGreater(multidongle.gops_weights["KL720"], 
-                          multidongle.gops_weights["KL720"])
-        
-        # Weights should sum to 1.0
-        total_weight = sum(multidongle.gops_weights.values())
-        self.assertAlmostEqual(total_weight, 1.0, places=5)
-        
-        print("Multi-series initialization test passed")
-    
-    def test_single_series_to_multi_series_conversion_success(self):
-        """Test that single-series config gets converted to multi-series internally"""
-        # Legacy single-series initialization
-        multidongle = MultiDongle(
-            port_id=[28, 32],
-            scpu_fw_path="/path/to/scpu.bin",
-            ncpu_fw_path="/path/to/ncpu.bin", 
-            model_path="/path/to/model.nef",
-            upload_fw=True
-        )
-        
-        # Should NOT be in explicit multi-series mode (legacy mode)
-        self.assertFalse(multidongle.multi_series_mode)
-        
-        # But should internally convert to multi-series format
-        self.assertIsNotNone(multidongle.series_groups)
-        self.assertEqual(len(multidongle.series_groups), 1)
-        
-        # Should auto-detect series (will be KL520 based on available devices or fallback)
-        series_keys = list(multidongle.series_groups.keys())
-        self.assertEqual(len(series_keys), 1)
-        detected_series = series_keys[0]
-        self.assertIn(detected_series, DongleSeriesSpec.SERIES_SPECS.keys())
-        
-        # Should have correct port configuration
-        series_config = multidongle.series_groups[detected_series]
-        self.assertEqual(series_config["port_ids"], [28, 32])
-        self.assertEqual(series_config["model_path"], "/path/to/model.nef")
-        
-        # Should have 100% weight since it's single series
-        self.assertEqual(multidongle.gops_weights[detected_series], 1.0)
-        
-        print(f"Single-to-multi-series conversion test passed (detected: {detected_series})")
-    
-    def test_load_balancing_success(self):
-        """Test that load balancing works based on GOPS weights"""
-        multidongle = MultiDongle(multi_series_config=self.multi_series_config)
-        
-        # Should have load balancing method
-        optimal_series = multidongle._select_optimal_series()
-        self.assertIsNotNone(optimal_series)
-        self.assertIn(optimal_series, ["KL520", "KL720"])
-        
-        # With zero load, should select the series with highest weight (KL720)
-        self.assertEqual(optimal_series, "KL720")
-        
-        # Test load balancing under different conditions
-        # Simulate high load on KL720
-        multidongle.current_loads["KL720"] = 100
-        multidongle.current_loads["KL520"] = 0
-        
-        # Now should prefer KL520 despite lower GOPS due to lower load
-        optimal_series_with_load = multidongle._select_optimal_series()
-        self.assertEqual(optimal_series_with_load, "KL520")
-        
-        print("Load balancing test passed")
-    
-    def test_backward_compatibility_maintained(self):
-        """Test that existing single-series API still works perfectly"""
-        # This should work exactly as before
-        multidongle = MultiDongle(
-            port_id=[28, 32],
-            scpu_fw_path="/path/to/scpu.bin",
-            ncpu_fw_path="/path/to/ncpu.bin",
-            model_path="/path/to/model.nef"
-        )
-        
-        # Legacy properties should still exist and work
-        self.assertIsNotNone(multidongle.port_id)
-        self.assertEqual(multidongle.port_id, [28, 32])
-        self.assertEqual(multidongle.model_path, "/path/to/model.nef")
-        self.assertEqual(multidongle.scpu_fw_path, "/path/to/scpu.bin")
-        self.assertEqual(multidongle.ncpu_fw_path, "/path/to/ncpu.bin")
-        
-        # Legacy attributes should be available
-        self.assertIsNotNone(multidongle.device_group)  # Will be None initially
-        self.assertIsNotNone(multidongle._input_queue)
-        self.assertIsNotNone(multidongle._output_queue)
-        
-        print("Backward compatibility test passed")
-    
-    def test_series_specs_are_correct(self):
-        """Test that series specifications match expected values"""
-        specs = DongleSeriesSpec.SERIES_SPECS
-        
-        # Check that all expected series are present
-        expected_series = ["KL520", "KL720", "KL630", "KL730", "KL540"]
-        for series in expected_series:
-            self.assertIn(series, specs)
-        
-        # Check GOPS values are reasonable
-        self.assertEqual(specs["KL520"]["gops"], 3)
-        self.assertEqual(specs["KL720"]["gops"], 28)
-        self.assertEqual(specs["KL630"]["gops"], 400)
-        self.assertEqual(specs["KL730"]["gops"], 1600)
-        self.assertEqual(specs["KL540"]["gops"], 800)
-        
-        print("Series specifications test passed")
-    
-    def test_edge_cases(self):
-        """Test various edge cases and error handling"""
-        
-        # Test with empty port list (single-series)
-        multidongle_empty = MultiDongle(port_id=[])
-        self.assertEqual(len(multidongle_empty.series_groups), 0)
-        
-        # Test with unknown series (should raise error)
-        with self.assertRaises(ValueError):
-            MultiDongle(multi_series_config={"UNKNOWN_SERIES": {"port_ids": [1, 2]}})
-        
-        # Test with no port IDs in multi-series config
-        config_no_ports = {
-            "KL520": {
-                "port_ids": [],
-                "model_path": "/path/to/model.nef"
-            }
-        }
-        multidongle_no_ports = MultiDongle(multi_series_config=config_no_ports)
-        self.assertEqual(multidongle_no_ports.gops_weights["KL520"], 0.0)  # 0 weight due to no devices
-        
-        print("Edge cases test passed")
-
-if __name__ == '__main__':
-    print("Running Multi-Series Integration Tests")
-    print("=" * 50)
-    
-    unittest.main(verbosity=2)

tests/test_multi_series_multidongle.py

@@ -1,172 +0,0 @@
-"""
-Test Multi-Series Integration for Multidongle
-
-Testing the integration of multi-series functionality into the existing Multidongle class
-following TDD principles.
-"""
-
-import unittest
-import sys
-import os
-from unittest.mock import Mock, patch, MagicMock
-
-# Add project root (core/functions) to path
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.insert(0, os.path.join(parent_dir, 'core', 'functions'))
-
-from Multidongle import MultiDongle
-
-class TestMultiSeriesMultidongle(unittest.TestCase):
-    
-    def setUp(self):
-        """Set up test fixtures"""
-        self.multi_series_config = {
-            "KL520": {
-                "port_ids": [28, 32],
-                "model_path": "/path/to/kl520_model.nef",
-                "firmware_paths": {
-                    "scpu": "/path/to/kl520_scpu.bin",
-                    "ncpu": "/path/to/kl520_ncpu.bin"
-                }
-            },
-            "KL720": {
-                "port_ids": [40, 44],
-                "model_path": "/path/to/kl720_model.nef",
-                "firmware_paths": {
-                    "scpu": "/path/to/kl720_scpu.bin",
-                    "ncpu": "/path/to/kl720_ncpu.bin"
-                }
-            }
-        }
-    
-    def test_multi_series_initialization_should_fail(self):
-        """
-        Test that multi-series initialization accepts config and sets up series groups
-        This should FAIL initially since the functionality doesn't exist yet
-        """
-        # This should work but will fail initially
-        try:
-            multidongle = MultiDongle(multi_series_config=self.multi_series_config)
-            
-            # Should have series groups configured
-            self.assertIsNotNone(multidongle.series_groups)
-            self.assertIn("KL520", multidongle.series_groups)
-            self.assertIn("KL720", multidongle.series_groups)
-            
-            # Should have GOPS weights calculated
-            self.assertIsNotNone(multidongle.gops_weights)
-            self.assertIn("KL520", multidongle.gops_weights)
-            self.assertIn("KL720", multidongle.gops_weights)
-            
-            # KL720 should have higher weight due to higher GOPS
-            self.assertGreater(multidongle.gops_weights["KL720"], 
-                             multidongle.gops_weights["KL520"])
-            
-            self.fail("Multi-series initialization should not work yet - test should fail")
-            
-        except (AttributeError, TypeError) as e:
-            # Expected to fail at this stage
-            print(f"Expected failure: {e}")
-            self.assertTrue(True, "Multi-series initialization correctly fails (not implemented yet)")
-    
-    def test_single_series_to_multi_series_conversion_should_fail(self):
-        """
-        Test that single-series config gets converted to multi-series internally
-        This should FAIL initially
-        """
-        try:
-            # Legacy single-series initialization
-            multidongle = MultiDongle(
-                port_id=[28, 32],
-                scpu_fw_path="/path/to/scpu.bin",
-                ncpu_fw_path="/path/to/ncpu.bin", 
-                model_path="/path/to/model.nef",
-                upload_fw=True
-            )
-            
-            # Should internally convert to multi-series format
-            self.assertIsNotNone(multidongle.series_groups)
-            self.assertEqual(len(multidongle.series_groups), 1)
-            
-            # Should auto-detect series from device scan or use default
-            series_keys = list(multidongle.series_groups.keys())
-            self.assertEqual(len(series_keys), 1)
-            
-            self.fail("Single to multi-series conversion should not work yet")
-            
-        except (AttributeError, TypeError) as e:
-            # Expected to fail at this stage
-            print(f"Expected failure: {e}")
-            self.assertTrue(True, "Single-series conversion correctly fails (not implemented yet)")
-    
-    def test_load_balancing_should_fail(self):
-        """
-        Test that load balancing works based on GOPS weights
-        This should FAIL initially
-        """
-        try:
-            multidongle = MultiDongle(multi_series_config=self.multi_series_config)
-            
-            # Should have load balancing method
-            optimal_series = multidongle._select_optimal_series()
-            self.assertIsNotNone(optimal_series)
-            self.assertIn(optimal_series, ["KL520", "KL720"])
-            
-            self.fail("Load balancing should not work yet")
-            
-        except (AttributeError, TypeError) as e:
-            # Expected to fail at this stage 
-            print(f"Expected failure: {e}")
-            self.assertTrue(True, "Load balancing correctly fails (not implemented yet)")
-    
-    def test_backward_compatibility_should_work(self):
-        """
-        Test that existing single-series API still works
-        This should PASS (existing functionality)
-        """
-        # This should still work with existing code
-        try:
-            multidongle = MultiDongle(
-                port_id=[28, 32],
-                scpu_fw_path="/path/to/scpu.bin",
-                ncpu_fw_path="/path/to/ncpu.bin",
-                model_path="/path/to/model.nef"
-            )
-            
-            # Basic properties should still exist
-            self.assertIsNotNone(multidongle.port_id)
-            self.assertEqual(multidongle.port_id, [28, 32])
-            self.assertEqual(multidongle.model_path, "/path/to/model.nef")
-            
-            print("Backward compatibility test passed")
-            
-        except Exception as e:
-            self.fail(f"Backward compatibility should work: {e}")
-    
-    def test_multi_series_device_grouping_should_fail(self):
-        """
-        Test that devices are properly grouped by series
-        This should FAIL initially
-        """
-        try:
-            multidongle = MultiDongle(multi_series_config=self.multi_series_config)
-            multidongle.initialize()
-            
-            # Should have device groups for each series
-            self.assertIsNotNone(multidongle.device_groups)
-            self.assertEqual(len(multidongle.device_groups), 2)
-            
-            # Each series should have its device group
-            for series_name, config in self.multi_series_config.items():
-                self.assertIn(series_name, multidongle.device_groups)
-                
-            self.fail("Multi-series device grouping should not work yet")
-            
-        except (AttributeError, TypeError) as e:
-            # Expected to fail
-            print(f"Expected failure: {e}")
-            self.assertTrue(True, "Device grouping correctly fails (not implemented yet)")
-
-if __name__ == '__main__':
-    unittest.main()

tests/test_multidongle_start.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test MultiDongle start/stop functionality
-"""
-
-import sys
-import os
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.insert(0, parent_dir)
-
-def test_multidongle_start():
-    """Test MultiDongle start method"""
-    try:
-        from core.functions.Multidongle import MultiDongle
-        
-        # Test multi-series configuration
-        multi_series_config = {
-            "KL520": {"port_ids": [28, 32]},
-            "KL720": {"port_ids": [4]}
-        }
-        
-        print("Creating MultiDongle with multi-series config...")
-        multidongle = MultiDongle(multi_series_config=multi_series_config)
-        
-        print(f"Multi-series mode: {multidongle.multi_series_mode}")
-        print(f"Has _start_multi_series method: {hasattr(multidongle, '_start_multi_series')}")
-        print(f"Has _stop_multi_series method: {hasattr(multidongle, '_stop_multi_series')}")
-        
-        print("MultiDongle created successfully!")
-        
-        # Test that the required attributes exist
-        expected_attrs = ['send_threads', 'receive_threads', 'dispatcher_thread', 'result_ordering_thread']
-        for attr in expected_attrs:
-            if hasattr(multidongle, attr):
-                print(f"[OK] Has attribute: {attr}")
-            else:
-                print(f"[ERROR] Missing attribute: {attr}")
-        
-        print("Test completed successfully!")
-        
-    except Exception as e:
-        print(f"Error: {e}")
-        import traceback
-        traceback.print_exc()
-
-if __name__ == "__main__":
-    test_multidongle_start()

tests/test_port_id_config.py

@@ -1,203 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script for new series-specific port ID configuration functionality
-"""
-
-import sys
-import os
-
-# Add the project root to Python path
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.insert(0, parent_dir)
-
-try:
-    from core.nodes.exact_nodes import ExactModelNode
-    print("[OK] Successfully imported ExactModelNode")
-except ImportError as e:
-    print(f"[ERROR] Failed to import ExactModelNode: {e}")
-    sys.exit(1)
-
-def test_port_id_properties():
-    """Test that new port ID properties are created correctly"""
-    print("\n=== Testing Port ID Properties Creation ===")
-    
-    try:
-        node = ExactModelNode()
-        
-        # Test that all series port ID properties exist
-        series_properties = ['kl520_port_ids', 'kl720_port_ids', 'kl630_port_ids', 'kl730_port_ids', 'kl540_port_ids']
-        
-        for prop in series_properties:
-            if hasattr(node, 'get_property'):
-                try:
-                    value = node.get_property(prop)
-                    print(f"[OK] Property {prop} exists with value: '{value}'")
-                except:
-                    print(f"[ERROR] Property {prop} does not exist or cannot be accessed")
-            else:
-                print(f"[WARN] Node does not have get_property method (NodeGraphQt not available)")
-                break
-        
-        # Test property options
-        if hasattr(node, '_property_options'):
-            for prop in series_properties:
-                if prop in node._property_options:
-                    options = node._property_options[prop]
-                    print(f"[OK] Property options for {prop}: {options}")
-                else:
-                    print(f"[ERROR] No property options found for {prop}")
-        else:
-            print("[WARN] Node does not have _property_options")
-            
-    except Exception as e:
-        print(f"[ERROR] Error testing port ID properties: {e}")
-
-def test_display_properties():
-    """Test that display properties work correctly"""
-    print("\n=== Testing Display Properties ===")
-    
-    try:
-        node = ExactModelNode()
-        
-        if not hasattr(node, 'get_display_properties'):
-            print("[WARN] Node does not have get_display_properties method (NodeGraphQt not available)")
-            return
-        
-        # Test single-series mode
-        if hasattr(node, 'set_property'):
-            node.set_property('multi_series_mode', False)
-            single_props = node.get_display_properties()
-            print(f"[OK] Single-series display properties: {single_props}")
-            
-            # Test multi-series mode
-            node.set_property('multi_series_mode', True)
-            node.set_property('enabled_series', ['520', '720'])
-            multi_props = node.get_display_properties()
-            print(f"[OK] Multi-series display properties: {multi_props}")
-            
-            # Check if port ID properties are included
-            expected_port_props = ['kl520_port_ids', 'kl720_port_ids']
-            found_port_props = [prop for prop in multi_props if prop in expected_port_props]
-            print(f"[OK] Found port ID properties in display: {found_port_props}")
-            
-            # Test with different enabled series
-            node.set_property('enabled_series', ['630', '730'])
-            multi_props_2 = node.get_display_properties()
-            print(f"[OK] Display properties with KL630/730: {multi_props_2}")
-            
-        else:
-            print("[WARN] Node does not have set_property method (NodeGraphQt not available)")
-            
-    except Exception as e:
-        print(f"[ERROR] Error testing display properties: {e}")
-
-def test_multi_series_config():
-    """Test multi-series configuration building"""
-    print("\n=== Testing Multi-Series Config Building ===")
-    
-    try:
-        node = ExactModelNode()
-        
-        if not hasattr(node, '_build_multi_series_config'):
-            print("[ERROR] Node does not have _build_multi_series_config method")
-            return
-        
-        if not hasattr(node, 'set_property'):
-            print("[WARN] Node does not have set_property method (NodeGraphQt not available)")
-            return
-        
-        # Test with sample configuration
-        node.set_property('enabled_series', ['520', '720'])
-        node.set_property('kl520_port_ids', '28,32')
-        node.set_property('kl720_port_ids', '30,34')
-        node.set_property('assets_folder', '/fake/assets/path')
-        
-        # Build multi-series config
-        config = node._build_multi_series_config()
-        print(f"[OK] Generated multi-series config: {config}")
-        
-        # Verify structure
-        if config:
-            expected_keys = ['KL520', 'KL720']
-            for key in expected_keys:
-                if key in config:
-                    series_config = config[key]
-                    print(f"[OK] {key} config: {series_config}")
-                    
-                    if 'port_ids' in series_config:
-                        print(f"  - Port IDs: {series_config['port_ids']}")
-                    else:
-                        print(f"  [ERROR] Missing port_ids in {key} config")
-                else:
-                    print(f"[ERROR] Missing {key} in config")
-        else:
-            print("[ERROR] Generated config is None or empty")
-        
-        # Test with invalid port IDs
-        node.set_property('kl520_port_ids', 'invalid,port,ids')
-        config_invalid = node._build_multi_series_config()
-        print(f"[OK] Config with invalid port IDs: {config_invalid}")
-        
-    except Exception as e:
-        print(f"[ERROR] Error testing multi-series config: {e}")
-
-def test_inference_config():
-    """Test inference configuration"""
-    print("\n=== Testing Inference Config ===")
-    
-    try:
-        node = ExactModelNode()
-        
-        if not hasattr(node, 'get_inference_config'):
-            print("[ERROR] Node does not have get_inference_config method")
-            return
-        
-        if not hasattr(node, 'set_property'):
-            print("[WARN] Node does not have set_property method (NodeGraphQt not available)")
-            return
-        
-        # Test multi-series inference config
-        node.set_property('multi_series_mode', True)
-        node.set_property('enabled_series', ['520', '720'])
-        node.set_property('kl520_port_ids', '28,32')
-        node.set_property('kl720_port_ids', '30,34')
-        node.set_property('assets_folder', '/fake/assets')
-        node.set_property('max_queue_size', 50)
-        
-        inference_config = node.get_inference_config()
-        print(f"[OK] Inference config: {inference_config}")
-        
-        # Check if multi_series_config is included
-        if 'multi_series_config' in inference_config:
-            ms_config = inference_config['multi_series_config']
-            print(f"[OK] Multi-series config included: {ms_config}")
-        else:
-            print("[WARN] Multi-series config not found in inference config")
-        
-        # Test single-series mode
-        node.set_property('multi_series_mode', False)
-        node.set_property('model_path', '/fake/model.nef')
-        node.set_property('port_id', '28')
-        
-        single_config = node.get_inference_config()
-        print(f"[OK] Single-series config: {single_config}")
-        
-    except Exception as e:
-        print(f"[ERROR] Error testing inference config: {e}")
-
-def main():
-    """Run all tests"""
-    print("Testing Series-Specific Port ID Configuration")
-    print("=" * 50)
-    
-    test_port_id_properties()
-    test_display_properties()
-    test_multi_series_config()
-    test_inference_config()
-    
-    print("\n" + "=" * 50)
-    print("Test completed!")
-
-if __name__ == "__main__":
-    main()

tests/test_postprocess_mode.py

@@ -1,211 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script for postprocessing mode switching and visualization.
-"""
-
-import sys
-import os
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.append(parent_dir)
-
-from core.nodes.exact_nodes import ExactPostprocessNode
-
-def test_postprocess_node():
-    """Test the ExactPostprocessNode for mode switching and configuration."""
-    
-    print("=== Testing ExactPostprocessNode Mode Switching ===")
-    
-    # Create node instance
-    try:
-        node = ExactPostprocessNode()
-        print("✓ ExactPostprocessNode created successfully")
-        
-        # Check if NodeGraphQt is available
-        if not hasattr(node, 'set_property'):
-            print("⚠ NodeGraphQt not available - using mock properties")
-            return True  # Skip tests that require NodeGraphQt
-            
-    except Exception as e:
-        print(f"✗ Error creating node: {e}")
-        return False
-    
-    # Test different postprocessing modes
-    test_modes = [
-        ('fire_detection', 'No Fire,Fire'),
-        ('yolo_v3', 'person,car,bicycle,motorbike,aeroplane'),
-        ('yolo_v5', 'person,bicycle,car,motorbike,bus,truck'),
-        ('classification', 'cat,dog,bird,fish'),
-        ('raw_output', '')
-    ]
-    
-    print("\n--- Testing Mode Switching ---")
-    for mode, class_names in test_modes:
-        try:
-            # Set properties for this mode
-            node.set_property('postprocess_type', mode)
-            node.set_property('class_names', class_names)
-            node.set_property('confidence_threshold', 0.6)
-            node.set_property('nms_threshold', 0.4)
-            
-            # Get configuration
-            config = node.get_postprocessing_config()
-            options = node.get_multidongle_postprocess_options()
-            
-            print(f"✓ Mode: {mode}")
-            print(f"  - Class names: {class_names}")
-            print(f"  - Config: {config['postprocess_type']}")
-            if options:
-                print(f"  - PostProcessor options created successfully")
-            else:
-                print(f"  - Warning: PostProcessor options not available")
-            
-        except Exception as e:
-            print(f"✗ Error testing mode {mode}: {e}")
-            return False
-    
-    # Test validation
-    print("\n--- Testing Configuration Validation ---")
-    try:
-        # Valid configuration
-        node.set_property('postprocess_type', 'fire_detection')
-        node.set_property('confidence_threshold', 0.7)
-        node.set_property('nms_threshold', 0.3)
-        node.set_property('max_detections', 50)
-        
-        is_valid, message = node.validate_configuration()
-        if is_valid:
-            print("✓ Valid configuration passed validation")
-        else:
-            print(f"✗ Valid configuration failed: {message}")
-            return False
-        
-        # Invalid configuration
-        node.set_property('confidence_threshold', 1.5)  # Invalid value
-        is_valid, message = node.validate_configuration()
-        if not is_valid:
-            print(f"✓ Invalid configuration caught: {message}")
-        else:
-            print("✗ Invalid configuration not caught")
-            return False
-        
-    except Exception as e:
-        print(f"✗ Error testing validation: {e}")
-        return False
-    
-    # Test display properties
-    print("\n--- Testing Display Properties ---")
-    try:
-        display_props = node.get_display_properties()
-        expected_props = ['postprocess_type', 'class_names', 'confidence_threshold']
-        
-        for prop in expected_props:
-            if prop in display_props:
-                print(f"✓ Display property found: {prop}")
-            else:
-                print(f"✗ Missing display property: {prop}")
-                return False
-                
-    except Exception as e:
-        print(f"✗ Error testing display properties: {e}")
-        return False
-    
-    # Test business properties
-    print("\n--- Testing Business Properties ---")
-    try:
-        business_props = node.get_business_properties()
-        print(f"✓ Business properties retrieved: {len(business_props)} properties")
-        
-        # Check key properties exist
-        key_props = ['postprocess_type', 'class_names', 'confidence_threshold', 'nms_threshold']
-        for prop in key_props:
-            if prop in business_props:
-                print(f"✓ Key property found: {prop} = {business_props[prop]}")
-            else:
-                print(f"✗ Missing key property: {prop}")
-                return False
-                
-    except Exception as e:
-        print(f"✗ Error testing business properties: {e}")
-        return False
-    
-    print("\n=== All Tests Passed! ===")
-    return True
-
-def test_visualization_integration():
-    """Test visualization integration with different modes."""
-    
-    print("\n=== Testing Visualization Integration ===")
-    
-    try:
-        node = ExactPostprocessNode()
-        
-        # Test each mode for visualization compatibility
-        test_cases = [
-            {
-                'mode': 'fire_detection',
-                'classes': 'No Fire,Fire',
-                'expected_classes': 2,
-                'description': 'Binary fire detection'
-            },
-            {
-                'mode': 'yolo_v3', 
-                'classes': 'person,car,bicycle,motorbike,bus',
-                'expected_classes': 5,
-                'description': 'Object detection'
-            },
-            {
-                'mode': 'classification',
-                'classes': 'cat,dog,bird,fish,rabbit',
-                'expected_classes': 5,
-                'description': 'Multi-class classification'
-            }
-        ]
-        
-        for case in test_cases:
-            print(f"\n--- {case['description']} ---")
-            
-            # Configure node
-            node.set_property('postprocess_type', case['mode'])
-            node.set_property('class_names', case['classes'])
-            
-            # Get configuration for visualization
-            config = node.get_postprocessing_config()
-            parsed_classes = config['class_names']
-            
-            print(f"✓ Mode: {case['mode']}")
-            print(f"✓ Classes: {parsed_classes}")
-            print(f"✓ Expected {case['expected_classes']}, got {len(parsed_classes)}")
-            
-            if len(parsed_classes) == case['expected_classes']:
-                print("✓ Class count matches expected")
-            else:
-                print(f"✗ Class count mismatch: expected {case['expected_classes']}, got {len(parsed_classes)}")
-                return False
-        
-        print("\n✓ Visualization integration tests passed!")
-        return True
-        
-    except Exception as e:
-        print(f"✗ Error in visualization integration test: {e}")
-        return False
-
-if __name__ == "__main__":
-    print("Starting ExactPostprocessNode Tests...\n")
-    
-    success = True
-    
-    # Run main functionality tests
-    if not test_postprocess_node():
-        success = False
-    
-    # Run visualization integration tests
-    if not test_visualization_integration():
-        success = False
-    
-    if success:
-        print("\n🎉 All tests completed successfully!")
-        print("ExactPostprocessNode is ready for mode switching and visualization!")
-    else:
-        print("\n❌ Some tests failed. Please check the implementation.")
-        sys.exit(1)

tests/test_result_formatting_fix.py

@@ -1,172 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify result formatting fixes for string probability values
-"""
-import sys
-import os
-
-# Add UI dialogs to path  
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.append(os.path.join(parent_dir, 'ui', 'dialogs'))
-
-def test_probability_formatting():
-    """Test that probability formatting handles both numeric and string values"""
-    
-    print("Testing probability formatting fixes...")
-    
-    # Test cases with different probability value types
-    test_cases = [
-        # Numeric probability (should work with :.3f)
-        {"probability": 0.85, "result_string": "Fire", "expected_error": False},
-        
-        # String probability that can be converted to float
-        {"probability": "0.75", "result_string": "Fire", "expected_error": False},
-        
-        # String probability that cannot be converted to float  
-        {"probability": "High", "result_string": "Fire", "expected_error": False},
-        
-        # None probability
-        {"probability": None, "result_string": "No result", "expected_error": False},
-        
-        # Dict result with numeric probability
-        {"dict_result": {"probability": 0.65, "class_name": "Fire"}, "expected_error": False},
-        
-        # Dict result with string probability
-        {"dict_result": {"probability": "Medium", "class_name": "Fire"}, "expected_error": False},
-    ]
-    
-    all_passed = True
-    
-    for i, case in enumerate(test_cases, 1):
-        print(f"\nTest case {i}:")
-        
-        try:
-            if "dict_result" in case:
-                # Test dict formatting
-                result = case["dict_result"]
-                for key, value in result.items():
-                    if key == 'probability':
-                        try:
-                            prob_value = float(value)
-                            formatted = f"    Probability: {prob_value:.3f}"
-                            print(f"  Dict probability formatted: {formatted}")
-                        except (ValueError, TypeError):
-                            formatted = f"    Probability: {value}"
-                            print(f"  Dict probability (as string): {formatted}")
-                    else:
-                        formatted = f"    {key}: {value}"
-                        print(f"  Dict {key}: {formatted}")
-            else:
-                # Test tuple formatting
-                probability = case["probability"]
-                result_string = case["result_string"]
-                
-                print(f"  Testing probability: {probability} (type: {type(probability)})")
-                
-                # Test the formatting logic
-                try:
-                    prob_value = float(probability)
-                    formatted_prob = f"    Probability: {prob_value:.3f}"
-                    print(f"  Formatted as float: {formatted_prob}")
-                except (ValueError, TypeError):
-                    formatted_prob = f"    Probability: {probability}"
-                    print(f"  Formatted as string: {formatted_prob}")
-                
-                formatted_result = f"    Result: {result_string}"
-                print(f"  Formatted result: {formatted_result}")
-            
-            print(f"  ✓ Test case {i} passed")
-            
-        except Exception as e:
-            print(f"  ✗ Test case {i} failed: {e}")
-            if not case["expected_error"]:
-                all_passed = False
-    
-    return all_passed
-
-def test_terminal_results_mock():
-    """Mock test of the terminal results formatting logic"""
-    
-    print("\n" + "="*50)
-    print("Testing terminal results formatting logic...")
-    
-    # Mock result dictionary with various probability types
-    mock_result_dict = {
-        'timestamp': 1234567890.123,
-        'pipeline_id': 'test-pipeline',
-        'stage_results': {
-            'stage1': (0.85, "Fire Detected"),           # Numeric probability
-            'stage2': ("High", "Object Found"),          # String probability  
-            'stage3': {"probability": 0.65, "result": "Classification"},  # Dict with numeric
-            'stage4': {"probability": "Medium", "result": "Detection"}     # Dict with string
-        }
-    }
-    
-    try:
-        # Simulate the formatting logic
-        from datetime import datetime
-        
-        timestamp = datetime.fromtimestamp(mock_result_dict.get('timestamp', 0)).strftime("%H:%M:%S.%f")[:-3]
-        pipeline_id = mock_result_dict.get('pipeline_id', 'Unknown')
-        
-        output_lines = []
-        output_lines.append(f"\nINFERENCE RESULT [{timestamp}]")
-        output_lines.append(f"   Pipeline ID: {pipeline_id}")
-        output_lines.append("   " + "="*50)
-        
-        stage_results = mock_result_dict.get('stage_results', {})
-        for stage_id, result in stage_results.items():
-            output_lines.append(f"   Stage: {stage_id}")
-            
-            if isinstance(result, tuple) and len(result) == 2:
-                probability, result_string = result
-                output_lines.append(f"      Result: {result_string}")
-                
-                # Test the safe formatting
-                try:
-                    prob_value = float(probability)
-                    output_lines.append(f"      Probability: {prob_value:.3f}")
-                except (ValueError, TypeError):
-                    output_lines.append(f"      Probability: {probability}")
-                    
-            elif isinstance(result, dict):
-                for key, value in result.items():
-                    if key == 'probability':
-                        try:
-                            prob_value = float(value)
-                            output_lines.append(f"      {key.title()}: {prob_value:.3f}")
-                        except (ValueError, TypeError):
-                            output_lines.append(f"      {key.title()}: {value}")
-                    else:
-                        output_lines.append(f"      {key.title()}: {value}")
-            
-            output_lines.append("")
-        
-        formatted_output = "\n".join(output_lines)
-        print("Formatted terminal output:")
-        print(formatted_output)
-        print("✓ Terminal formatting test passed")
-        return True
-        
-    except Exception as e:
-        print(f"✗ Terminal formatting test failed: {e}")
-        return False
-
-if __name__ == "__main__":
-    print("Running result formatting fix tests...")
-    
-    try:
-        test1_passed = test_probability_formatting()
-        test2_passed = test_terminal_results_mock()
-        
-        if test1_passed and test2_passed:
-            print("\n🎉 All formatting fix tests passed! The format string errors should be resolved.")
-        else:
-            print("\n❌ Some tests failed. Please check the output above.")
-            
-    except Exception as e:
-        print(f"\n❌ Test suite failed with error: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)

tests/test_yolov5_fixed.py

@@ -1,225 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to verify YOLOv5 postprocessing fixes
-
-This script tests the improved YOLOv5 postprocessing configuration
-to ensure positive probabilities and proper bounding box detection.
-"""
-import sys
-import os
-import numpy as np
-
-# Add core functions to path
-current_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.dirname(current_dir)
-sys.path.append(os.path.join(parent_dir, 'core', 'functions'))
-
-def test_yolov5_postprocessor():
-    """Test the improved YOLOv5 postprocessor with mock data"""
-    from Multidongle import PostProcessorOptions, PostProcessType, PostProcessor
-    
-    print("=" * 60)
-    print("Testing Improved YOLOv5 Postprocessor")
-    print("=" * 60)
-    
-    # Create YOLOv5 postprocessor options
-    options = PostProcessorOptions(
-        postprocess_type=PostProcessType.YOLO_V5,
-        threshold=0.3,
-        class_names=["person", "bicycle", "car", "motorbike", "aeroplane", "bus"],
-        nms_threshold=0.5,
-        max_detections_per_class=50
-    )
-    
-    postprocessor = PostProcessor(options)
-    
-    print(f"✓ Postprocessor created with type: {options.postprocess_type.value}")
-    print(f"✓ Confidence threshold: {options.threshold}")
-    print(f"✓ NMS threshold: {options.nms_threshold}")
-    print(f"✓ Number of classes: {len(options.class_names)}")
-    
-    # Create mock YOLOv5 output data - format: [batch, detections, features]
-    # Features: [x_center, y_center, width, height, objectness, class0_prob, class1_prob, ...]
-    mock_output = create_mock_yolov5_output()
-    
-    # Test processing
-    try:
-        result = postprocessor.process([mock_output])
-        
-        print(f"\n📊 Processing Results:")
-        print(f"   Result type: {type(result).__name__}")
-        print(f"   Detected objects: {result.box_count}")
-        print(f"   Available classes: {result.class_count}")
-        
-        if result.box_count > 0:
-            print(f"\n📦 Detection Details:")
-            for i, box in enumerate(result.box_list):
-                print(f"   Detection {i+1}:")
-                print(f"     Class: {box.class_name} (ID: {box.class_num})")
-                print(f"     Confidence: {box.score:.3f}")
-                print(f"     Bounding Box: ({box.x1}, {box.y1}) to ({box.x2}, {box.y2})")
-                print(f"     Box Size: {box.x2 - box.x1} x {box.y2 - box.y1}")
-        
-        # Verify positive probabilities
-        all_positive = all(box.score > 0 for box in result.box_list)
-        print(f"\n✓ All probabilities positive: {all_positive}")
-        
-        # Verify reasonable coordinates
-        valid_coords = all(
-            box.x2 > box.x1 and box.y2 > box.y1 
-            for box in result.box_list
-        )
-        print(f"✓ All bounding boxes valid: {valid_coords}")
-        
-        return result
-        
-    except Exception as e:
-        print(f"❌ Postprocessing failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return None
-
-def create_mock_yolov5_output():
-    """Create mock YOLOv5 output data for testing"""
-    # YOLOv5 output format: [batch_size, num_detections, num_features]
-    # Features: [x_center, y_center, width, height, objectness, class_probs...]
-    
-    batch_size = 1
-    num_detections = 25200  # Typical YOLOv5 output size
-    num_classes = 80  # COCO classes
-    num_features = 5 + num_classes  # coords + objectness + class probs
-    
-    # Create mock output
-    mock_output = np.zeros((batch_size, num_detections, num_features), dtype=np.float32)
-    
-    # Add some realistic detections
-    detections = [
-        # Format: [x_center, y_center, width, height, objectness, class_id, class_prob]
-        [320, 240, 100, 150, 0.8, 0, 0.9],   # person
-        [500, 300, 80, 60, 0.7, 2, 0.85],    # car  
-        [150, 100, 60, 120, 0.6, 1, 0.75],   # bicycle
-    ]
-    
-    for i, detection in enumerate(detections):
-        x_center, y_center, width, height, objectness, class_id, class_prob = detection
-        
-        # Set coordinates and objectness
-        mock_output[0, i, 0] = x_center
-        mock_output[0, i, 1] = y_center
-        mock_output[0, i, 2] = width
-        mock_output[0, i, 3] = height
-        mock_output[0, i, 4] = objectness
-        
-        # Set class probabilities (one-hot style)
-        mock_output[0, i, 5 + int(class_id)] = class_prob
-    
-    print(f"✓ Created mock YOLOv5 output: {mock_output.shape}")
-    print(f"   Added {len(detections)} test detections")
-    
-    # Wrap in mock output object
-    class MockOutput:
-        def __init__(self, data):
-            self.ndarray = data
-    
-    return MockOutput(mock_output)
-
-def test_result_formatting():
-    """Test the result formatting functions"""
-    from Multidongle import ObjectDetectionResult, BoundingBox
-    
-    print(f"\n" + "=" * 60)
-    print("Testing Result Formatting")
-    print("=" * 60)
-    
-    # Create mock detection result
-    boxes = [
-        BoundingBox(x1=100, y1=200, x2=200, y2=350, score=0.85, class_num=0, class_name="person"),
-        BoundingBox(x1=300, y1=150, x2=380, y2=210, score=0.75, class_num=2, class_name="car"),
-        BoundingBox(x1=50, y1=100, x2=110, y2=220, score=0.65, class_num=1, class_name="bicycle"),
-    ]
-    
-    result = ObjectDetectionResult(
-        class_count=80,
-        box_count=len(boxes),
-        box_list=boxes
-    )
-    
-    # Test the enhanced result string generation  
-    from Multidongle import MultiDongle, PostProcessorOptions, PostProcessType
-    # Create a minimal MultiDongle instance to access the method
-    options = PostProcessorOptions(postprocess_type=PostProcessType.YOLO_V5)
-    multidongle = MultiDongle(port_id=[1], postprocess_options=options)  # Dummy port
-    result_string = multidongle._generate_result_string(result)
-    
-    print(f"📝 Generated result string: {result_string}")
-    
-    # Test individual object summaries
-    print(f"\n📊 Object Summary:")
-    object_counts = {}
-    for box in boxes:
-        if box.class_name in object_counts:
-            object_counts[box.class_name] += 1
-        else:
-            object_counts[box.class_name] = 1
-    
-    for class_name, count in sorted(object_counts.items()):
-        print(f"   {count} {class_name}{'s' if count > 1 else ''}")
-    
-    return result
-
-def show_configuration_usage():
-    """Show how to use the fixed configuration"""
-    print(f"\n" + "=" * 60)
-    print("Configuration Usage Instructions")
-    print("=" * 60)
-    
-    print(f"\n🔧 Updated Configuration:")
-    print(f"   1. Modified multi_series_example.mflow:")
-    print(f"      - Set 'enable_postprocessing': true")
-    print(f"      - Added ExactPostprocessNode with YOLOv5 settings")
-    print(f"      - Connected Model → Postprocess → Output")
-    
-    print(f"\n⚙️ Postprocessing Settings:")
-    print(f"   - postprocess_type: 'yolo_v5'")
-    print(f"   - confidence_threshold: 0.3")
-    print(f"   - nms_threshold: 0.5")
-    print(f"   - class_names: Full COCO 80 classes")
-    
-    print(f"\n🎯 Expected Improvements:")
-    print(f"   ✓ Positive probability values (0.0 to 1.0)")
-    print(f"   ✓ Proper object detection with bounding boxes")
-    print(f"   ✓ Correct class names (person, car, bicycle, etc.)")
-    print(f"   ✓ Enhanced live view with corner markers")
-    print(f"   ✓ Detailed terminal output with object counts")
-    print(f"   ✓ Non-Maximum Suppression to reduce duplicates")
-    
-    print(f"\n📁 Files Modified:")
-    print(f"   - core/functions/Multidongle.py (improved YOLO processing)")
-    print(f"   - multi_series_example.mflow (added postprocess node)")
-    print(f"   - Enhanced live view display and terminal output")
-
-if __name__ == "__main__":
-    print("YOLOv5 Postprocessing Fix Verification")
-    print("=" * 60)
-    
-    try:
-        # Test the postprocessor
-        result = test_yolov5_postprocessor()
-        
-        if result:
-            # Test result formatting
-            test_result_formatting()
-            
-            # Show usage instructions
-            show_configuration_usage()
-            
-            print(f"\n🎉 All tests passed! YOLOv5 postprocessing should now work correctly.")
-            print(f"   Use the updated multi_series_example.mflow configuration.")
-        else:
-            print(f"\n❌ Tests failed. Please check the error messages above.")
-        
-    except Exception as e:
-        print(f"\n❌ Test suite failed with error: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)

ui/dialogs/deployment.py

@@ -35,10 +35,24 @@ from PyQt5.QtWidgets import (
 from PyQt5.QtCore import Qt, QThread, pyqtSignal, QTimer
 from PyQt5.QtGui import QFont, QColor, QPalette, QImage, QPixmap
 
-# Ensure project root is on sys.path so that 'core.functions' package imports work
-PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', '..'))
-if PROJECT_ROOT not in sys.path:
-    sys.path.insert(0, PROJECT_ROOT)
+# Import our converter and pipeline system
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'core', 'functions'))
+
+# Multi-series imports
+try:
+    from ui.dialogs.multi_series_config import MultiSeriesConfigDialog
+    MULTI_SERIES_UI_AVAILABLE = True
+except ImportError as e:
+    print(f"Warning: Multi-series UI not available: {e}")
+    MULTI_SERIES_UI_AVAILABLE = False
+
+try:
+    from multi_series_dongle_manager import MultiSeriesDongleManager
+    from core.functions.multi_series_mflow_converter import MultiSeriesMFlowConverter
+    MULTI_SERIES_BACKEND_AVAILABLE = True
+except ImportError as e:
+    print(f"Warning: Multi-series backend not available: {e}")
+    MULTI_SERIES_BACKEND_AVAILABLE = False
 
 try:
     from core.functions.mflow_converter import MFlowConverter, PipelineConfig
@@ -81,10 +95,8 @@ class StdoutCapture:
                 
             def write(self, text):
                 # Write to original stdout/stderr (so it still appears in terminal)
-                # Check if original exists (it might be None in PyInstaller builds)
-                if self.original is not None:
-                    self.original.write(text)
-                    self.original.flush()
+                self.original.write(text)
+                self.original.flush()
                 
                 # Capture for GUI if it's a substantial message and not already emitting
                 if text.strip() and not self._emitting:
@@ -95,9 +107,7 @@ class StdoutCapture:
                         self._emitting = False
                     
             def flush(self):
-                # Check if original exists before calling flush
-                if self.original is not None:
-                    self.original.flush()
+                self.original.flush()
         
         # Replace stdout and stderr with our tee writers
         sys.stdout = TeeWriter(self.original_stdout, self.captured_output, self.signal_emitter)
@@ -125,15 +135,112 @@ class DeploymentWorker(QThread):
     result_updated = pyqtSignal(dict)  # For inference results
     terminal_output = pyqtSignal(str)  # For terminal output in GUI
     stdout_captured = pyqtSignal(str)  # For captured stdout/stderr
+    multi_series_status = pyqtSignal(dict)  # For multi-series dongle status
     
-    def __init__(self, pipeline_data: Dict[str, Any]):
+    def __init__(self, pipeline_data: Dict[str, Any], multi_series_config: Dict[str, Any] = None):
         super().__init__()
         self.pipeline_data = pipeline_data
+        self.multi_series_config = multi_series_config
         self.should_stop = False
         self.orchestrator = None
+        self.multi_series_manager = None
         
     def run(self):
         """Main deployment workflow."""
+        try:
+            # Check if this is a multi-series deployment
+            is_multi_series = self._check_multi_series_mode()
+            
+            if is_multi_series and self.multi_series_config:
+                self._run_multi_series_deployment()
+            else:
+                self._run_single_series_deployment()
+                
+        except Exception as e:
+            self.error_occurred.emit(f"Deployment error: {str(e)}")
+    
+    def _check_multi_series_mode(self) -> bool:
+        """Check if any nodes are configured for multi-series mode"""
+        nodes = self.pipeline_data.get('nodes', [])
+        for node in nodes:
+            # Check for any Model node type (including ExactModelNode)
+            if 'Model' in node.get('type', ''):
+                # Check properties in order of preference
+                node_properties = node.get('properties', {})  # New format
+                if not node_properties:
+                    node_properties = node.get('custom_properties', {})  # Fallback 1
+                if not node_properties:
+                    node_properties = node.get('custom', {})  # Fallback 2
+                
+                if node_properties.get('multi_series_mode', False):
+                    print(f"Multi-series mode detected in node: {node.get('name', 'Unknown')}")
+                    return True
+        return False
+    
+    def _run_multi_series_deployment(self):
+        """Run multi-series deployment workflow"""
+        try:
+            # Step 1: Convert to multi-series configuration
+            self.progress_updated.emit(10, "Converting to multi-series configuration...")
+            
+            if not MULTI_SERIES_BACKEND_AVAILABLE:
+                self.error_occurred.emit("Multi-series backend not available. Please check installation.")
+                return
+            
+            converter = MultiSeriesMFlowConverter()
+            multi_series_config = converter.convert_to_multi_series(
+                self.pipeline_data, 
+                self.multi_series_config
+            )
+            
+            # Step 2: Validate multi-series configuration
+            self.progress_updated.emit(30, "Validating multi-series configuration...")
+            is_valid, issues = converter.validate_multi_series_config(multi_series_config)
+            
+            if not is_valid:
+                error_msg = "Multi-series configuration validation failed:\n" + "\n".join(issues)
+                self.error_occurred.emit(error_msg)
+                return
+            
+            self.progress_updated.emit(50, "Configuration validation passed")
+            
+            # Step 3: Initialize MultiSeriesDongleManager
+            self.progress_updated.emit(60, "Initializing multi-series dongle manager...")
+            
+            self.multi_series_manager = converter.create_multi_series_manager(multi_series_config)
+            if not self.multi_series_manager:
+                self.error_occurred.emit("Failed to initialize multi-series dongle manager")
+                return
+            
+            self.progress_updated.emit(80, "Starting multi-series inference...")
+            self.deployment_started.emit()
+            
+            # Start the multi-series manager
+            self.multi_series_manager.start()
+            
+            # Emit status
+            status_info = {
+                'type': 'multi_series',
+                'enabled_series': multi_series_config.enabled_series,
+                'total_gops': sum([
+                    {'KL520': 3, 'KL720': 28, 'KL630': 400, 'KL730': 1600, 'KL540': 800}.get(series, 0)
+                    for series in multi_series_config.enabled_series
+                ]),
+                'port_mapping': multi_series_config.port_mapping
+            }
+            self.multi_series_status.emit(status_info)
+            
+            self.progress_updated.emit(100, "Multi-series pipeline deployed successfully!")
+            self.deployment_completed.emit(True, f"Multi-series pipeline deployed with {len(multi_series_config.enabled_series)} series")
+            
+            # Keep running and processing results
+            self._process_multi_series_results()
+            
+        except Exception as e:
+            self.error_occurred.emit(f"Multi-series deployment failed: {str(e)}")
+    
+    def _run_single_series_deployment(self):
+        """Run single-series deployment workflow (original behavior)"""
         try:
             # Step 1: Convert .mflow to pipeline config
             self.progress_updated.emit(10, "Converting pipeline configuration...")
@@ -217,8 +324,7 @@ class DeploymentWorker(QThread):
                             # Add current FPS from pipeline to result_dict
                             current_fps = pipeline.get_current_fps()
                             result_dict['current_pipeline_fps'] = current_fps
-                            if os.getenv('C4NPU_DEBUG', '0') == '1':
-                                print(f"DEBUG: Pipeline FPS = {current_fps:.2f}")  # Debug info
+                            print(f"DEBUG: Pipeline FPS = {current_fps:.2f}")  # Debug info
                             
                             # Send to GUI terminal and results display
                             terminal_output = self._format_terminal_results(result_dict)
@@ -243,11 +349,56 @@ class DeploymentWorker(QThread):
         except Exception as e:
             self.error_occurred.emit(f"Deployment error: {str(e)}")
     
+    def _process_multi_series_results(self):
+        """Process results from multi-series manager"""
+        import cv2
+        
+        try:
+            while not self.should_stop:
+                # Get result from multi-series manager
+                result = self.multi_series_manager.get_result(timeout=0.1)
+                
+                if result:
+                    # Process result for UI display
+                    result_dict = {
+                        'sequence_id': result.sequence_id,
+                        'dongle_series': result.dongle_series,
+                        'timestamp': result.timestamp,
+                        'stage_results': {
+                            f'{result.dongle_series}_stage': result.result
+                        }
+                    }
+                    
+                    # Emit result for GUI display
+                    self.result_updated.emit(result_dict)
+                    
+                    # Emit terminal output
+                    terminal_text = f"[{result.dongle_series}] Sequence {result.sequence_id}: Processed"
+                    self.terminal_output.emit(terminal_text)
+                    
+                    # Get and emit statistics
+                    stats = self.multi_series_manager.get_statistics()
+                    status_info = {
+                        'type': 'multi_series',
+                        'stats': stats,
+                        'current_loads': stats.get('current_loads', {}),
+                        'total_processed': stats.get('total_completed', 0),
+                        'queue_size': stats.get('input_queue_size', 0)
+                    }
+                    self.multi_series_status.emit(status_info)
+                
+                self.msleep(10)  # Small delay to prevent busy waiting
+                
+        except Exception as e:
+            self.error_occurred.emit(f"Error processing multi-series results: {str(e)}")
+    
     def stop(self):
         """Stop the deployment process."""
         self.should_stop = True
         if self.orchestrator:
             self.orchestrator.stop()
+        if self.multi_series_manager:
+            self.multi_series_manager.stop()
     
     def _format_terminal_results(self, result_dict):
         """Format inference results for terminal display in GUI."""
@@ -270,89 +421,42 @@ class DeploymentWorker(QThread):
                     output_lines.append(f"   Stage: {stage_id}")
                     
                     if isinstance(result, tuple) and len(result) == 2:
-                        # Handle tuple results (may be (ObjectDetectionResult, result_string) or (float, result_string))
-                        probability_or_obj, result_string = result
+                        # Handle tuple results (probability, result_string) - matching actual format
+                        probability, result_string = result
                         output_lines.append(f"      Result: {result_string}")
+                        output_lines.append(f"      Probability: {probability:.3f}")
                         
-                        # If first element is an object detection result, summarize detections
-                        if hasattr(probability_or_obj, 'box_count') and hasattr(probability_or_obj, 'box_list'):
-                            det = probability_or_obj
-                            output_lines.append(f"      Detections: {int(getattr(det, 'box_count', 0))}")
-                            # Optional short class summary
-                            class_counts = {}
-                            for b in getattr(det, 'box_list', [])[:5]:
-                                name = getattr(b, 'class_name', 'object')
-                                class_counts[name] = class_counts.get(name, 0) + 1
-                            if class_counts:
-                                summary = ", ".join(f"{k} x{v}" for k, v in class_counts.items())
-                                output_lines.append(f"      Classes: {summary}")
+                        # Add confidence level
+                        if probability > 0.8:
+                            confidence = "Very High"
+                        elif probability > 0.6:
+                            confidence = "High"
+                        elif probability > 0.4:
+                            confidence = "Medium"
                         else:
-                            # Safely format numeric probability
-                            try:
-                                prob_value = float(probability_or_obj)
-                                output_lines.append(f"      Probability: {prob_value:.3f}")
-                                # Add confidence level
-                                if prob_value > 0.8:
-                                    confidence = "Very High"
-                                elif prob_value > 0.6:
-                                    confidence = "High"
-                                elif prob_value > 0.4:
-                                    confidence = "Medium"
-                                else:
-                                    confidence = "Low"
-                                output_lines.append(f"      Confidence: {confidence}")
-                            except (ValueError, TypeError):
-                                output_lines.append(f"      Probability: {probability_or_obj}")
+                            confidence = "Low"
+                        output_lines.append(f"      Confidence: {confidence}")
                         
                     elif isinstance(result, dict):
                         # Handle dict results
                         for key, value in result.items():
                             if key == 'probability':
-                                try:
-                                    prob_value = float(value)
-                                    output_lines.append(f"      {key.title()}: {prob_value:.3f}")
-                                except (ValueError, TypeError):
-                                    output_lines.append(f"      {key.title()}: {value}")
+                                output_lines.append(f"      {key.title()}: {value:.3f}")
                             elif key == 'result':
                                 output_lines.append(f"      {key.title()}: {value}")
                             elif key == 'confidence':
                                 output_lines.append(f"      {key.title()}: {value}")
                             elif key == 'fused_probability':
-                                try:
-                                    prob_value = float(value)
-                                    output_lines.append(f"      Fused Probability: {prob_value:.3f}")
-                                except (ValueError, TypeError):
-                                    output_lines.append(f"      Fused Probability: {value}")
+                                output_lines.append(f"      Fused Probability: {value:.3f}")
                             elif key == 'individual_probs':
                                 output_lines.append(f"      Individual Probabilities:")
                                 for prob_key, prob_value in value.items():
-                                    try:
-                                        float_prob = float(prob_value)
-                                        output_lines.append(f"         {prob_key}: {float_prob:.3f}")
-                                    except (ValueError, TypeError):
-                                        output_lines.append(f"         {prob_key}: {prob_value}")
+                                    output_lines.append(f"         {prob_key}: {prob_value:.3f}")
                             else:
                                 output_lines.append(f"      {key}: {value}")
                     else:
-                        # Handle other result types, including detection objects
-                        # Try to pretty-print ObjectDetectionResult-like objects
-                        try:
-                            if hasattr(result, 'box_count') and hasattr(result, 'box_list'):
-                                # Summarize detections
-                                count = int(getattr(result, 'box_count', 0))
-                                output_lines.append(f"      Detections: {count}")
-                                # Optional: top classes summary
-                                class_counts = {}
-                                for b in getattr(result, 'box_list', [])[:5]:
-                                    name = getattr(b, 'class_name', 'object')
-                                    class_counts[name] = class_counts.get(name, 0) + 1
-                                if class_counts:
-                                    summary = ", ".join(f"{k} x{v}" for k, v in class_counts.items())
-                                    output_lines.append(f"      Classes: {summary}")
-                            else:
-                                output_lines.append(f"      Raw Result: {result}")
-                        except Exception:
-                            output_lines.append(f"      Raw Result: {result}")
+                        # Handle other result types
+                        output_lines.append(f"      Raw Result: {result}")
                     
                     output_lines.append("")  # Blank line between stages
             else:
@@ -395,14 +499,75 @@ class DeploymentDialog(QDialog):
         self.pipeline_data = pipeline_data
         self.deployment_worker = None
         self.pipeline_config = None
-        self._latest_boxes = []  # cached detection boxes for live overlay
-        self._latest_letterbox = None  # cached letterbox mapping for overlay
+        self.is_multi_series = self._check_multi_series_nodes()
         
-        self.setWindowTitle("Deploy Pipeline to Dongles")
+        # Extract multi-series configuration if needed
+        if self.is_multi_series:
+            self.multi_series_config = self._extract_multi_series_config()
+        else:
+            self.multi_series_config = None
+        
+        title = "Deploy Multi-Series Pipeline" if self.is_multi_series else "Deploy Pipeline to Dongles"
+        self.setWindowTitle(title)
         self.setMinimumSize(800, 600)
         self.setup_ui()
         self.apply_theme()
     
+    def _check_multi_series_nodes(self) -> bool:
+        """Check if pipeline has multi-series enabled nodes"""
+        nodes = self.pipeline_data.get('nodes', [])
+        for node in nodes:
+            # Check for any Model node type (including ExactModelNode)
+            if 'Model' in node.get('type', ''):
+                # Check properties in order of preference
+                node_properties = node.get('properties', {})  # New format
+                if not node_properties:
+                    node_properties = node.get('custom_properties', {})  # Fallback 1
+                if not node_properties:
+                    node_properties = node.get('custom', {})  # Fallback 2
+                
+                if node_properties.get('multi_series_mode', False):
+                    print(f"Multi-series node detected: {node.get('name', 'Unknown')}")
+                    return True
+        return False
+        
+    def _extract_multi_series_config(self):
+        """Extract multi-series configuration from node properties"""
+        multi_series_config = {
+            'language': 'en',
+            'enabled_series': [],
+            'config_mode': 'folder',
+            'assets_folder': '',
+            'port_mapping': {},
+            'individual_paths': {}
+        }
+        
+        nodes = self.pipeline_data.get('nodes', [])
+        for node in nodes:
+            if 'Model' in node.get('type', ''):
+                # Check properties in order of preference
+                node_properties = node.get('properties', {})
+                if not node_properties:
+                    node_properties = node.get('custom_properties', {})
+                if not node_properties:
+                    node_properties = node.get('custom', {})
+                
+                if node_properties.get('multi_series_mode', False):
+                    # Extract multi-series configuration
+                    multi_series_config['enabled_series'] = node_properties.get('enabled_series', [])
+                    multi_series_config['assets_folder'] = node_properties.get('assets_folder', '')
+                    multi_series_config['port_mapping'] = node_properties.get('port_mapping', {})
+                    
+                    # Determine config mode based on assets_folder
+                    if multi_series_config['assets_folder']:
+                        multi_series_config['config_mode'] = 'folder'
+                    else:
+                        multi_series_config['config_mode'] = 'individual'
+                    
+                    break
+        
+        return multi_series_config
+        
     def setup_ui(self):
         """Setup the dialog UI."""
         layout = QVBoxLayout(self)
@@ -451,11 +616,18 @@ class DeploymentDialog(QDialog):
         # Buttons
         button_layout = QHBoxLayout()
         
+        # Multi-series configuration button (only for multi-series pipelines)
+        if self.is_multi_series:
+            self.configure_multi_series_btn = QPushButton("Configure Multi-Series")
+            self.configure_multi_series_btn.clicked.connect(self.configure_multi_series)
+            button_layout.addWidget(self.configure_multi_series_btn)
+        
         self.analyze_button = QPushButton("Analyze Pipeline")
         self.analyze_button.clicked.connect(self.analyze_pipeline)
         button_layout.addWidget(self.analyze_button)
         
-        self.deploy_button = QPushButton("Deploy to Dongles")
+        deploy_text = "Deploy Multi-Series Pipeline" if self.is_multi_series else "Deploy to Dongles"
+        self.deploy_button = QPushButton(deploy_text)
         self.deploy_button.clicked.connect(self.start_deployment)
         self.deploy_button.setEnabled(False)
         button_layout.addWidget(self.deploy_button)
@@ -477,6 +649,31 @@ class DeploymentDialog(QDialog):
         # Populate initial data
         self.populate_overview()
     
+    def configure_multi_series(self):
+        """Open multi-series configuration dialog"""
+        if not MULTI_SERIES_UI_AVAILABLE:
+            QMessageBox.warning(
+                self, 
+                "Configuration Error",
+                "Multi-series configuration UI not available. Please check installation."
+            )
+            return
+        
+        # Create and show multi-series configuration dialog
+        config_dialog = MultiSeriesConfigDialog(self, self.multi_series_config)
+        
+        if config_dialog.exec_() == config_dialog.Accepted:
+            self.multi_series_config = config_dialog.get_configuration()
+            
+            # Update status
+            enabled_series = self.multi_series_config.get('enabled_series', [])
+            if enabled_series:
+                self.dongle_status.setText(f"Multi-series configured: {', '.join(enabled_series)}")
+                self.deploy_button.setEnabled(True)
+            else:
+                self.dongle_status.setText("No series configured")
+                self.deploy_button.setEnabled(False)
+        
     def create_overview_tab(self) -> QWidget:
         """Create pipeline overview tab."""
         widget = QWidget()
@@ -590,13 +787,33 @@ class DeploymentDialog(QDialog):
         
         layout.addWidget(splitter)
         
-        # Dongle status (placeholder)
-        status_group = QGroupBox("Dongle Status")
-        status_layout = QVBoxLayout(status_group)
+        # Dongle status
+        if self.is_multi_series:
+            status_group = QGroupBox("Multi-Series Dongle Status")
+            status_layout = QVBoxLayout(status_group)
             
-        self.dongle_status = QLabel("No dongles detected")
-        self.dongle_status.setAlignment(Qt.AlignCenter)
-        status_layout.addWidget(self.dongle_status)
+            # Multi-series status table
+            self.multi_series_status_table = QTableWidget()
+            self.multi_series_status_table.setColumnCount(4)
+            self.multi_series_status_table.setHorizontalHeaderLabels([
+                "Series", "Port IDs", "Current Load", "Total Processed"
+            ])
+            self.multi_series_status_table.horizontalHeader().setStretchLastSection(True)
+            self.multi_series_status_table.setMaximumHeight(150)
+            status_layout.addWidget(self.multi_series_status_table)
+            
+            # Overall status
+            self.dongle_status = QLabel("Configure multi-series settings to begin")
+            self.dongle_status.setAlignment(Qt.AlignCenter)
+            status_layout.addWidget(self.dongle_status)
+            
+        else:
+            status_group = QGroupBox("Dongle Status")
+            status_layout = QVBoxLayout(status_group)
+            
+            self.dongle_status = QLabel("No dongles detected")
+            self.dongle_status.setAlignment(Qt.AlignCenter)
+            status_layout.addWidget(self.dongle_status)
         
         layout.addWidget(status_group)
         
@@ -614,20 +831,6 @@ class DeploymentDialog(QDialog):
         self.live_view_label.setAlignment(Qt.AlignCenter)
         self.live_view_label.setMinimumSize(640, 480)
         video_layout.addWidget(self.live_view_label)
-
-        # Display threshold control
-        from PyQt5.QtWidgets import QDoubleSpinBox
-        thresh_row = QHBoxLayout()
-        thresh_label = QLabel("Min Conf:")
-        self.display_threshold_spin = QDoubleSpinBox()
-        self.display_threshold_spin.setRange(0.0, 1.0)
-        self.display_threshold_spin.setSingleStep(0.05)
-        self.display_threshold_spin.setValue(getattr(self, '_display_threshold', 0.5))
-        self.display_threshold_spin.valueChanged.connect(self.on_display_threshold_changed)
-        thresh_row.addWidget(thresh_label)
-        thresh_row.addWidget(self.display_threshold_spin)
-        thresh_row.addStretch()
-        video_layout.addLayout(thresh_row)
         layout.addWidget(video_group, 2)
 
         # Inference results
@@ -640,13 +843,6 @@ class DeploymentDialog(QDialog):
 
         return widget
     
-    def on_display_threshold_changed(self, val: float):
-        """Update in-UI display confidence threshold for overlays and summaries."""
-        try:
-            self._display_threshold = float(val)
-        except Exception:
-            pass
-    
     def populate_overview(self):
         """Populate overview tab with pipeline data."""
         self.name_label.setText(self.pipeline_data.get('project_name', 'Untitled'))
@@ -699,32 +895,10 @@ Stage Configurations:
             
             for i, stage_config in enumerate(config.stage_configs, 1):
                 analysis_text += f"\nStage {i}: {stage_config.stage_id}\n"
-                
-                # Check if this is multi-series configuration
-                if stage_config.multi_series_config:
-                    analysis_text += f"  Mode: Multi-Series\n"
-                    analysis_text += f"  Series Configured: {list(stage_config.multi_series_config.keys())}\n"
-                    
-                    # Show details for each series
-                    for series_name, series_config in stage_config.multi_series_config.items():
-                        analysis_text += f"  \n  {series_name} Configuration:\n"
-                        analysis_text += f"    Port IDs: {series_config.get('port_ids', [])}\n"
-                        model_path = series_config.get('model_path', 'Not specified')
-                        analysis_text += f"    Model: {model_path}\n"
-                        firmware_paths = series_config.get('firmware_paths', {})
-                        if firmware_paths:
-                            analysis_text += f"    SCPU Firmware: {firmware_paths.get('scpu', 'Not specified')}\n"
-                            analysis_text += f"    NCPU Firmware: {firmware_paths.get('ncpu', 'Not specified')}\n"
-                        else:
-                            analysis_text += f"    Firmware: Not specified\n"
-                else:
-                    # Single-series (legacy) configuration
-                    analysis_text += f"  Mode: Single-Series\n"
-                    analysis_text += f"  Port IDs: {stage_config.port_ids}\n"
-                    analysis_text += f"  Model Path: {stage_config.model_path}\n"
-                    analysis_text += f"  SCPU Firmware: {stage_config.scpu_fw_path}\n"
-                    analysis_text += f"  NCPU Firmware: {stage_config.ncpu_fw_path}\n"
-                
+                analysis_text += f"  Port IDs: {stage_config.port_ids}\n"
+                analysis_text += f"  Model Path: {stage_config.model_path}\n"
+                analysis_text += f"  SCPU Firmware: {stage_config.scpu_fw_path}\n"
+                analysis_text += f"  NCPU Firmware: {stage_config.ncpu_fw_path}\n"
                 analysis_text += f"  Upload Firmware: {stage_config.upload_fw}\n"
                 analysis_text += f"  Max Queue Size: {stage_config.max_queue_size}\n"
             
@@ -762,66 +936,23 @@ Stage Configurations:
             stage_group = QGroupBox(f"Stage {i}: {stage_config.stage_id}")
             stage_layout = QFormLayout(stage_group)
             
-            # Check if this is multi-series configuration
-            if stage_config.multi_series_config:
-                # Multi-series configuration display
-                mode_edit = QLineEdit("Multi-Series")
-                mode_edit.setReadOnly(True)
-                stage_layout.addRow("Mode:", mode_edit)
+            # Create read-only fields for stage configuration
+            model_path_edit = QLineEdit(stage_config.model_path)
+            model_path_edit.setReadOnly(True)
+            stage_layout.addRow("Model Path:", model_path_edit)
             
-                series_edit = QLineEdit(str(list(stage_config.multi_series_config.keys())))
-                series_edit.setReadOnly(True)
-                stage_layout.addRow("Series:", series_edit)
+            scpu_fw_edit = QLineEdit(stage_config.scpu_fw_path)
+            scpu_fw_edit.setReadOnly(True)
+            stage_layout.addRow("SCPU Firmware:", scpu_fw_edit)
             
-                # Show details for each series
-                for series_name, series_config in stage_config.multi_series_config.items():
-                    series_label = QLabel(f"--- {series_name} ---")
-                    series_label.setStyleSheet("font-weight: bold; color: #89b4fa;")
-                    stage_layout.addRow(series_label)
+            ncpu_fw_edit = QLineEdit(stage_config.ncpu_fw_path)
+            ncpu_fw_edit.setReadOnly(True)
+            stage_layout.addRow("NCPU Firmware:", ncpu_fw_edit)
             
-                    port_ids_edit = QLineEdit(str(series_config.get('port_ids', [])))
-                    port_ids_edit.setReadOnly(True)
-                    stage_layout.addRow(f"{series_name} Port IDs:", port_ids_edit)
+            port_ids_edit = QLineEdit(str(stage_config.port_ids))
+            port_ids_edit.setReadOnly(True)
+            stage_layout.addRow("Port IDs:", port_ids_edit)
             
-                    model_path = series_config.get('model_path', 'Not specified')
-                    model_path_edit = QLineEdit(model_path)
-                    model_path_edit.setReadOnly(True)
-                    stage_layout.addRow(f"{series_name} Model:", model_path_edit)
-                    
-                    firmware_paths = series_config.get('firmware_paths', {})
-                    if firmware_paths:
-                        scpu_path = firmware_paths.get('scpu', 'Not specified')
-                        scpu_fw_edit = QLineEdit(scpu_path)
-                        scpu_fw_edit.setReadOnly(True)
-                        stage_layout.addRow(f"{series_name} SCPU FW:", scpu_fw_edit)
-                        
-                        ncpu_path = firmware_paths.get('ncpu', 'Not specified')
-                        ncpu_fw_edit = QLineEdit(ncpu_path)
-                        ncpu_fw_edit.setReadOnly(True)
-                        stage_layout.addRow(f"{series_name} NCPU FW:", ncpu_fw_edit)
-            else:
-                # Single-series configuration display
-                mode_edit = QLineEdit("Single-Series")
-                mode_edit.setReadOnly(True)
-                stage_layout.addRow("Mode:", mode_edit)
-                
-                model_path_edit = QLineEdit(stage_config.model_path)
-                model_path_edit.setReadOnly(True)
-                stage_layout.addRow("Model Path:", model_path_edit)
-                
-                scpu_fw_edit = QLineEdit(stage_config.scpu_fw_path)
-                scpu_fw_edit.setReadOnly(True)
-                stage_layout.addRow("SCPU Firmware:", scpu_fw_edit)
-                
-                ncpu_fw_edit = QLineEdit(stage_config.ncpu_fw_path)
-                ncpu_fw_edit.setReadOnly(True)
-                stage_layout.addRow("NCPU Firmware:", ncpu_fw_edit)
-                
-                port_ids_edit = QLineEdit(str(stage_config.port_ids))
-                port_ids_edit.setReadOnly(True)
-                stage_layout.addRow("Port IDs:", port_ids_edit)
-            
-            # Common fields
             queue_size_spin = QSpinBox()
             queue_size_spin.setValue(stage_config.max_queue_size)
             queue_size_spin.setReadOnly(True)
@@ -847,11 +978,17 @@ Stage Configurations:
     
     def start_deployment(self):
         """Start the deployment process."""
-        if not self.pipeline_config:
+        if not self.pipeline_config and not self.is_multi_series:
             QMessageBox.warning(self, "Deployment Error", 
                               "Please analyze the pipeline first.")
             return
         
+        # For multi-series pipelines, check if configuration is done
+        if self.is_multi_series and not self.multi_series_config:
+            QMessageBox.warning(self, "Configuration Required", 
+                              "Please configure multi-series settings first.")
+            return
+        
         # Switch to deployment tab
         self.tab_widget.setCurrentIndex(3)
         
@@ -868,7 +1005,7 @@ Stage Configurations:
         self.terminal_output_display.append("Pipeline deployment started - terminal output will appear here...")
         
         # Create and start deployment worker
-        self.deployment_worker = DeploymentWorker(self.pipeline_data)
+        self.deployment_worker = DeploymentWorker(self.pipeline_data, self.multi_series_config)
         self.deployment_worker.progress_updated.connect(self.update_progress)
         self.deployment_worker.topology_analyzed.connect(self.update_topology_results)
         self.deployment_worker.conversion_completed.connect(self.on_conversion_completed)
@@ -879,6 +1016,7 @@ Stage Configurations:
         self.deployment_worker.result_updated.connect(self.update_inference_results)
         self.deployment_worker.terminal_output.connect(self.update_terminal_output)
         self.deployment_worker.stdout_captured.connect(self.update_terminal_output)
+        self.deployment_worker.multi_series_status.connect(self.update_multi_series_status)
         
         
         self.deployment_worker.start()
@@ -979,57 +1117,6 @@ Stage Configurations:
     def update_live_view(self, frame):
         """Update the live view with a new frame."""
         try:
-            # Optionally overlay latest detections before display
-            if hasattr(self, '_latest_boxes') and self._latest_boxes:
-                import cv2
-                H, W = frame.shape[0], frame.shape[1]
-                # Letterbox mapping
-                letter = getattr(self, '_latest_letterbox', None)
-                for box in self._latest_boxes:
-                    # Filter by display threshold
-                    sc = box.get('score', None)
-                    try:
-                        if sc is not None and float(sc) < getattr(self, '_display_threshold', 0.5):
-                            continue
-                    except Exception:
-                        pass
-                    x1 = float(box.get('x1', 0)); y1 = float(box.get('y1', 0))
-                    x2 = float(box.get('x2', 0)); y2 = float(box.get('y2', 0))
-
-                    mapped = False
-                    if letter and all(k in letter for k in ('model_w','model_h','resized_w','resized_h','pad_left','pad_top')):
-                        mw = int(letter.get('model_w', 0))
-                        mh = int(letter.get('model_h', 0))
-                        rw = int(letter.get('resized_w', 0))
-                        rh = int(letter.get('resized_h', 0))
-                        pl = int(letter.get('pad_left', 0)); pt = int(letter.get('pad_top', 0))
-                        if rw > 0 and rh > 0:
-                            # Reverse letterbox: remove padding, then scale to original
-                            x1 = (x1 - pl) / rw * W; x2 = (x2 - pl) / rw * W
-                            y1 = (y1 - pt) / rh * H; y2 = (y2 - pt) / rh * H
-                            mapped = True
-                        elif mw > 0 and mh > 0:
-                            # Fallback: simple proportional mapping from model space
-                            x1 = x1 / mw * W; x2 = x2 / mw * W
-                            y1 = y1 / mh * H; y2 = y2 / mh * H
-                            mapped = True
-                    if not mapped:
-                        # Last resort proportional mapping using typical 640 baseline
-                        baseline = 640.0
-                        x1 = x1 / baseline * W; x2 = x2 / baseline * W
-                        y1 = y1 / baseline * H; y2 = y2 / baseline * H
-
-                    # Clamp
-                    xi1 = max(0, min(int(x1), W - 1)); yi1 = max(0, min(int(y1), H - 1))
-                    xi2 = max(xi1 + 1, min(int(x2), W)); yi2 = max(yi1 + 1, min(int(y2), H))
-                    color = (0, 255, 0)
-                    cv2.rectangle(frame, (xi1, yi1), (xi2, yi2), color, 2)
-                    label = box.get('class_name', 'obj')
-                    score = box.get('score', None)
-                    if score is not None:
-                        label = f"{label} {score:.2f}"
-                    cv2.putText(frame, label, (xi1, max(0, yi1 - 5)), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
-
             # Convert the OpenCV frame to a QImage
             height, width, channel = frame.shape
             bytes_per_line = 3 * width
@@ -1055,92 +1142,20 @@ Stage Configurations:
             # Display results from each stage
             for stage_id, result in stage_results.items():
                 result_text += f"  {stage_id}:\n"
-                # Cache latest detection boxes for live overlay if available
-                source_obj = None
-                if hasattr(result, 'box_count') and hasattr(result, 'box_list'):
-                    source_obj = result
-                elif isinstance(result, tuple) and len(result) == 2 and hasattr(result[0], 'box_list'):
-                    source_obj = result[0]
-
-                if source_obj is not None:
-                    boxes = []
-                    for b in getattr(source_obj, 'box_list', [])[:50]:
-                        boxes.append({
-                            'x1': getattr(b, 'x1', 0), 'y1': getattr(b, 'y1', 0),
-                            'x2': getattr(b, 'x2', 0), 'y2': getattr(b, 'y2', 0),
-                            'class_name': getattr(b, 'class_name', 'obj'),
-                            'score': float(getattr(b, 'score', 0.0)) if hasattr(b, 'score') else None,
-                        })
-                    self._latest_boxes = boxes
-                    # Cache letterbox mapping from result object if available
-                    try:
-                        self._latest_letterbox = {
-                            'model_w': int(getattr(source_obj, 'model_input_width', 0)),
-                            'model_h': int(getattr(source_obj, 'model_input_height', 0)),
-                            'resized_w': int(getattr(source_obj, 'resized_img_width', 0)),
-                            'resized_h': int(getattr(source_obj, 'resized_img_height', 0)),
-                            'pad_left': int(getattr(source_obj, 'pad_left', 0)),
-                            'pad_top': int(getattr(source_obj, 'pad_top', 0)),
-                            'pad_right': int(getattr(source_obj, 'pad_right', 0)),
-                            'pad_bottom': int(getattr(source_obj, 'pad_bottom', 0)),
-                        }
-                    except Exception:
-                        self._latest_letterbox = None
-
                 if isinstance(result, tuple) and len(result) == 2:
-                    # Handle tuple results which may be (ClassificationResult|ObjectDetectionResult|float, result_string)
-                    prob_or_obj, result_string = result
+                    # Handle tuple results (probability, result_string)
+                    probability, result_string = result
                     result_text += f"    Result: {result_string}\n"
-
-                    # Object detection summary
-                    if hasattr(prob_or_obj, 'box_list'):
-                        filtered = [b for b in getattr(prob_or_obj, 'box_list', [])
-                                    if not hasattr(b, 'score') or float(getattr(b, 'score', 0.0)) >= getattr(self, '_display_threshold', 0.5)]
-                        thresh = getattr(self, '_display_threshold', 0.5)
-                        result_text += f"    Detections (>= {thresh:.2f}): {len(filtered)}\n"
-                    # Classification summary (e.g., Fire detection)
-                    elif hasattr(prob_or_obj, 'probability') and hasattr(prob_or_obj, 'class_name'):
-                        try:
-                            p = float(getattr(prob_or_obj, 'probability', 0.0))
-                            result_text += f"    Probability: {p:.3f}\n"
-                        except Exception:
-                            result_text += f"    Probability: {getattr(prob_or_obj, 'probability', 'N/A')}\n"
-                    else:
-                        # Numeric probability fallback
-                        try:
-                            prob_value = float(prob_or_obj)
-                            result_text += f"    Probability: {prob_value:.3f}\n"
-                        except (ValueError, TypeError):
-                            result_text += f"    Probability: {prob_or_obj}\n"
+                    result_text += f"    Probability: {probability:.3f}\n"
                 elif isinstance(result, dict):
                     # Handle dict results
                     for key, value in result.items():
                         if key == 'probability':
-                            try:
-                                prob_value = float(value)
-                                result_text += f"    Probability: {prob_value:.3f}\n"
-                            except (ValueError, TypeError):
-                                result_text += f"    Probability: {value}\n"
+                            result_text += f"    Probability: {value:.3f}\n"
                         else:
                             result_text += f"    {key}: {value}\n"
                 else:
-                    # Pretty-print detection objects
-                    try:
-                        if hasattr(result, 'box_count') and hasattr(result, 'box_list'):
-                            filtered = [b for b in getattr(result, 'box_list', [])
-                                        if not hasattr(b, 'score') or float(getattr(b, 'score', 0.0)) >= getattr(self, '_display_threshold', 0.5)]
-                            thresh = getattr(self, '_display_threshold', 0.5)
-                            result_text += f"    Detections (>= {thresh:.2f}): {len(filtered)}\n"
-                        elif hasattr(result, 'probability') and hasattr(result, 'class_name'):
-                            try:
-                                p = float(getattr(result, 'probability', 0.0))
-                                result_text += f"    Probability: {p:.3f}\n"
-                            except Exception:
-                                result_text += f"    Probability: {getattr(result, 'probability', 'N/A')}\n"
-                        else:
-                            result_text += f"    {result}\n"
-                    except Exception:
-                        result_text += f"    {result}\n"
+                    result_text += f"    {result}\n"
             
             result_text += "-" * 50 + "\n"
             
@@ -1182,6 +1197,71 @@ Stage Configurations:
         except Exception as e:
             print(f"Error updating terminal output: {e}")
     
+    def update_multi_series_status(self, status_info: dict):
+        """Update multi-series dongle status display"""
+        try:
+            if not self.is_multi_series:
+                return
+            
+            status_type = status_info.get('type', '')
+            
+            if status_type == 'multi_series':
+                # Update overall status
+                enabled_series = status_info.get('enabled_series', [])
+                total_gops = status_info.get('total_gops', 0)
+                
+                if enabled_series:
+                    status_text = f"Running: {', '.join(enabled_series)} ({total_gops} total GOPS)"
+                    self.dongle_status.setText(status_text)
+                
+                # Update status table
+                stats = status_info.get('stats', {})
+                current_loads = status_info.get('current_loads', {})
+                port_mapping = status_info.get('port_mapping', {})
+                
+                if hasattr(self, 'multi_series_status_table'):
+                    # Group port IDs by series
+                    series_ports = {}
+                    for port_id, series in port_mapping.items():
+                        if series not in series_ports:
+                            series_ports[series] = []
+                        series_ports[series].append(str(port_id))
+                    
+                    # Update table
+                    self.multi_series_status_table.setRowCount(len(enabled_series))
+                    
+                    for i, series in enumerate(enabled_series):
+                        # Series name
+                        self.multi_series_status_table.setItem(i, 0, QTableWidgetItem(series))
+                        
+                        # Port IDs
+                        ports = series_ports.get(series, [])
+                        ports_text = ", ".join(ports) if ports else "Not mapped"
+                        self.multi_series_status_table.setItem(i, 1, QTableWidgetItem(ports_text))
+                        
+                        # Current load
+                        # Find product_id for this series
+                        product_id = None
+                        series_specs = {'KL520': 0x100, 'KL720': 0x720, 'KL630': 0x630, 'KL730': 0x730, 'KL540': 0x540}
+                        product_id = series_specs.get(series)
+                        
+                        if product_id and product_id in current_loads:
+                            load = current_loads[product_id]
+                            self.multi_series_status_table.setItem(i, 2, QTableWidgetItem(str(load)))
+                        else:
+                            self.multi_series_status_table.setItem(i, 2, QTableWidgetItem("0"))
+                        
+                        # Total processed
+                        dongle_stats = stats.get('dongle_stats', {})
+                        if product_id and product_id in dongle_stats:
+                            processed = dongle_stats[product_id].get('received', 0)
+                            self.multi_series_status_table.setItem(i, 3, QTableWidgetItem(str(processed)))
+                        else:
+                            self.multi_series_status_table.setItem(i, 3, QTableWidgetItem("0"))
+                
+        except Exception as e:
+            print(f"Error updating multi-series status: {e}")
+    
     def apply_theme(self):
         """Apply consistent theme to the dialog."""
         self.setStyleSheet("""

ui/windows/dashboard.py

@@ -43,7 +43,6 @@ except ImportError:
 
 from config.theme import HARMONIOUS_THEME_STYLESHEET
 from config.settings import get_settings
-from utils.folder_dialog import select_assets_folder
 try:
     from core.nodes import (
         InputNode, ModelNode, PreprocessNode, PostprocessNode, OutputNode,
@@ -1141,10 +1140,16 @@ class IntegratedPipelineDashboard(QMainWindow):
         # Get node properties - try different methods
         try:
             properties = {}
+            # Initialize variables that might be used later in form layout
+            node_type = node.__class__.__name__
+            multi_series_enabled = False
             
             # Method 1: Try custom properties (for enhanced nodes)
             if hasattr(node, 'get_business_properties'):
                 properties = node.get_business_properties()
+                # For Model nodes, check if multi-series is enabled
+                if 'Model' in node_type and hasattr(node, 'get_property'):
+                    multi_series_enabled = node.get_property('multi_series_mode') if hasattr(node, 'get_property') else False
             
             # Method 1.5: Try ExactNode properties (with _property_options)
             elif hasattr(node, '_property_options') and node._property_options:
@@ -1156,6 +1161,9 @@ class IntegratedPipelineDashboard(QMainWindow):
                         except:
                             # If property doesn't exist, use a default value
                             properties[prop_name] = None
+                # For Model nodes, check if multi-series is enabled
+                if 'Model' in node_type and hasattr(node, 'get_property'):
+                    multi_series_enabled = node.get_property('multi_series_mode') if hasattr(node, 'get_property') else False
             
             # Method 2: Try standard NodeGraphQt properties
             elif hasattr(node, 'properties'):
@@ -1164,10 +1172,15 @@ class IntegratedPipelineDashboard(QMainWindow):
                 for key, value in all_props.items():
                     if not key.startswith('_') and key not in ['name', 'selected', 'disabled', 'custom']:
                         properties[key] = value
+                # For Model nodes, check if multi-series is enabled
+                if 'Model' in node_type:
+                    multi_series_enabled = properties.get('multi_series_mode', False)
             
             # Method 3: Use exact original properties based on node type
             else:
-                node_type = node.__class__.__name__
+                # Variables already initialized above
+                properties = {}  # Initialize properties dict
+                
                 if 'Input' in node_type:
                     # Exact InputNode properties from original
                     properties = {
@@ -1178,16 +1191,31 @@ class IntegratedPipelineDashboard(QMainWindow):
                         'fps': node.get_property('fps') if hasattr(node, 'get_property') else 30
                     }
                 elif 'Model' in node_type:
-                    # Exact ModelNode properties from original - including upload_fw checkbox
+                    # Check if multi-series mode is enabled
+                    multi_series_enabled = node.get_property('multi_series_mode') if hasattr(node, 'get_property') else False
+                    
+                    # Basic properties always shown
                     properties = {
-                        'model_path': node.get_property('model_path') if hasattr(node, 'get_property') else '',
-                        'scpu_fw_path': node.get_property('scpu_fw_path') if hasattr(node, 'get_property') else '',
-                        'ncpu_fw_path': node.get_property('ncpu_fw_path') if hasattr(node, 'get_property') else '',
-                        'dongle_series': node.get_property('dongle_series') if hasattr(node, 'get_property') else '520',
-                        'num_dongles': node.get_property('num_dongles') if hasattr(node, 'get_property') else 1,
-                        'port_id': node.get_property('port_id') if hasattr(node, 'get_property') else '',
-                        'upload_fw': node.get_property('upload_fw') if hasattr(node, 'get_property') else True
+                        'multi_series_mode': multi_series_enabled
                     }
+                    
+                    if multi_series_enabled:
+                        # Multi-series mode properties
+                        properties.update({
+                            'assets_folder': node.get_property('assets_folder') if hasattr(node, 'get_property') else '',
+                            'enabled_series': node.get_property('enabled_series') if hasattr(node, 'get_property') else ['520', '720']
+                        })
+                    else:
+                        # Single-series mode properties (original)
+                        properties.update({
+                            'model_path': node.get_property('model_path') if hasattr(node, 'get_property') else '',
+                            'scpu_fw_path': node.get_property('scpu_fw_path') if hasattr(node, 'get_property') else '',
+                            'ncpu_fw_path': node.get_property('ncpu_fw_path') if hasattr(node, 'get_property') else '',
+                            'dongle_series': node.get_property('dongle_series') if hasattr(node, 'get_property') else '520',
+                            'num_dongles': node.get_property('num_dongles') if hasattr(node, 'get_property') else 1,
+                            'port_id': node.get_property('port_id') if hasattr(node, 'get_property') else '',
+                            'upload_fw': node.get_property('upload_fw') if hasattr(node, 'get_property') else True
+                        })
                 elif 'Preprocess' in node_type:
                     # Exact PreprocessNode properties from original
                     properties = {
@@ -1200,16 +1228,10 @@ class IntegratedPipelineDashboard(QMainWindow):
                 elif 'Postprocess' in node_type:
                     # Exact PostprocessNode properties from original
                     properties = {
-                        'postprocess_type': node.get_property('postprocess_type') if hasattr(node, 'get_property') else 'fire_detection',
-                        'class_names': node.get_property('class_names') if hasattr(node, 'get_property') else 'No Fire,Fire',
                         'output_format': node.get_property('output_format') if hasattr(node, 'get_property') else 'JSON',
                         'confidence_threshold': node.get_property('confidence_threshold') if hasattr(node, 'get_property') else 0.5,
                         'nms_threshold': node.get_property('nms_threshold') if hasattr(node, 'get_property') else 0.4,
-                        'max_detections': node.get_property('max_detections') if hasattr(node, 'get_property') else 100,
-                        'enable_confidence_filter': node.get_property('enable_confidence_filter') if hasattr(node, 'get_property') else True,
-                        'enable_nms': node.get_property('enable_nms') if hasattr(node, 'get_property') else True,
-                        'coordinate_system': node.get_property('coordinate_system') if hasattr(node, 'get_property') else 'relative',
-                        'operations': node.get_property('operations') if hasattr(node, 'get_property') else 'filter,nms,format'
+                        'max_detections': node.get_property('max_detections') if hasattr(node, 'get_property') else 100
                     }
                 elif 'Output' in node_type:
                     # Exact OutputNode properties from original
@@ -1226,9 +1248,30 @@ class IntegratedPipelineDashboard(QMainWindow):
                     widget = self.create_property_widget_enhanced(node, prop_name, prop_value)
                     
                     # Add to form with appropriate labels
-                    if prop_name == 'upload_fw':
-                        # For upload_fw, don't show a separate label since the checkbox has its own text
+                    if prop_name in ['upload_fw', 'multi_series_mode']:
+                        # For checkboxes with their own text, don't show a separate label
                         form_layout.addRow(widget)
+                    elif prop_name == 'assets_folder':
+                        form_layout.addRow("Assets Folder:", widget)
+                    elif prop_name == 'enabled_series':
+                        form_layout.addRow("Enabled Series:", widget)
+                        
+                        # Add port mapping widget for multi-series mode
+                        if 'Model' in node_type and multi_series_enabled:
+                            port_mapping_widget = self.create_port_mapping_widget(node)
+                            form_layout.addRow(port_mapping_widget)
+                    elif prop_name == 'dongle_series':
+                        form_layout.addRow("Dongle Series:", widget)
+                    elif prop_name == 'num_dongles':
+                        form_layout.addRow("Number of Dongles:", widget)
+                    elif prop_name == 'port_id':
+                        form_layout.addRow("Port ID:", widget)
+                    elif prop_name == 'model_path':
+                        form_layout.addRow("Model Path:", widget)
+                    elif prop_name == 'scpu_fw_path':
+                        form_layout.addRow("SCPU Firmware:", widget)
+                    elif prop_name == 'ncpu_fw_path':
+                        form_layout.addRow("NCPU Firmware:", widget)
                     else:
                         label = prop_name.replace('_', ' ').title()
                         form_layout.addRow(f"{label}:", widget)
@@ -1330,75 +1373,9 @@ class IntegratedPipelineDashboard(QMainWindow):
         if hasattr(node, '_property_options') and prop_name in node._property_options:
             prop_options = node._property_options[prop_name]
         
-        # Special handling for assets_folder property
-        if prop_name == 'assets_folder':
-            # Assets folder property with validation and improved dialog
-            display_text = self.truncate_path_smart(str(prop_value)) if prop_value else 'Select Assets Folder...'
-            widget = QPushButton(display_text)
-            
-            # Set fixed width and styling to prevent expansion
-            widget.setMaximumWidth(250)
-            widget.setMinimumWidth(200)
-            widget.setStyleSheet("""
-                QPushButton {
-                    text-align: left; 
-                    padding: 5px 8px;
-                    background-color: #45475a;
-                    color: #cdd6f4;
-                    border: 1px solid #585b70;
-                    border-radius: 4px;
-                    font-size: 10px;
-                }
-                QPushButton:hover {
-                    background-color: #585b70;
-                    border-color: #a6e3a1;
-                }
-                QPushButton:pressed {
-                    background-color: #313244;
-                }
-            """)
-            
-            # Store full path for tooltip and internal use
-            full_path = str(prop_value) if prop_value else ''
-            widget.setToolTip(f"Full path: {full_path}\n\nClick to browse for Assets folder\n(Should contain Firmware/ and Models/ subfolders)")
-            
-            def browse_assets_folder():
-                # Use the specialized assets folder dialog with validation
-                result = select_assets_folder(initial_dir=full_path or '')
-                
-                if result['path']:
-                    # Update button text with truncated path
-                    truncated_text = self.truncate_path_smart(result['path'])
-                    widget.setText(truncated_text)
-                    
-                    # Create detailed tooltip with validation results
-                    tooltip_lines = [f"Full path: {result['path']}"]
-                    if result['valid']:
-                        tooltip_lines.append("✓ Valid Assets folder structure detected")
-                        if 'details' in result and 'available_series' in result['details']:
-                            series = result['details']['available_series']
-                            tooltip_lines.append(f"Available series: {', '.join(series)}")
-                    else:
-                        tooltip_lines.append(f"⚠ {result['message']}")
-                    
-                    tooltip_lines.append("\nClick to browse for Assets folder")
-                    widget.setToolTip('\n'.join(tooltip_lines))
-                    
-                    # Set property with full path
-                    if hasattr(node, 'set_property'):
-                        node.set_property(prop_name, result['path'])
-                    
-                    # Show validation message to user
-                    if not result['valid']:
-                        QMessageBox.warning(self, "Assets Folder Validation", 
-                                          f"Selected folder may not have the expected structure:\n\n{result['message']}\n\n"
-                                          "Expected structure:\nAssets/\n├── Firmware/\n│   └── KL520/, KL720/, etc.\n└── Models/\n    └── KL520/, KL720/, etc.")
-            
-            widget.clicked.connect(browse_assets_folder)
-        
-        # Check for file path properties (from prop_options or name pattern)
-        elif (prop_options and isinstance(prop_options, dict) and prop_options.get('type') == 'file_path') or \
-           prop_name in ['model_path', 'source_path', 'destination']:
+        # Check for file path properties first (from prop_options or name pattern)
+        if (prop_options and isinstance(prop_options, dict) and prop_options.get('type') == 'file_path') or \
+           prop_name in ['model_path', 'source_path', 'destination', 'assets_folder']:
             # File path property with smart truncation and width limits
             display_text = self.truncate_path_smart(str(prop_value)) if prop_value else 'Select File...'
             widget = QPushButton(display_text)
@@ -1430,33 +1407,107 @@ class IntegratedPipelineDashboard(QMainWindow):
             widget.setToolTip(f"Full path: {full_path}\n\nClick to browse for {prop_name.replace('_', ' ')}")
             
             def browse_file():
-                # Use filter from prop_options if available, otherwise use defaults
-                if prop_options and 'filter' in prop_options:
-                    file_filter = prop_options['filter']
+                # Handle assets_folder as folder dialog
+                if prop_name == 'assets_folder':
+                    folder_path = QFileDialog.getExistingDirectory(
+                        self, 
+                        'Select Multi-Series Assets Folder',
+                        str(prop_value) if prop_value else os.path.expanduser("~")
+                    )
+                    if folder_path:
+                        # Update button text with truncated path
+                        truncated_text = self.truncate_path_smart(folder_path)
+                        widget.setText(truncated_text)
+                        # Update tooltip with full path
+                        widget.setToolTip(f"Assets Folder: {folder_path}\n\nContains Firmware/ and Models/ subdirectories")
+                        # Set property with full path
+                        if hasattr(node, 'set_property'):
+                            node.set_property(prop_name, folder_path)
                 else:
-                    # Fallback to original filters
-                    filters = {
-                        'model_path': 'NEF Model files (*.nef)',
-                        'scpu_fw_path': 'SCPU Firmware files (*.bin)',
-                        'ncpu_fw_path': 'NCPU Firmware files (*.bin)',
-                        'source_path': 'Media files (*.mp4 *.avi *.mov *.mkv *.wav *.mp3)',
-                        'destination': 'Output files (*.json *.xml *.csv *.txt)'
-                    }
-                    file_filter = filters.get(prop_name, 'All files (*)')
+                    # Use filter from prop_options if available, otherwise use defaults
+                    if prop_options and 'filter' in prop_options:
+                        file_filter = prop_options['filter']
+                    else:
+                        # Fallback to original filters
+                        filters = {
+                            'model_path': 'NEF Model files (*.nef)',
+                            'scpu_fw_path': 'SCPU Firmware files (*.bin)',
+                            'ncpu_fw_path': 'NCPU Firmware files (*.bin)',
+                            'source_path': 'Media files (*.mp4 *.avi *.mov *.mkv *.wav *.mp3)',
+                            'destination': 'Output files (*.json *.xml *.csv *.txt)'
+                        }
+                        file_filter = filters.get(prop_name, 'All files (*)')
                     
-                file_path, _ = QFileDialog.getOpenFileName(self, f'Select {prop_name}', '', file_filter)
-                if file_path:
-                    # Update button text with truncated path
-                    truncated_text = self.truncate_path_smart(file_path)
-                    widget.setText(truncated_text)
-                    # Update tooltip with full path
-                    widget.setToolTip(f"Full path: {file_path}\n\nClick to browse for {prop_name.replace('_', ' ')}")
-                    # Set property with full path
-                    if hasattr(node, 'set_property'):
-                        node.set_property(prop_name, file_path)
+                    file_path, _ = QFileDialog.getOpenFileName(self, f'Select {prop_name}', '', file_filter)
+                    if file_path:
+                        # Update button text with truncated path
+                        truncated_text = self.truncate_path_smart(file_path)
+                        widget.setText(truncated_text)
+                        # Update tooltip with full path
+                        widget.setToolTip(f"Full path: {file_path}\n\nClick to browse for {prop_name.replace('_', ' ')}")
+                        # Set property with full path
+                        if hasattr(node, 'set_property'):
+                            node.set_property(prop_name, file_path)
             
             widget.clicked.connect(browse_file)
         
+        # Check for enabled_series (special multi-select property)
+        elif prop_name == 'enabled_series':
+            # Create a custom widget for multi-series selection
+            widget = QWidget()
+            layout = QVBoxLayout(widget)
+            layout.setContentsMargins(0, 0, 0, 0)
+            layout.setSpacing(2)
+            
+            # Available series options
+            available_series = ['KL520', 'KL720', 'KL630', 'KL730', 'KL540']
+            current_selection = prop_value if isinstance(prop_value, list) else [prop_value] if prop_value else []
+            
+            # Convert to series names if they're just numbers
+            if current_selection and all(isinstance(x, str) and x.isdigit() for x in current_selection):
+                current_selection = [f'KL{x}' for x in current_selection]
+            
+            checkboxes = []
+            for series in available_series:
+                checkbox = QCheckBox(f"{series}")
+                checkbox.setChecked(series in current_selection)
+                checkbox.setStyleSheet("""
+                    QCheckBox {
+                        color: #cdd6f4;
+                        font-size: 10px;
+                        padding: 2px;
+                    }
+                    QCheckBox::indicator {
+                        width: 14px;
+                        height: 14px;
+                        border-radius: 2px;
+                        border: 1px solid #45475a;
+                        background-color: #313244;
+                    }
+                    QCheckBox::indicator:checked {
+                        background-color: #a6e3a1;
+                        border-color: #a6e3a1;
+                    }
+                """)
+                layout.addWidget(checkbox)
+                checkboxes.append((series, checkbox))
+            
+            # Update function for checkboxes
+            def update_enabled_series():
+                selected = []
+                for series, checkbox in checkboxes:
+                    if checkbox.isChecked():
+                        # Store just the number for compatibility
+                        series_number = series.replace('KL', '')
+                        selected.append(series_number)
+                
+                if hasattr(node, 'set_property'):
+                    node.set_property(prop_name, selected)
+            
+            # Connect all checkboxes to update function
+            for _, checkbox in checkboxes:
+                checkbox.toggled.connect(update_enabled_series)
+        
         # Check for dropdown properties (list options from prop_options or predefined)
         elif (prop_options and isinstance(prop_options, list)) or \
              prop_name in ['source_type', 'dongle_series', 'output_format', 'format', 'output_type', 'resolution']:
@@ -1528,7 +1579,7 @@ class IntegratedPipelineDashboard(QMainWindow):
             widget = QCheckBox()
             widget.setChecked(prop_value)
             
-            # Add special styling for upload_fw checkbox
+            # Add special styling and text for specific checkboxes
             if prop_name == 'upload_fw':
                 widget.setText("Upload Firmware to Device")
                 widget.setStyleSheet("""
@@ -1552,6 +1603,31 @@ class IntegratedPipelineDashboard(QMainWindow):
                         border-color: #74c7ec;
                     }
                 """)
+            elif prop_name == 'multi_series_mode':
+                widget.setText("Enable Multi-Series Mode")
+                widget.setStyleSheet("""
+                    QCheckBox {
+                        color: #f9e2af;
+                        font-size: 12px;
+                        font-weight: bold;
+                        padding: 4px;
+                    }
+                    QCheckBox::indicator {
+                        width: 18px;
+                        height: 18px;
+                        border-radius: 4px;
+                        border: 2px solid #f9e2af;
+                        background-color: #313244;
+                    }
+                    QCheckBox::indicator:checked {
+                        background-color: #a6e3a1;
+                        border-color: #a6e3a1;
+                    }
+                    QCheckBox::indicator:hover {
+                        border-color: #f38ba8;
+                    }
+                """)
+                widget.setToolTip("Enable multi-series mode to use different dongle models simultaneously")
             else:
                 widget.setStyleSheet("""
                     QCheckBox {
@@ -1579,6 +1655,12 @@ class IntegratedPipelineDashboard(QMainWindow):
                     if prop_name == 'upload_fw':
                         status = "enabled" if state == 2 else "disabled"
                         print(f"Upload Firmware {status} for {node.name()}")
+                    # For multi_series_mode, refresh the properties panel
+                    elif prop_name == 'multi_series_mode':
+                        status = "enabled" if state == 2 else "disabled"
+                        print(f"Multi-series mode {status} for {node.name()}")
+                        # Trigger properties panel refresh to show/hide multi-series properties
+                        self.update_node_properties_panel(node)
             
             widget.stateChanged.connect(on_change)
         
@@ -1784,42 +1866,152 @@ class IntegratedPipelineDashboard(QMainWindow):
     
     
     def detect_dongles(self):
-        """Detect available dongles using actual device scanning."""
+        """Enhanced dongle detection supporting both single and multi-series configurations."""
         if not self.dongles_list:
             return
         
         self.dongles_list.clear()
         
         try:
-            # Import MultiDongle for device scanning
+            # Import both scanning methods
             from core.functions.Multidongle import MultiDongle
+            import sys
+            import os
             
-            # Scan for available devices
+            # Add path for multi-series manager
+            current_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+            sys.path.insert(0, current_dir)
+            
+            try:
+                from multi_series_dongle_manager import MultiSeriesDongleManager, DongleSeriesSpec
+                multi_series_available = True
+            except ImportError:
+                multi_series_available = False
+            
+            # Scan using MultiDongle (existing method)
             devices = MultiDongle.scan_devices()
             
             if devices:
-                # Add detected devices to the list
+                # Group devices by series for better organization
+                series_groups = {}
                 for device in devices:
-                    port_id = device['port_id']
                     series = device['series']
-                    self.dongles_list.addItem(f"{series} Dongle - Port {port_id}")
+                    if series not in series_groups:
+                        series_groups[series] = []
+                    series_groups[series].append(device)
                 
-                # Add summary item
-                self.dongles_list.addItem(f"Total: {len(devices)} device(s) detected")
+                # Add header for device listing
+                self.dongles_list.addItem("=== Detected Kneron Dongles ===")
                 
-                # Store device info for later use
+                # Display devices grouped by series
+                for series, device_list in series_groups.items():
+                    # Add series header with capabilities
+                    if multi_series_available:
+                        # Find GOPS capacity for this series
+                        gops_capacity = "Unknown"
+                        for product_id, spec in DongleSeriesSpec.SERIES_SPECS.items():
+                            if spec["name"] == series:
+                                gops_capacity = f"{spec['gops']} GOPS"
+                                break
+                        
+                        series_header = f"{series} Series ({gops_capacity}):"
+                    else:
+                        series_header = f"{series} Series:"
+                    
+                    self.dongles_list.addItem(series_header)
+                    
+                    # Add individual devices
+                    for device in device_list:
+                        port_id = device['port_id']
+                        device_item = f"   Port {port_id}"
+                        if 'device_descriptor' in device:
+                            desc = device['device_descriptor']
+                            if hasattr(desc, 'product_id'):
+                                product_id = hex(desc.product_id)
+                                device_item += f" (ID: {product_id})"
+                        
+                        self.dongles_list.addItem(device_item)
+                
+                # Add multi-series information
+                if multi_series_available and len(series_groups) > 1:
+                    self.dongles_list.addItem("")
+                    self.dongles_list.addItem("Multi-Series Mode Available!")
+                    self.dongles_list.addItem("   Different series can work together for")
+                    self.dongles_list.addItem("   improved performance and load balancing.")
+                    
+                    # Calculate total potential GOPS
+                    total_gops = 0
+                    for series, device_list in series_groups.items():
+                        for product_id, spec in DongleSeriesSpec.SERIES_SPECS.items():
+                            if spec["name"] == series:
+                                total_gops += spec["gops"] * len(device_list)
+                                break
+                    
+                    if total_gops > 0:
+                        self.dongles_list.addItem(f"   Total Combined GOPS: {total_gops}")
+                
+                # Add configuration options
+                self.dongles_list.addItem("")
+                self.dongles_list.addItem("=== Configuration Options ===")
+                
+                if len(series_groups) > 1 and multi_series_available:
+                    self.dongles_list.addItem("Configure Multi-Series Mapping:")
+                    self.dongles_list.addItem("   Enable multi-series mode in model")
+                    self.dongles_list.addItem("   properties to use mixed dongle types.")
+                else:
+                    self.dongles_list.addItem("Single-Series Configuration:")
+                    self.dongles_list.addItem("   All detected dongles are same series.")
+                    self.dongles_list.addItem("   Standard mode will be used.")
+                
+                # Summary
+                self.dongles_list.addItem("")
+                self.dongles_list.addItem(f"Summary: {len(devices)} device(s), {len(series_groups)} series type(s)")
+                
+                # Store enhanced device info
                 self.detected_devices = devices
+                self.detected_series_groups = series_groups
+                
+                # Store multi-series availability for other methods
+                self.multi_series_available = multi_series_available
                 
             else:
                 self.dongles_list.addItem("No Kneron devices detected")
+                self.dongles_list.addItem("")
+                self.dongles_list.addItem("Troubleshooting:")
+                self.dongles_list.addItem("- Check USB connections")
+                self.dongles_list.addItem("- Ensure dongles are powered")
+                self.dongles_list.addItem("- Try different USB ports")
+                self.dongles_list.addItem("- Check device drivers")
+                
                 self.detected_devices = []
+                self.detected_series_groups = {}
+                self.multi_series_available = multi_series_available
                 
         except Exception as e:
-            # Fallback to simulation if scanning fails
+            # Enhanced fallback with multi-series simulation
             self.dongles_list.addItem("Device scanning failed - using simulation")
-            self.dongles_list.addItem("Simulated KL520 Dongle - Port 28")
-            self.dongles_list.addItem("Simulated KL720 Dongle - Port 32")
-            self.detected_devices = []
+            self.dongles_list.addItem("")
+            self.dongles_list.addItem("=== Simulated Devices ===")
+            self.dongles_list.addItem("KL520 Series (3 GOPS):")
+            self.dongles_list.addItem("   Port 28 (ID: 0x100)")
+            self.dongles_list.addItem("KL720 Series (28 GOPS):")
+            self.dongles_list.addItem("   Port 32 (ID: 0x720)")
+            self.dongles_list.addItem("")
+            self.dongles_list.addItem("Multi-Series Mode Available!")
+            self.dongles_list.addItem("   Total Combined GOPS: 31")
+            self.dongles_list.addItem("")
+            self.dongles_list.addItem("Summary: 2 device(s), 2 series type(s)")
+            
+            # Create simulated device data
+            self.detected_devices = [
+                {'port_id': 28, 'series': 'KL520'},
+                {'port_id': 32, 'series': 'KL720'}
+            ]
+            self.detected_series_groups = {
+                'KL520': [{'port_id': 28, 'series': 'KL520'}],
+                'KL720': [{'port_id': 32, 'series': 'KL720'}]
+            }
+            self.multi_series_available = True
             
             # Print error for debugging
             print(f"Dongle detection error: {str(e)}")
@@ -1852,6 +2044,243 @@ class IntegratedPipelineDashboard(QMainWindow):
         """
         return [device['port_id'] for device in self.get_detected_devices()]
     
+    def create_port_mapping_widget(self, node):
+        """Create port mapping widget for multi-series configuration."""
+        try:
+            from PyQt5.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, 
+                                       QLabel, QPushButton, QComboBox, QTableWidget, 
+                                       QTableWidgetItem, QHeaderView)
+            
+            # Main container widget
+            container = QWidget()
+            container.setStyleSheet("""
+                QWidget {
+                    background-color: #1e1e2e;
+                    border: 1px solid #45475a;
+                    border-radius: 6px;
+                    margin: 2px;
+                }
+            """)
+            
+            layout = QVBoxLayout(container)
+            layout.setContentsMargins(8, 8, 8, 8)
+            
+            # Title
+            title_label = QLabel("Port ID to Series Mapping")
+            title_label.setStyleSheet("""
+                QLabel {
+                    color: #f9e2af;
+                    font-size: 13px;
+                    font-weight: bold;
+                    background: none;
+                    border: none;
+                    margin-bottom: 5px;
+                }
+            """)
+            layout.addWidget(title_label)
+            
+            # Get detected devices
+            series_groups = getattr(self, 'detected_series_groups', {})
+            detected_devices = getattr(self, 'detected_devices', [])
+            
+            if not detected_devices:
+                # Show message if no devices detected
+                no_devices_label = QLabel("No devices detected. Use 'Detect Dongles' button above.")
+                no_devices_label.setStyleSheet("""
+                    QLabel {
+                        color: #f38ba8;
+                        font-size: 11px;
+                        background: none;
+                        border: none;
+                        padding: 10px;
+                        text-align: center;
+                    }
+                """)
+                layout.addWidget(no_devices_label)
+                return container
+            
+            # Create mapping table
+            if len(series_groups) > 1:
+                # Multiple series detected - show mapping table
+                table = QTableWidget()
+                table.setColumnCount(3)
+                table.setHorizontalHeaderLabels(["Port ID", "Detected Series", "Assign To"])
+                table.setRowCount(len(detected_devices))
+                
+                # Style the table
+                table.setStyleSheet("""
+                    QTableWidget {
+                        background-color: #313244;
+                        gridline-color: #45475a;
+                        color: #cdd6f4;
+                        border: 1px solid #45475a;
+                        font-size: 10px;
+                    }
+                    QTableWidget::item {
+                        padding: 5px;
+                        border-bottom: 1px solid #45475a;
+                    }
+                    QTableWidget::item:selected {
+                        background-color: #89b4fa;
+                    }
+                    QHeaderView::section {
+                        background-color: #45475a;
+                        color: #f9e2af;
+                        padding: 5px;
+                        border: none;
+                        font-weight: bold;
+                    }
+                """)
+                
+                # Get current port mapping from node
+                current_mapping = node.get_property('port_mapping') if hasattr(node, 'get_property') else {}
+                
+                # Populate table
+                available_series = list(series_groups.keys())
+                for i, device in enumerate(detected_devices):
+                    port_id = device['port_id']
+                    detected_series = device['series']
+                    
+                    # Port ID column (read-only)
+                    port_item = QTableWidgetItem(str(port_id))
+                    port_item.setFlags(port_item.flags() & ~0x02)  # Make read-only
+                    table.setItem(i, 0, port_item)
+                    
+                    # Detected Series column (read-only)
+                    series_item = QTableWidgetItem(detected_series)
+                    series_item.setFlags(series_item.flags() & ~0x02)  # Make read-only
+                    table.setItem(i, 1, series_item)
+                    
+                    # Assignment combo box
+                    combo = QComboBox()
+                    combo.addItems(['Auto'] + available_series)
+                    
+                    # Set current mapping
+                    if str(port_id) in current_mapping:
+                        mapped_series = current_mapping[str(port_id)]
+                        if mapped_series in available_series:
+                            combo.setCurrentText(mapped_series)
+                        else:
+                            combo.setCurrentText('Auto')
+                    else:
+                        combo.setCurrentText('Auto')
+                    
+                    # Style combo box
+                    combo.setStyleSheet("""
+                        QComboBox {
+                            background-color: #45475a;
+                            color: #cdd6f4;
+                            border: 1px solid #585b70;
+                            padding: 3px;
+                            font-size: 10px;
+                        }
+                        QComboBox:hover {
+                            border-color: #74c7ec;
+                        }
+                        QComboBox::drop-down {
+                            border: none;
+                        }
+                        QComboBox::down-arrow {
+                            width: 10px;
+                            height: 10px;
+                        }
+                    """)
+                    
+                    def make_mapping_handler(port, combo_widget):
+                        def on_mapping_change(series_name):
+                            # Update node property
+                            if hasattr(node, 'set_property'):
+                                current_mapping = node.get_property('port_mapping') if hasattr(node, 'get_property') else {}
+                                if series_name == 'Auto':
+                                    # Remove explicit mapping, let auto-detection handle it
+                                    current_mapping.pop(str(port), None)
+                                else:
+                                    current_mapping[str(port)] = series_name
+                                node.set_property('port_mapping', current_mapping)
+                                print(f"Port {port} mapped to {series_name}")
+                        return on_mapping_change
+                    
+                    combo.currentTextChanged.connect(make_mapping_handler(port_id, combo))
+                    table.setCellWidget(i, 2, combo)
+                
+                # Adjust column widths
+                table.horizontalHeader().setStretchLastSection(True)
+                table.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeToContents)
+                table.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeToContents)
+                table.setMaximumHeight(150)
+                
+                layout.addWidget(table)
+                
+                # Add configuration button
+                config_button = QPushButton("Advanced Configuration")
+                config_button.setStyleSheet("""
+                    QPushButton {
+                        background-color: #89b4fa;
+                        color: #1e1e2e;
+                        border: none;
+                        padding: 6px 12px;
+                        border-radius: 4px;
+                        font-size: 11px;
+                        font-weight: bold;
+                    }
+                    QPushButton:hover {
+                        background-color: #74c7ec;
+                    }
+                    QPushButton:pressed {
+                        background-color: #585b70;
+                    }
+                """)
+                
+                def open_multi_series_config():
+                    try:
+                        from ui.dialogs.multi_series_config import MultiSeriesConfigDialog
+                        dialog = MultiSeriesConfigDialog()
+                        
+                        # Pre-populate with current detected devices
+                        if hasattr(dialog, 'set_detected_devices'):
+                            dialog.set_detected_devices(detected_devices, series_groups)
+                        
+                        if dialog.exec_() == dialog.Accepted:
+                            config = dialog.get_configuration()
+                            # Update node properties with configuration
+                            if hasattr(node, 'set_property') and config:
+                                for key, value in config.items():
+                                    node.set_property(key, value)
+                                # Refresh properties panel
+                                self.update_node_properties_panel(node)
+                                print("Multi-series configuration updated")
+                    except ImportError as e:
+                        print(f"Multi-series config dialog not available: {e}")
+                
+                config_button.clicked.connect(open_multi_series_config)
+                layout.addWidget(config_button)
+                
+            else:
+                # Single series detected - show info message
+                single_series = list(series_groups.keys())[0] if series_groups else "Unknown"
+                info_label = QLabel(f"All devices are {single_series} series. Multi-series mapping not needed.")
+                info_label.setStyleSheet("""
+                    QLabel {
+                        color: #94e2d5;
+                        font-size: 11px;
+                        background: none;
+                        border: none;
+                        padding: 10px;
+                        text-align: center;
+                    }
+                """)
+                layout.addWidget(info_label)
+            
+            return container
+            
+        except Exception as e:
+            print(f"Error creating port mapping widget: {e}")
+            # Return simple label as fallback
+            from PyQt5.QtWidgets import QLabel
+            fallback_label = QLabel("Port mapping configuration unavailable")
+            fallback_label.setStyleSheet("color: #f38ba8; padding: 10px;")
+            return fallback_label
+    
     def get_device_by_port(self, port_id):
         """
         Get device information by port ID.

utils/__init__.py

@@ -21,12 +21,8 @@ Usage:
 # Import utilities as they are implemented
 # from . import file_utils
 # from . import ui_utils
-from .folder_dialog import select_folder, select_assets_folder, validate_assets_folder_structure
 
 __all__ = [
     # "file_utils",
     # "ui_utils"
-    "select_folder",
-    "select_assets_folder", 
-    "validate_assets_folder_structure"
 ]

utils/folder_dialog.py

@@ -1,252 +0,0 @@
-"""
-Folder selection utilities using PyQt5 as primary, tkinter as fallback
-"""
-
-import os
-
-def select_folder(title="Select Folder", initial_dir="", must_exist=True):
-    """
-    Open a folder selection dialog using PyQt5 (preferred) or tkinter (fallback)
-    
-    Args:
-        title (str): Dialog window title
-        initial_dir (str): Initial directory to open
-        must_exist (bool): Whether the folder must already exist
-        
-    Returns:
-        str: Selected folder path, or empty string if cancelled
-    """
-    # Try PyQt5 first (more reliable on macOS)
-    try:
-        from PyQt5.QtWidgets import QApplication, QFileDialog
-        import sys
-        
-        # Create QApplication if it doesn't exist
-        app = QApplication.instance()
-        if app is None:
-            app = QApplication(sys.argv)
-        
-        # Set initial directory
-        if not initial_dir:
-            initial_dir = os.getcwd()
-        elif not os.path.exists(initial_dir):
-            initial_dir = os.getcwd()
-        
-        # Open folder selection dialog
-        folder_path = QFileDialog.getExistingDirectory(
-            None,
-            title,
-            initial_dir,
-            QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks
-        )
-        
-        return folder_path if folder_path else ""
-        
-    except ImportError:
-        print("PyQt5 not available, trying tkinter...")
-        
-        # Fallback to tkinter
-        try:
-            import tkinter as tk
-            from tkinter import filedialog
-            
-            # Create a root window but keep it hidden
-            root = tk.Tk()
-            root.withdraw()  # Hide the main window
-            root.attributes('-topmost', True)  # Bring dialog to front
-            
-            # Set initial directory
-            if not initial_dir:
-                initial_dir = os.getcwd()
-            
-            # Open folder selection dialog
-            folder_path = filedialog.askdirectory(
-                title=title,
-                initialdir=initial_dir,
-                mustexist=must_exist
-            )
-            
-            # Destroy the root window
-            root.destroy()
-            
-            return folder_path if folder_path else ""
-            
-        except ImportError:
-            print("tkinter also not available")
-            return ""
-        except Exception as e:
-            print(f"Error opening tkinter folder dialog: {e}")
-            return ""
-    
-    except Exception as e:
-        print(f"Error opening PyQt5 folder dialog: {e}")
-        return ""
-
-def select_assets_folder(initial_dir=""):
-    """
-    Specialized function for selecting Assets folder with validation
-    
-    Args:
-        initial_dir (str): Initial directory to open
-        
-    Returns:
-        dict: Result with 'path', 'valid', and 'message' keys
-    """
-    folder_path = select_folder(
-        title="Select Assets Folder (containing Firmware/ and Models/)",
-        initial_dir=initial_dir
-    )
-    
-    if not folder_path:
-        return {'path': '', 'valid': False, 'message': 'No folder selected'}
-    
-    # Validate folder structure
-    validation_result = validate_assets_folder_structure(folder_path)
-    
-    return {
-        'path': folder_path,
-        'valid': validation_result['valid'],
-        'message': validation_result['message'],
-        'details': validation_result.get('details', {})
-    }
-
-def validate_assets_folder_structure(folder_path):
-    """
-    Validate that a folder has the expected Assets structure
-    
-    Expected structure:
-    Assets/
-    ├── Firmware/
-    │   ├── KL520/
-    │   │   ├── fw_scpu.bin
-    │   │   └── fw_ncpu.bin
-    │   └── KL720/
-    │       ├── fw_scpu.bin
-    │       └── fw_ncpu.bin
-    └── Models/
-        ├── KL520/
-        │   └── model.nef
-        └── KL720/
-            └── model.nef
-    
-    Args:
-        folder_path (str): Path to validate
-        
-    Returns:
-        dict: Validation result with 'valid', 'message', and 'details' keys
-    """
-    if not os.path.exists(folder_path):
-        return {'valid': False, 'message': 'Folder does not exist'}
-    
-    if not os.path.isdir(folder_path):
-        return {'valid': False, 'message': 'Path is not a directory'}
-    
-    details = {}
-    issues = []
-    
-    # Check for Firmware and Models folders
-    firmware_path = os.path.join(folder_path, 'Firmware')
-    models_path = os.path.join(folder_path, 'Models')
-    
-    has_firmware = os.path.exists(firmware_path) and os.path.isdir(firmware_path)
-    has_models = os.path.exists(models_path) and os.path.isdir(models_path)
-    
-    details['has_firmware_folder'] = has_firmware
-    details['has_models_folder'] = has_models
-    
-    if not has_firmware:
-        issues.append("Missing 'Firmware' folder")
-    
-    if not has_models:
-        issues.append("Missing 'Models' folder")
-    
-    if not (has_firmware and has_models):
-        return {
-            'valid': False,
-            'message': f"Invalid folder structure: {', '.join(issues)}",
-            'details': details
-        }
-    
-    # Check for series subfolders
-    expected_series = ['KL520', 'KL720', 'KL630', 'KL730', 'KL540']
-    
-    firmware_series = []
-    models_series = []
-    
-    try:
-        firmware_dirs = [d for d in os.listdir(firmware_path) 
-                        if os.path.isdir(os.path.join(firmware_path, d))]
-        firmware_series = [d for d in firmware_dirs if d in expected_series]
-        
-        models_dirs = [d for d in os.listdir(models_path)
-                      if os.path.isdir(os.path.join(models_path, d))]
-        models_series = [d for d in models_dirs if d in expected_series]
-        
-    except Exception as e:
-        return {
-            'valid': False,
-            'message': f"Error reading folder contents: {e}",
-            'details': details
-        }
-    
-    details['firmware_series'] = firmware_series
-    details['models_series'] = models_series
-    
-    # Find common series (have both firmware and models)
-    common_series = list(set(firmware_series) & set(models_series))
-    details['available_series'] = common_series
-    
-    if not common_series:
-        return {
-            'valid': False,
-            'message': "No series found with both firmware and models folders",
-            'details': details
-        }
-    
-    # Check for actual files in series folders
-    series_with_files = []
-    for series in common_series:
-        has_files = False
-        
-        # Check firmware files
-        fw_series_path = os.path.join(firmware_path, series)
-        if os.path.exists(fw_series_path):
-            fw_files = [f for f in os.listdir(fw_series_path) 
-                       if f.endswith('.bin')]
-            if fw_files:
-                has_files = True
-        
-        # Check model files
-        model_series_path = os.path.join(models_path, series)
-        if os.path.exists(model_series_path):
-            model_files = [f for f in os.listdir(model_series_path) 
-                          if f.endswith('.nef')]
-            if model_files and has_files:
-                series_with_files.append(series)
-    
-    details['series_with_files'] = series_with_files
-    
-    if not series_with_files:
-        return {
-            'valid': False,
-            'message': "No series found with actual firmware and model files",
-            'details': details
-        }
-    
-    return {
-        'valid': True,
-        'message': f"Valid Assets folder with {len(series_with_files)} series: {', '.join(series_with_files)}",
-        'details': details
-    }
-
-# Example usage
-if __name__ == "__main__":
-    print("Testing folder selection...")
-    
-    # Test basic folder selection
-    folder = select_folder("Select any folder")
-    print(f"Selected: {folder}")
-    
-    # Test Assets folder selection with validation
-    result = select_assets_folder()
-    print(f"Assets folder result: {result}")

utils/multi_series_setup.py

@@ -0,0 +1,447 @@
+"""
+Multi-Series Setup Utility
+
+This utility helps users set up the proper folder structure and configuration
+for multi-series dongle inference.
+
+Features:
+- Create recommended folder structure
+- Validate existing folder structure  
+- Generate example configuration files
+- Provide setup guidance and troubleshooting
+
+Usage:
+    python utils/multi_series_setup.py create-structure --path "C:/MyAssets"
+    python utils/multi_series_setup.py validate --path "C:/MyAssets"
+    python utils/multi_series_setup.py help
+"""
+
+import os
+import sys
+import argparse
+from typing import List, Tuple, Dict
+import json
+
+
+class MultiSeriesSetup:
+    """Utility class for multi-series setup operations"""
+    
+    SUPPORTED_SERIES = ['520', '720', '630', '730', '540']
+    REQUIRED_FW_FILES = ['fw_scpu.bin', 'fw_ncpu.bin']
+    
+    @staticmethod
+    def create_folder_structure(base_path: str, series_list: List[str] = None) -> bool:
+        """
+        Create the recommended folder structure for multi-series assets
+        
+        Args:
+            base_path: Root path where assets folder should be created
+            series_list: List of series to create folders for
+            
+        Returns:
+            bool: Success status
+        """
+        if series_list is None:
+            series_list = MultiSeriesSetup.SUPPORTED_SERIES
+        
+        try:
+            assets_path = os.path.join(base_path, 'Assets')
+            firmware_path = os.path.join(assets_path, 'Firmware')
+            models_path = os.path.join(assets_path, 'Models')
+            
+            # Create main directories
+            os.makedirs(firmware_path, exist_ok=True)
+            os.makedirs(models_path, exist_ok=True)
+            
+            print(f"✓ Created main directories at: {assets_path}")
+            
+            # Create series-specific directories
+            created_series = []
+            for series in series_list:
+                series_name = f'KL{series}'
+                fw_dir = os.path.join(firmware_path, series_name)
+                model_dir = os.path.join(models_path, series_name)
+                
+                os.makedirs(fw_dir, exist_ok=True)
+                os.makedirs(model_dir, exist_ok=True)
+                created_series.append(series_name)
+                
+            print(f"✓ Created series directories: {', '.join(created_series)}")
+            
+            # Create README file explaining the structure
+            readme_content = MultiSeriesSetup._generate_readme_content()
+            readme_path = os.path.join(assets_path, 'README.md')
+            with open(readme_path, 'w') as f:
+                f.write(readme_content)
+            
+            print(f"✓ Created README file: {readme_path}")
+            
+            # Create example configuration
+            config_example = MultiSeriesSetup._generate_example_config(assets_path, series_list)
+            config_path = os.path.join(assets_path, 'example_config.json')
+            with open(config_path, 'w') as f:
+                json.dump(config_example, f, indent=2)
+            
+            print(f"✓ Created example configuration: {config_path}")
+            
+            print(f"\n🎉 Multi-series folder structure created successfully!")
+            print(f"📁 Assets folder: {assets_path}")
+            print("\n📋 Next steps:")
+            print("1. Copy your firmware files to the appropriate Firmware/KLxxx/ folders")
+            print("2. Copy your model files to the appropriate Models/KLxxx/ folders") 
+            print("3. Configure your model node to use this Assets folder")
+            print("4. Enable multi-series mode and select desired series")
+            
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error creating folder structure: {e}")
+            return False
+    
+    @staticmethod
+    def validate_folder_structure(assets_path: str) -> Tuple[bool, List[str]]:
+        """
+        Validate an existing folder structure for multi-series configuration
+        
+        Args:
+            assets_path: Path to the assets folder
+            
+        Returns:
+            Tuple of (is_valid, list_of_issues)
+        """
+        issues = []
+        
+        # Check if assets folder exists
+        if not os.path.exists(assets_path):
+            issues.append(f"Assets folder does not exist: {assets_path}")
+            return False, issues
+        
+        # Check for main folders
+        firmware_path = os.path.join(assets_path, 'Firmware')
+        models_path = os.path.join(assets_path, 'Models')
+        
+        if not os.path.exists(firmware_path):
+            issues.append(f"Firmware folder missing: {firmware_path}")
+        
+        if not os.path.exists(models_path):
+            issues.append(f"Models folder missing: {models_path}")
+        
+        if issues:
+            return False, issues
+        
+        # Check series folders and contents
+        found_series = []
+        
+        for item in os.listdir(firmware_path):
+            if item.startswith('KL') and os.path.isdir(os.path.join(firmware_path, item)):
+                series_name = item
+                series_fw_path = os.path.join(firmware_path, series_name)
+                series_model_path = os.path.join(models_path, series_name)
+                
+                # Check if corresponding model folder exists
+                if not os.path.exists(series_model_path):
+                    issues.append(f"Models folder missing for {series_name}: {series_model_path}")
+                    continue
+                
+                # Check firmware files
+                fw_issues = []
+                for fw_file in MultiSeriesSetup.REQUIRED_FW_FILES:
+                    fw_file_path = os.path.join(series_fw_path, fw_file)
+                    if not os.path.exists(fw_file_path):
+                        fw_issues.append(f"{fw_file} missing")
+                
+                if fw_issues:
+                    issues.append(f"{series_name} firmware issues: {', '.join(fw_issues)}")
+                
+                # Check for model files
+                model_files = [f for f in os.listdir(series_model_path) if f.endswith('.nef')]
+                if not model_files:
+                    issues.append(f"{series_name} has no .nef model files in {series_model_path}")
+                
+                if not fw_issues and model_files:
+                    found_series.append(series_name)
+        
+        if not found_series:
+            issues.append("No valid series configurations found")
+        
+        is_valid = len(issues) == 0
+        
+        # Print validation results
+        if is_valid:
+            print(f"✅ Validation passed!")
+            print(f"📁 Assets folder: {assets_path}")
+            print(f"🎯 Valid series found: {', '.join(found_series)}")
+        else:
+            print(f"❌ Validation failed with {len(issues)} issues:")
+            for i, issue in enumerate(issues, 1):
+                print(f"   {i}. {issue}")
+                
+        return is_valid, issues
+    
+    @staticmethod
+    def list_available_series(assets_path: str) -> Dict[str, Dict[str, any]]:
+        """
+        List all available and configured series in the assets folder
+        
+        Args:
+            assets_path: Path to the assets folder
+            
+        Returns:
+            Dict with series information
+        """
+        series_info = {}
+        
+        if not os.path.exists(assets_path):
+            return series_info
+        
+        firmware_path = os.path.join(assets_path, 'Firmware')
+        models_path = os.path.join(assets_path, 'Models')
+        
+        if not os.path.exists(firmware_path) or not os.path.exists(models_path):
+            return series_info
+        
+        for item in os.listdir(firmware_path):
+            if item.startswith('KL') and os.path.isdir(os.path.join(firmware_path, item)):
+                series_name = item
+                series_fw_path = os.path.join(firmware_path, series_name)
+                series_model_path = os.path.join(models_path, series_name)
+                
+                # Check firmware files
+                fw_files = {}
+                for fw_file in MultiSeriesSetup.REQUIRED_FW_FILES:
+                    fw_file_path = os.path.join(series_fw_path, fw_file)
+                    fw_files[fw_file] = os.path.exists(fw_file_path)
+                
+                # Check model files
+                model_files = []
+                if os.path.exists(series_model_path):
+                    model_files = [f for f in os.listdir(series_model_path) if f.endswith('.nef')]
+                
+                # Determine status
+                fw_complete = all(fw_files.values())
+                has_models = len(model_files) > 0
+                
+                if fw_complete and has_models:
+                    status = "✅ Ready"
+                elif fw_complete:
+                    status = "⚠️ Missing models"
+                elif has_models:
+                    status = "⚠️ Missing firmware"
+                else:
+                    status = "❌ Incomplete"
+                
+                series_info[series_name] = {
+                    'status': status,
+                    'firmware_files': fw_files,
+                    'model_files': model_files,
+                    'firmware_path': series_fw_path,
+                    'models_path': series_model_path
+                }
+        
+        return series_info
+    
+    @staticmethod
+    def _generate_readme_content() -> str:
+        """Generate README content for the assets folder"""
+        return '''
+# Multi-Series Assets Folder Structure
+
+This folder contains firmware and models organized by dongle series for multi-series inference.
+
+## Structure:
+```
+Assets/
+├── Firmware/
+│   ├── KL520/
+│   │   ├── fw_scpu.bin
+│   │   └── fw_ncpu.bin
+│   ├── KL720/
+│   │   ├── fw_scpu.bin
+│   │   └── fw_ncpu.bin
+│   └── [other series...]
+└── Models/
+    ├── KL520/
+    │   └── [model.nef files]
+    ├── KL720/
+    │   └── [model.nef files]
+    └── [other series...]
+```
+
+## Usage:
+1. Place firmware files (fw_scpu.bin, fw_ncpu.bin) in the appropriate series subfolder under Firmware/
+2. Place model files (.nef) in the appropriate series subfolder under Models/
+3. Configure your model node to use this Assets folder in multi-series mode
+4. Select which series to enable in the model node properties
+
+## Supported Series:
+- **KL520**: Entry-level performance (3 GOPS)
+- **KL720**: Mid-range performance (28 GOPS)
+- **KL630**: High performance (400 GOPS)
+- **KL730**: Very high performance (1600 GOPS)
+- **KL540**: Specialized performance (800 GOPS)
+
+## Performance Benefits:
+The multi-series system automatically load balances inference across all enabled series
+based on their GOPS capacity for optimal performance. You can expect:
+
+- Higher overall throughput by utilizing multiple dongle types simultaneously
+- Automatic load balancing based on dongle capabilities
+- Seamless failover if one series becomes unavailable
+- Scalable performance as you add more dongles
+
+## Validation:
+Run `python utils/multi_series_setup.py validate --path <this_folder>` to validate your configuration.
+
+## Troubleshooting:
+- Ensure all firmware files are exactly named `fw_scpu.bin` and `fw_ncpu.bin`
+- Model files must have `.nef` extension
+- Each series must have both firmware and at least one model file
+- Check file permissions and accessibility
+        '''.strip()
+    
+    @staticmethod
+    def _generate_example_config(assets_path: str, series_list: List[str]) -> Dict:
+        """Generate example configuration for model node"""
+        return {
+            "model_node_properties": {
+                "multi_series_mode": True,
+                "assets_folder": assets_path,
+                "enabled_series": series_list[:2],  # Enable first two series by default
+                "max_queue_size": 100,
+                "result_buffer_size": 1000,
+                "batch_size": 1
+            },
+            "expected_performance": {
+                "total_gops": sum([
+                    {"520": 3, "720": 28, "630": 400, "730": 1600, "540": 800}.get(series, 0)
+                    for series in series_list[:2]
+                ]),
+                "load_balancing": "automatic",
+                "expected_fps_improvement": "2-5x compared to single series"
+            },
+            "notes": [
+                "This is an example configuration",
+                "Adjust enabled_series based on your available dongles", 
+                "Higher queue sizes may improve performance but use more memory",
+                "Monitor system resources when using multiple series"
+            ]
+        }
+
+
+def main():
+    """Main CLI interface"""
+    parser = argparse.ArgumentParser(description='Multi-Series Dongle Setup Utility')
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    # Create structure command
+    create_parser = subparsers.add_parser('create-structure', help='Create folder structure')
+    create_parser.add_argument('--path', required=True, help='Base path for assets folder')
+    create_parser.add_argument('--series', nargs='*', default=None, help='Series to set up (default: all)')
+    
+    # Validate command
+    validate_parser = subparsers.add_parser('validate', help='Validate existing structure')
+    validate_parser.add_argument('--path', required=True, help='Path to assets folder')
+    
+    # List command
+    list_parser = subparsers.add_parser('list', help='List available series')
+    list_parser.add_argument('--path', required=True, help='Path to assets folder')
+    
+    # Help command
+    help_parser = subparsers.add_parser('help', help='Show detailed help')
+    
+    args = parser.parse_args()
+    
+    if args.command == 'create-structure':
+        series_list = args.series if args.series else None
+        MultiSeriesSetup.create_folder_structure(args.path, series_list)
+    
+    elif args.command == 'validate':
+        is_valid, issues = MultiSeriesSetup.validate_folder_structure(args.path)
+        sys.exit(0 if is_valid else 1)
+    
+    elif args.command == 'list':
+        series_info = MultiSeriesSetup.list_available_series(args.path)
+        
+        if not series_info:
+            print(f"❌ No series found in {args.path}")
+            sys.exit(1)
+        
+        print(f"📁 Series configuration in {args.path}:\n")
+        
+        for series_name, info in series_info.items():
+            print(f"  {series_name}: {info['status']}")
+            print(f"    📁 Firmware: {info['firmware_path']}")
+            print(f"    📁 Models: {info['models_path']}")
+            
+            if info['model_files']:
+                print(f"    📄 Model files: {', '.join(info['model_files'])}")
+            
+            fw_issues = [fw for fw, exists in info['firmware_files'].items() if not exists]
+            if fw_issues:
+                print(f"    ⚠️  Missing firmware: {', '.join(fw_issues)}")
+            
+            print()
+    
+    elif args.command == 'help':
+        print("""
+Multi-Series Dongle Setup Help
+=============================
+
+This utility helps you set up and manage multi-series dongle configurations
+for improved inference performance.
+
+Commands:
+---------
+
+create-structure --path <path> [--series KL520 KL720 ...]
+    Creates the recommended folder structure for multi-series assets.
+    
+    Example:
+        python utils/multi_series_setup.py create-structure --path "C:/MyAssets"
+        python utils/multi_series_setup.py create-structure --path "C:/MyAssets" --series 520 720
+
+validate --path <path>
+    Validates an existing assets folder structure.
+    
+    Example:
+        python utils/multi_series_setup.py validate --path "C:/MyAssets/Assets"
+
+list --path <path>
+    Lists all available series and their status in an assets folder.
+    
+    Example:
+        python utils/multi_series_setup.py list --path "C:/MyAssets/Assets"
+
+Setup Workflow:
+--------------
+1. Create folder structure: create-structure --path "C:/MyProject"
+2. Copy firmware files to Assets/Firmware/KLxxx/ folders
+3. Copy model files to Assets/Models/KLxxx/ folders  
+4. Validate configuration: validate --path "C:/MyProject/Assets"
+5. Configure model node in UI to use Assets folder
+6. Enable multi-series mode and select desired series
+
+Performance Benefits:
+-------------------
+- 2-5x throughput improvement with multiple series
+- Automatic load balancing based on dongle GOPS
+- Seamless scaling as you add more dongles
+- Fault tolerance if some dongles become unavailable
+
+Troubleshooting:
+---------------
+- Ensure exact firmware file names: fw_scpu.bin, fw_ncpu.bin
+- Model files must have .nef extension
+- Check file permissions and paths
+- Verify dongle connectivity with single-series mode first
+- Use validate command to check configuration
+
+For more help, see Assets/README.md after creating the structure.
+        """)
+    
+    else:
+        parser.print_help()
+
+
+if __name__ == '__main__':
+    main()

verify_properties.py

@@ -1,41 +0,0 @@
-#!/usr/bin/env python3
-"""
-Verify that properties are correctly set for multi-series
-"""
-
-def verify_properties():
-    """Check the expected multi-series properties"""
-    
-    print("Multi-Series Configuration Checklist:")
-    print("=" * 50)
-    
-    print("\n1. In your Dashboard, Model Node properties should have:")
-    print("   ✓ multi_series_mode = True")
-    print("   ✓ enabled_series = ['520', '720']")
-    print("   ✓ kl520_port_ids = '28,32'")
-    print("   ✓ kl720_port_ids = '4'")
-    print("   ✓ assets_folder = (optional, for auto model/firmware detection)")
-    
-    print("\n2. After setting these properties, when you deploy:")
-    print("   Expected output should show:")
-    print("   '[stage_1_Model_Node] Using multi-series mode with config: ...'")
-    print("   NOT: 'Single-series config converted to multi-series format'")
-    
-    print("\n3. If you still see single-series behavior:")
-    print("   a) Double-check property names (they should be lowercase)")
-    print("   b) Make sure multi_series_mode is checked/enabled")
-    print("   c) Verify port IDs are comma-separated strings")
-    print("   d) Save the .mflow file and re-deploy")
-    
-    print("\n4. Property format reference:")
-    print("   - kl520_port_ids: '28,32' (string, comma-separated)")
-    print("   - kl720_port_ids: '4' (string)")
-    print("   - enabled_series: ['520', '720'] (list)")
-    print("   - multi_series_mode: True (boolean)")
-    
-    print("\n" + "=" * 50)
-    print("If properties are set correctly, your deployment should use")
-    print("true multi-series load balancing across KL520 and KL720 dongles!")
-
-if __name__ == "__main__":
-    verify_properties()