matrice-analytics 0.1.60__py3-none-any.whl

matrice_analytics/boundary_drawing_internal/data/.gitignore

@@ -0,0 +1,12 @@
+# Boundary Drawing Tool Data Files
+# This directory contains user-generated boundary tool files
+# These files are created when users draw boundaries and should not be in version control
+
+# Ignore all files in this directory except this .gitignore
+*
+!.gitignore
+
+# Explanation:
+# - Each boundary tool session creates a unique timestamped directory
+# - Contains HTML files, processed images, and configuration files
+# - These are user-specific and should remain local 

matrice_analytics/boundary_drawing_internal/example_usage.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+Example usage of the Easy Boundary Drawing Tool.
+
+This file demonstrates various ways to use the boundary drawing tool
+with minimal code for quick zone definition.
+"""
+
+import os
+from matrice_analytics.boundary_drawing_internal import (
+    EasyBoundaryTool,
+    quick_boundary_tool,
+    create_standalone_tool,
+    get_usage_template
+)
+
+
+def example_1_quick_video_tool():
+    """Example 1: Create a boundary tool from a video file with one line."""
+    print("📹 Example 1: Quick video boundary tool")
+    print("=" * 50)
+    
+    # Replace with your video file path
+    video_path = "example_video.mp4"
+    
+    if os.path.exists(video_path):
+        # One line to create and open the tool
+        html_path = quick_boundary_tool(
+            video_path, 
+            zones_needed=["queue", "staff", "entry", "exit"]
+        )
+        print(f"✅ Tool created: {html_path}")
+    else:
+        print(f"⚠️  Video file not found: {video_path}")
+        print("Replace 'example_video.mp4' with your actual video file path")
+
+
+def example_2_image_tool():
+    """Example 2: Create a boundary tool from an image file."""
+    print("\n🖼️  Example 2: Image boundary tool")
+    print("=" * 50)
+    
+    # Replace with your image file path
+    image_path = "example_frame.jpg"
+    
+    if os.path.exists(image_path):
+        tool = EasyBoundaryTool()
+        html_path = tool.create_from_image(image_path)
+        print(f"✅ Tool created: {html_path}")
+    else:
+        print(f"⚠️  Image file not found: {image_path}")
+        print("Replace 'example_frame.jpg' with your actual image file path")
+
+
+def example_3_class_usage():
+    """Example 3: Using the class for more control."""
+    print("\n🔧 Example 3: Class-based usage with more control")
+    print("=" * 50)
+    
+    # Initialize tool with custom settings
+    tool = EasyBoundaryTool(
+        auto_open_browser=False,  # Don't auto-open browser
+        grid_step=25              # Smaller grid for precision
+    )
+    
+    # Replace with your file path
+    file_path = "your_file.mp4"  # or .jpg, .png, etc.
+    
+    if os.path.exists(file_path):
+        # Auto-detect file type and create tool
+        html_path = tool.quick_setup(
+            file_path,
+            zones_needed=["customer_area", "service_desk", "waiting_zone"]
+        )
+        print(f"✅ Tool created (browser not opened): {html_path}")
+        
+        # Get template code for integration
+        template = tool.get_template_code(["customer_area", "service_desk"])
+        print("\n📝 Template code for using your zones:")
+        print(template[:300] + "..." if len(template) > 300 else template)
+        
+        # Clean up temporary files when done
+        tool.cleanup()
+    else:
+        print(f"⚠️  File not found: {file_path}")
+        print("Replace 'your_file.mp4' with your actual file path")
+
+
+def example_4_standalone_tool():
+    """Example 4: Create a standalone tool for drag & drop."""
+    print("\n📎 Example 4: Standalone drag & drop tool")
+    print("=" * 50)
+    
+    # Create a standalone HTML tool
+    html_path = create_standalone_tool(
+        output_path="my_boundary_tool.html",
+        auto_open=True
+    )
+    
+    print(f"✅ Standalone tool created: {html_path}")
+    print("🎯 You can now drag & drop any video or image file into the tool!")
+
+
+def example_5_integration_code():
+    """Example 5: Show how to integrate generated zones with post-processing."""
+    print("\n🔗 Example 5: Integration with post-processing")
+    print("=" * 50)
+    
+    # Example zones (replace with your generated zones)
+    zones = {
+        "queue": [[100, 200], [300, 200], [300, 400], [100, 400]],
+        "staff": [[500, 100], [700, 100], [700, 300], [500, 300]],
+        "entry": [[50, 50], [150, 100]]
+    }
+    
+    print("📝 Example integration code:")
+    print("""
+# 1. Customer Service Processor
+from matrice_analytics.post_processing import CustomerServiceProcessor
+
+processor = CustomerServiceProcessor(
+    customer_areas=zones["queue"],
+    staff_areas=zones["staff"],
+    service_areas=zones.get("service", {})
+)
+
+# 2. Advanced Tracking with Entry/Exit
+from matrice_analytics.post_processing import AdvancedTrackingProcessor
+from matrice_analytics.post_processing.config import AdvancedTrackingConfig
+
+config = AdvancedTrackingConfig(
+    boundary_config={
+        "points": zones["entry"],
+        "type": "line"
+    }
+)
+tracker = AdvancedTrackingProcessor(config)
+
+# 3. Count objects in zones
+from matrice_analytics.post_processing import CountingProcessor
+
+counter = CountingProcessor(your_config)
+results = counter.count_in_zones(detection_results, zones=zones)
+    """)
+
+
+def example_6_workflow():
+    """Example 6: Complete workflow example."""
+    print("\n🔄 Example 6: Complete workflow")
+    print("=" * 50)
+    
+    print("""
+📋 Complete Boundary Drawing Workflow:
+
+1. 📹 Start with your video/image:
+   tool = EasyBoundaryTool()
+   html_path = tool.create_from_video("security_camera.mp4")
+
+2. 🎨 Use the interactive tool to draw zones:
+   - Select zone types (queue, staff, entry, etc.)
+   - Click on image to add points
+   - Complete zones with right-click or Enter
+   - Generate and copy the Python code
+
+3. 📝 Use generated zones in your application:
+   # Paste the generated code
+   zones = {
+       "queue": [[x1, y1], [x2, y2], ...],
+       "staff": [[x1, y1], [x2, y2], ...]
+   }
+
+4. 🔧 Integrate with post-processing:
+   processor = CustomerServiceProcessor(
+       customer_areas=zones["queue"],
+       staff_areas=zones["staff"]
+   )
+
+5. 🚀 Process your data:
+   results = processor.process_detections(detection_data)
+    """)
+
+
+def main():
+    """Run all examples."""
+    print("🎯 Easy Boundary Drawing Tool - Usage Examples")
+    print("=" * 60)
+    
+    # Run examples
+    example_1_quick_video_tool()
+    example_2_image_tool()
+    example_3_class_usage()
+    example_4_standalone_tool()
+    example_5_integration_code()
+    example_6_workflow()
+    
+    print("\n" + "=" * 60)
+    print("💡 Tips:")
+    print("- Replace example file paths with your actual files")
+    print("- The tool supports MP4, AVI, MOV, JPG, PNG, and more")
+    print("- Generated zones work directly with Matrice post-processing")
+    print("- Save configurations as JSON for reuse")
+    print("- Use custom zone names for specific use cases")
+
+
+if __name__ == "__main__":
+    main() 

matrice_analytics/boundary_drawing_internal/usage/README.md

@@ -0,0 +1,110 @@
+# Boundary Drawing Tool Usage Examples
+
+This folder contains ready-to-use launcher scripts for the Matrice Boundary Drawing Tool.
+
+## 📁 Files
+
+### `boundary_drawer_launcher.py`
+- **Purpose**: Full-featured launcher with comprehensive error handling
+- **Features**: Detailed instructions, multiple fallback methods, airport security zones
+- **Best for**: First-time users or when you need detailed guidance
+
+### `simple_boundary_launcher.py`
+- **Purpose**: Clean, simple launcher that's easy to customize
+- **Features**: Function-based approach, minimal output, customizable zones
+- **Best for**: Experienced users or when you want to modify the code
+
+## 🚀 Quick Start
+
+1. **Navigate to this folder**:
+   ```bash
+   cd python-sdk/src/matrice/deploy/utils/boundary_drawing_internal/usage
+   ```
+
+2. **Run a launcher**:
+   ```bash
+   python boundary_drawer_launcher.py
+   # OR
+   python simple_boundary_launcher.py
+   ```
+
+3. **The tool will**:
+   - Check if your video file exists at: `C:\Users\pathi\OneDrive\Desktop\matriceai\matrice-applications\airport-security\door2.mp4`
+   - Launch an interactive HTML tool in your browser
+   - Allow you to draw boundaries on video frames
+   - Generate Python code with zone coordinates
+
+## 🎯 Customization
+
+### Change Video Path
+Edit the `VIDEO_PATH` variable in either file:
+```python
+VIDEO_PATH = r"path\to\your\video.mp4"
+```
+
+### Modify Zone Names
+Update the zone lists for your specific use case:
+```python
+# For airport security
+SECURITY_ZONES = [
+    "entry_door",
+    "security_line", 
+    "checkpoint",
+    "waiting_area",
+    "restricted_zone",
+    "exit_door"
+]
+
+# For retail
+RETAIL_ZONES = [
+    "entrance",
+    "checkout",
+    "aisles",
+    "customer_service"
+]
+```
+
+## 🔧 How the Tool Works
+
+1. **Select Zone Type**: Choose from the dropdown menu
+2. **Draw Boundaries**: Click points on the video frame
+3. **Complete Zone**: Right-click or press Enter
+4. **Generate Code**: Click the "Generate Code" button
+5. **Copy & Use**: Copy the Python code for your application
+
+## 📤 Output Format
+
+The tool generates Python code like this:
+```python
+zones = {
+    "entry_door": [[100, 200], [300, 200], [300, 400], [100, 400]],
+    "security_line": [[350, 150], [500, 150], [500, 350], [350, 350]],
+    "checkpoint": [[200, 100], [400, 120], [380, 250], [180, 230]]
+}
+```
+
+## 🔗 Integration
+
+Use the generated zones with Matrice post-processing:
+```python
+from matrice_analytics.post_processing import CustomerServiceProcessor
+
+processor = CustomerServiceProcessor(
+    customer_areas=zones["waiting_area"],
+    staff_areas=zones["restricted_zone"]
+)
+```
+
+## 🐛 Troubleshooting
+
+- **Import Error**: Make sure you're running from the correct directory
+- **Video Not Found**: Check the video path in the script
+- **Browser Doesn't Open**: The HTML file path will be printed - open it manually
+- **Tool Not Working**: Try the alternative method in `boundary_drawer_launcher.py`
+
+## 💡 Tips
+
+- Use precise boundary drawing for better results
+- Save your zone configurations as JSON for reuse
+- Test with a short video clip first
+- The tool works with MP4, AVI, MOV, JPG, PNG files 

matrice_analytics/boundary_drawing_internal/usage/boundary_drawer_launcher.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Boundary Drawing Tool Launcher for Airport Security Video
+
+This script launches the interactive boundary drawing tool for creating
+zones in the airport security video door2.mp4.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add the python-sdk to the path so we can import matrice modules
+# Navigate up from usage folder to find the src directory
+current_dir = Path(__file__).parent.absolute()
+src_path = current_dir.parent.parent.parent
+sys.path.insert(0, str(src_path))
+
+# Alternative: Add the matrice package directly
+matrice_path = src_path / "matrice"
+if matrice_path.exists():
+    sys.path.insert(0, str(src_path))
+
+try:
+    from matrice_analytics.boundary_drawing_internal import (
+        EasyBoundaryTool,
+        quick_boundary_tool
+    )
+except ImportError as e:
+    print(f"❌ Error importing matrice modules: {e}")
+    print("Make sure you're running this from the matriceai directory")
+    sys.exit(1)
+
+
+def main():
+    """Launch the boundary drawing tool for the airport security video."""
+    
+    # Video path
+    video_path = r"C:\Users\pathi\OneDrive\Desktop\matriceai\matrice-applications\airport-security\door2.mp4"
+    
+    print("🎯 Airport Security Boundary Drawing Tool")
+    print("=" * 50)
+    print(f"📹 Video: {video_path}")
+    
+    # Check if video exists
+    if not os.path.exists(video_path):
+        print(f"❌ Video file not found: {video_path}")
+        print("\nPlease check that the file exists and the path is correct.")
+        return
+    
+    print("✅ Video file found!")
+    print("\n🚀 Launching boundary drawing tool...")
+    
+    try:
+        # Launch the boundary drawing tool with relevant zones for airport security
+        html_path = quick_boundary_tool(
+            video_path,
+            zones_needed=[
+                "entry_zone", 
+                "security_checkpoint", 
+                "waiting_area", 
+                "restricted_area",
+                "exit_zone",
+                "monitoring_zone"
+            ]
+        )
+        
+        print(f"✅ Boundary drawing tool launched!")
+        print(f"🌐 Tool URL: {html_path}")
+        print("\n📋 Instructions:")
+        print("1. The tool should open in your default browser")
+        print("2. Select a zone type from the dropdown")
+        print("3. Click on the video frame to create boundary points")
+        print("4. Right-click or press Enter to complete a zone")
+        print("5. Generate Python code when finished")
+        print("6. Copy the generated code for use in your application")
+        
+        print("\n💡 Suggested zones for airport security:")
+        print("- entry_zone: Area where people enter")
+        print("- security_checkpoint: X-ray and metal detector area")
+        print("- waiting_area: Queue or waiting zones")
+        print("- restricted_area: Staff-only or secure areas")
+        print("- exit_zone: Exit doors and pathways")
+        print("- monitoring_zone: Areas under special surveillance")
+        
+    except Exception as e:
+        print(f"❌ Error launching tool: {e}")
+        print("\nTrying alternative method...")
+        
+        # Alternative method using the class directly
+        try:
+            tool = EasyBoundaryTool(auto_open_browser=True)
+            html_path = tool.create_from_video(video_path)
+            print(f"✅ Alternative launch successful!")
+            print(f"🌐 Tool URL: {html_path}")
+        except Exception as e2:
+            print(f"❌ Alternative method also failed: {e2}")
+            print("Please check the matrice installation and try again.")
+
+
+if __name__ == "__main__":
+    main() 

matrice_analytics/boundary_drawing_internal/usage/simple_boundary_launcher.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+Simple Boundary Drawing Tool Launcher
+
+A simpler version of the boundary drawing launcher with more configuration options.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add the python-sdk to the path
+# Navigate up from usage folder to find the src directory
+current_dir = Path(__file__).parent.absolute()
+src_path = current_dir.parent.parent.parent
+sys.path.insert(0, str(src_path))
+
+# Alternative: Add the matrice package directly
+matrice_path = src_path / "matrice"
+if matrice_path.exists():
+    sys.path.insert(0, str(src_path))
+
+def launch_boundary_tool(video_path, custom_zones=None):
+    """
+    Launch the boundary drawing tool for any video file.
+    
+    Args:
+        video_path (str): Path to the video file
+        custom_zones (list): List of zone names to use
+    """
+    
+    try:
+        from matrice_analytics.boundary_drawing_internal import EasyBoundaryTool
+    except ImportError as e:
+        print(f"❌ Error importing matrice modules: {e}")
+        return None
+    
+    # Default zones if none provided
+    if custom_zones is None:
+        custom_zones = ["zone1", "zone2", "zone3", "zone4"]
+    
+    print(f"🎯 Launching boundary tool for: {os.path.basename(video_path)}")
+    print(f"📍 Zones to create: {', '.join(custom_zones)}")
+    
+    # Check if file exists
+    if not os.path.exists(video_path):
+        print(f"❌ File not found: {video_path}")
+        return None
+    
+    try:
+        # Create the tool with custom settings
+        tool = EasyBoundaryTool(
+            auto_open_browser=True,  # Automatically open browser
+            grid_step=20            # Grid step for precise drawing
+        )
+        
+        # Create the boundary tool
+        html_path = tool.quick_setup(video_path, zones_needed=custom_zones)
+        
+        print(f"✅ Tool created successfully!")
+        print(f"🌐 Browser should open automatically")
+        print(f"📄 Tool file: {html_path}")
+        
+        return html_path
+        
+    except Exception as e:
+        print(f"❌ Error creating tool: {e}")
+        return None
+
+
+if __name__ == "__main__":
+    # Your video path
+    VIDEO_PATH = r"C:\Users\pathi\OneDrive\Desktop\matriceai\matrice-applications\airport-security\door2.mp4"
+    
+    # Custom zones for airport security (you can modify these)
+    SECURITY_ZONES = [
+        "entry_door",
+        "security_line", 
+        "checkpoint",
+        "waiting_area",
+        "restricted_zone",
+        "exit_door"
+    ]
+    
+    print("🔒 Airport Security Boundary Drawing Tool")
+    print("=" * 45)
+    
+    # Launch the tool
+    result = launch_boundary_tool(VIDEO_PATH, SECURITY_ZONES)
+    
+    if result:
+        print("\n✨ Success! The boundary drawing tool is now open.")
+        print("\n📋 How to use:")
+        print("1. Select a zone type from the dropdown menu")
+        print("2. Click points on the video frame to draw boundaries") 
+        print("3. Complete each zone by right-clicking or pressing Enter")
+        print("4. Click 'Generate Code' when finished")
+        print("5. Copy the generated Python code for your application")
+        
+        print("\n💾 The generated code will look like:")
+        print("zones = {")
+        print('    "entry_door": [[x1, y1], [x2, y2], ...],')
+        print('    "security_line": [[x1, y1], [x2, y2], ...],')
+        print("    ...")
+        print("}")
+    else:
+        print("\n❌ Failed to launch the tool. Please check the error messages above.")