matrice 1.0.99245__tar.gz → 1.0.99246__tar.gz

{matrice-1.0.99245/src/matrice.egg-info → matrice-1.0.99246}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice
-Version: 1.0.99245
+Version: 1.0.99246
 Summary: SDK for connecting to matrice.ai services
 Home-page: https://github.com/matrice-ai/python-sdk
 Author: Matrice.ai

{matrice-1.0.99245 → matrice-1.0.99246}/setup.py

@@ -14,7 +14,7 @@ long_description = (here / "README.md").read_text(encoding="utf-8")
 setup(
     name="matrice",
 
-    version = "1.0.99245",
+    version = "1.0.99246",
     
     description="SDK for connecting to matrice.ai services",
     long_description=long_description,

{matrice-1.0.99245 → matrice-1.0.99246}/src/matrice/deploy/utils/post_processing/__init__.py

@@ -56,6 +56,7 @@ from .core.config import (
     BaseConfig,
     PeopleCountingConfig,
     CustomerServiceConfig,
+    ProximityConfig,
     ZoneConfig,
     TrackingConfig,
     AlertConfig,
@@ -130,6 +131,7 @@ from .usecases.Histopathological_Cancer_Detection_img import HistopathologicalCa
 from .usecases import (
     PeopleCountingUseCase,
     CustomerServiceUseCase,
+    ProximityUseCase,
     AdvancedCustomerServiceUseCase,
     BasicCountingTrackingUseCase,
     LicensePlateUseCase,
@@ -193,6 +195,7 @@ from .usecases import (
 # Register use cases automatically
 _people_counting = PeopleCountingUseCase()
 _customer_service = CustomerServiceUseCase()
+_proximity_detection = ProximityUseCase()
 _advanced_customer_service = AdvancedCustomerServiceUseCase()
 _basic_counting_tracking = BasicCountingTrackingUseCase()
 _license_plate = LicensePlateUseCase()
@@ -248,7 +251,7 @@ _flower_segmentation = FlowerUseCase()
 _leaf_det = LeafUseCase()
 _smoker_detection = SmokerDetectionUseCase()
 _litter_detection = LitterDetectionUseCase()
-_abandoned_object_detection  = AbandonedObjectDetectionUseCase()
+_abandoned_object_detection = AbandonedObjectDetectionUseCase()
 _human_activity_recognition = HumanActivityUseCase()
 _gas_leak_detection = GasLeakDetectionUseCase()
 
@@ -262,6 +265,7 @@ _histopathological_cancer_detection = HistopathologicalCancerDetectionUseCase()
 registry.register_use_case(_abandoned_object_detection.category, _abandoned_object_detection.name, AbandonedObjectDetectionUseCase)
 registry.register_use_case(_litter_detection.category, _litter_detection.name, LitterDetectionUseCase)
 registry.register_use_case(_people_counting.category, _people_counting.name, PeopleCountingUseCase)
+registry.register_use_case(_proximity_detection.category, _proximity_detection.name, ProximityUseCase)
 registry.register_use_case(_customer_service.category, _customer_service.name, CustomerServiceUseCase)
 registry.register_use_case(_advanced_customer_service.category, _advanced_customer_service.name, AdvancedCustomerServiceUseCase)
 registry.register_use_case(_basic_counting_tracking.category, _basic_counting_tracking.name, BasicCountingTrackingUseCase)
@@ -373,6 +377,7 @@ from .utils import (  # noqa: E402
     # New utilities
     create_people_counting_config,
     create_intrusion_detection_config,
+    create_proximity_detection_config,
     create_customer_service_config,
     create_advanced_customer_service_config,
     create_basic_counting_tracking_config,
@@ -457,7 +462,8 @@ __all__ = [
     
     # Configuration classes
     'BaseConfig',
-    'PeopleCountingConfig', 
+    'PeopleCountingConfig',
+    'ProximityConfig', 
     'CustomerServiceConfig',
     'ColorDetectionConfig',
     'LicensePlateConfig',
@@ -524,6 +530,7 @@ __all__ = [
     # Use case classes
     'PeopleCountingUseCase',
     'CustomerServiceUseCase',
+    'ProximityUseCase',
     'AdvancedCustomerServiceUseCase',
     'BasicCountingTrackingUseCase',
     'LicensePlateUseCase',
@@ -643,6 +650,7 @@ __all__ = [
     # New utilities
     'create_people_counting_config',
     'create_intrusion_detection_config',
+    'create_proximity_detection_config',
     'create_customer_service_config',
     'create_advanced_customer_service_config',
     'create_basic_counting_tracking_config',

{matrice-1.0.99245 → matrice-1.0.99246}/src/matrice/deploy/utils/post_processing/config.py

@@ -1,6 +1,7 @@
 APP_NAME_TO_USECASE = {
     "people_counting": "people_counting",
     "intrusion_detection": "intrusion_detection",
+    "proximity_detection": "proximity_detection",
     "mask_detection": "mask_detection",
     "pipeline_detection": "pipeline_detection",
     "vehicle_monitoring": "vehicle_monitoring",
@@ -55,6 +56,7 @@ APP_NAME_TO_USECASE = {
 APP_NAME_TO_CATEGORY = {
     "people_counting": "general",
     "intrusion_detection": "security",
+    "proximity_detection": "security",
     "mask_detection": "mask_detection",
     "pipeline_detection": "pipeline_detection",
     "vehicle_monitoring": "traffic",

{matrice-1.0.99245 → matrice-1.0.99246}/src/matrice/deploy/utils/post_processing/core/__init__.py

@@ -50,6 +50,7 @@ __all__ = [
     'BaseConfig',
     'PeopleCountingConfig',
     'IntrusionConfig',
+    'ProximityConfig',
     'CustomerServiceConfig',
     'ZoneConfig',
     'TrackingConfig',

{matrice-1.0.99245 → matrice-1.0.99246}/src/matrice/deploy/utils/post_processing/core/config.py

@@ -327,6 +327,7 @@ class PeopleCountingConfig(BaseConfig):
         
         return errors
 
+
 @dataclass
 class IntrusionConfig(BaseConfig):
     """Configuration for intrusion detection use case."""
@@ -346,7 +347,7 @@ class IntrusionConfig(BaseConfig):
     time_window_minutes: int = 60
     
     # Category mapping
-    person_categories: List[str] = field(default_factory=lambda: ["person", "people", "human"])
+    person_categories: List[str] = field(default_factory=lambda: ["person"])
     index_to_category: Optional[Dict[int, str]] = None
     
     # Alert configuration
@@ -372,6 +373,51 @@ class IntrusionConfig(BaseConfig):
         return errors
 
 
+@dataclass
+class ProximityConfig(BaseConfig):
+    """Configuration for intrusion detection use case."""
+    
+    # Smoothing configuration
+    enable_smoothing: bool = True
+    smoothing_algorithm: str = "observability"  # "window" or "observability"
+    smoothing_window_size: int = 20
+    smoothing_cooldown_frames: int = 5
+    smoothing_confidence_range_factor: float = 0.5
+    
+    # Zone configuration
+    zone_config: Optional[ZoneConfig] = None
+    
+    # Counting parameters
+    enable_unique_counting: bool = True
+    time_window_minutes: int = 60
+    
+    # Category mapping
+    person_categories: List[str] = field(default_factory=lambda: ["person"])
+    index_to_category: Optional[Dict[int, str]] = None
+    
+    # Alert configuration
+    alert_config: Optional[AlertConfig] = None
+    
+    def validate(self) -> List[str]:
+        """Validate proximity detection configuration."""
+        errors = super().validate()
+        
+        if self.time_window_minutes <= 0:
+            errors.append("time_window_minutes must be positive")
+        
+        if not self.person_categories:
+            errors.append("person_categories cannot be empty")
+        
+        # Validate nested configurations
+        if self.zone_config:
+            errors.extend(self.zone_config.validate())
+        
+        if self.alert_config:
+            errors.extend(self.alert_config.validate())
+        
+        return errors
+
+
 @dataclass  
 class CustomerServiceConfig(BaseConfig):
     """Configuration for customer service use case."""
@@ -450,6 +496,7 @@ class ConfigManager:
             "customer_service": CustomerServiceConfig,
             "advanced_customer_service": CustomerServiceConfig,
             "intrusion_detection": IntrusionConfig,
+            "proximity_detection": ProximityConfig,
             "basic_counting_tracking": None,  # Will be set later to avoid circular import
             "license_plate_detection": None,  # Will be set later to avoid circular import
             "ppe_compliance_detection": None,
@@ -1032,6 +1079,24 @@ class ConfigManager:
                 alert_config=alert_config,
                 **kwargs
             )
+        
+        elif usecase == "proximity_detection":
+            # Handle nested configurations
+            zone_config = kwargs.pop("zone_config", None)
+            if zone_config and isinstance(zone_config, dict):
+                zone_config = ZoneConfig(**zone_config)
+
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = ProximityConfig(
+                category=category or "security",
+                usecase=usecase,
+                zone_config=zone_config,
+                alert_config=alert_config,
+                **kwargs
+            )
 
         elif usecase in ["customer_service", "advanced_customer_service"]:
             # Handle nested configurations

{matrice-1.0.99245 → matrice-1.0.99246}/src/matrice/deploy/utils/post_processing/core/config_utils.py

@@ -13,6 +13,7 @@ from .config import (
     PeopleCountingConfig,
     CustomerServiceConfig,
     IntrusionConfig,
+    ProximityConfig,
     ZoneConfig,
     TrackingConfig,
     AlertConfig,
@@ -132,13 +133,73 @@ def create_intrusion_detection_config(
         usecase="intrusion_detection",
         confidence_threshold=confidence_threshold,
         zone_config=zone_config,
-        person_categories=person_categories or ["person", "people", "human"],
+        person_categories=person_categories or ["person"],
         enable_tracking=enable_tracking,
         time_window_minutes=time_window_minutes,
         alert_config=alert_config,
         **kwargs
     )
 
+
+def create_proximity_detection_config(
+    confidence_threshold: float = 0.5,
+    zones: Optional[Dict[str, List[List[float]]]] = None,
+    person_categories: Optional[List[str]] = None,
+    enable_tracking: bool = False,
+    time_window_minutes: int = 60,
+    alert_thresholds: Optional[Dict[str, int]] = None,
+    category: str = "general",
+    **kwargs
+) -> ProximityConfig:
+    """
+    Create a proximity detection configuration with sensible defaults.
+    
+    Args:
+        confidence_threshold: Minimum confidence for detections (0.0-1.0)
+        zones: Dictionary of zone_name -> polygon points [[x1,y1], [x2,y2], ...]
+        person_categories: List of category names that represent people
+        enable_tracking: Whether to enable object tracking
+        time_window_minutes: Time window for counting statistics
+        alert_thresholds: Dictionary of zone_name -> max_count for alerts
+        category: Use case category
+        **kwargs: Additional configuration parameters
+        
+    Returns:
+        ProximityConfig: Configured proximity detection configuration
+        
+    Example:
+        config = create_proximity_detection_config(
+            confidence_threshold=0.6,
+            zones={
+                "entrance": [[0, 0], [100, 0], [100, 100], [0, 100]],
+                "exit": [[200, 0], [300, 0], [300, 100], [200, 100]]
+            },
+            alert_thresholds={"entrance": 10, "exit": 5}
+        )
+    """
+    # Create zone configuration if zones provided
+    zone_config = None
+    if zones:
+        zone_config = ZoneConfig(zones=zones)
+    
+    # Create alert configuration if thresholds provided  
+    alert_config = None
+    if alert_thresholds:
+        alert_config = AlertConfig(count_thresholds=alert_thresholds)
+    
+    return ProximityConfig(
+        category=category,
+        usecase="proximity_detection",
+        confidence_threshold=confidence_threshold,
+        zone_config=zone_config,
+        person_categories=person_categories or ["person"],
+        enable_tracking=enable_tracking,
+        time_window_minutes=time_window_minutes,
+        alert_config=alert_config,
+        **kwargs
+    )
+
+
 def create_customer_service_config(
     confidence_threshold: float = 0.5,
     customer_areas: Optional[Dict[str, List[List[float]]]] = None,
@@ -513,6 +574,8 @@ def create_config_from_template(
             return create_people_counting_config(**overrides)
         elif usecase == "intrusion_detection":
             return create_intrusion_detection_config(**overrides)
+        elif usecase == "proximity_detection":
+            return create_proximity_detection_config(**overrides)
         elif usecase == "customer_service":
             return create_customer_service_config(**overrides)
         elif usecase == "advanced_customer_service":
@@ -566,17 +629,33 @@ def get_use_case_examples() -> Dict[str, Dict[str, Any]]:
             "confidence_threshold": 0.6,
             "enable_tracking": True,
             "time_window_minutes": 60,
-            "person_categories": ["person", "people", "human"],
+            "person_categories": ["person"],
             "zone_config": {
                 "zones": {
-                    "High": [[535, 558], [745, 453], [846, 861], [665, 996]],
-                    "Mid": [[663, 995], [925, 817], [1266, 885], [1012, 1116]]
+                    "Boarding Gate": [[314, 652], [1034, 317], [1854, 845], [987, 1491]]
                 }
             },
             "alert_config": {
                 "count_thresholds": {
-                    "High": 0,
-                    "Mid": 0,
+                    "Boarding Gate": 0
+                },
+                "alert_cooldown": 10.0
+            }
+        },
+        
+        "proximity_detection": {
+            "usecase": "proximity_detection",
+            "category": "security",
+            "confidence_threshold": 0.6,
+            "enable_tracking": True,
+            "time_window_minutes": 60,
+            "person_categories": ["person"],
+            "zone_config": {
+                "zones": {}
+            },
+            "alert_config": {
+                "count_thresholds": {
+                    "Boarding Gate": 0
                 },
                 "alert_cooldown": 10.0
             }

{matrice-1.0.99245 → matrice-1.0.99246}/src/matrice/deploy/utils/post_processing/processor.py

@@ -25,12 +25,14 @@ from .core.config import (
     PeopleCountingConfig, 
     CustomerServiceConfig,
     IntrusionConfig,
+    ProximityConfig,
     config_manager,
     ConfigValidationError
 )
 from .usecases import (
     PeopleCountingUseCase,
     IntrusionUseCase,
+    ProximityUseCase,
     CustomerServiceUseCase,
     AdvancedCustomerServiceUseCase,
     LicensePlateUseCase,
@@ -73,7 +75,6 @@ from .usecases import (
     WeldDefectUseCase,
     WeaponDetectionUseCase,
 
-    AgeDetectionUseCase,
     PriceTagUseCase,
     DistractedDriverUseCase,
     EmergencyVehicleUseCase,
@@ -157,6 +158,9 @@ class PostProcessor:
         # Register intrusion detection use case
         registry.register_use_case("security", "intrusion_detection", IntrusionUseCase)
         
+        # Register proximity detection use case
+        registry.register_use_case("security", "proximity_detection", ProximityUseCase)
+        
         # Register customer service use case
         registry.register_use_case("sales", "customer_service", CustomerServiceUseCase)
         
@@ -340,8 +344,8 @@ class PostProcessor:
             elif isinstance(use_case, ChickenPoseDetectionUseCase):
                 result = use_case.process(data, parsed_config, context, stream_info)
             elif isinstance(use_case, FlareAnalysisUseCase):
-                result = use_case.process(data, parsed_config,input_bytes, context, stream_info)
-            elif isinstance(use_case,LicensePlateUseCase):
+                result = use_case.process(data, parsed_config, input_bytes, context, stream_info)
+            elif isinstance(use_case, LicensePlateUseCase):
                 result = use_case.process(data, parsed_config, context, stream_info)
             elif isinstance(use_case, CropWeedDetectionUseCase):
                 result = use_case.process(data, parsed_config, context, stream_info)

{matrice-1.0.99245 → matrice-1.0.99246}/src/matrice/deploy/utils/post_processing/usecases/__init__.py

@@ -7,6 +7,7 @@ post-processing scenarios.
 
 from .people_counting import PeopleCountingUseCase, PeopleCountingConfig
 from .intrusion_detection import IntrusionUseCase, IntrusionConfig
+from .proximity_detection import ProximityUseCase, ProximityConfig
 from .customer_service import CustomerServiceUseCase, CustomerServiceConfig
 from .advanced_customer_service import AdvancedCustomerServiceUseCase
 from .basic_counting_tracking import BasicCountingTrackingUseCase
@@ -86,6 +87,7 @@ from .Histopathological_Cancer_Detection_img import HistopathologicalCancerDetec
 __all__ = [
     'PeopleCountingUseCase',
     'IntrusionUseCase',
+    'ProximityUseCase',
     'CustomerServiceUseCase',
     'AdvancedCustomerServiceUseCase',
     'BasicCountingTrackingUseCase',
@@ -157,6 +159,7 @@ __all__ = [
 
     'PeopleCountingConfig',
     'IntrusionConfig',
+    'ProximityConfig',
     'ParkingSpaceConfig',
     'CustomerServiceConfig',
     'AdvancedCustomerServiceConfig',

{matrice-1.0.99245 → matrice-1.0.99246}/src/matrice/deploy/utils/post_processing/usecases/intrusion_detection.py

@@ -554,14 +554,14 @@ class IntrusionUseCase(BaseProcessor):
                     return zone_count
                 else:
                     return 0
-            human_text_lines.append(f"\t- Total count in Prohibited Boarding Gate: {total_people}")
+            human_text_lines.append(f"\t- Person detected in Prohibited Boarding Gate: {total_people}")
             human_text_lines.append("")
             human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
                 
             for zone_name, zone_count in zone_analysis.items():
                 zone_total = robust_zone_total(zone_count)
                 human_text_lines.append(f"\t- Zone name: {zone_name}")
-                human_text_lines.append(f"\t\t\t- Total count in Prohibited Boarding Gate: {zone_total}")
+                human_text_lines.append(f"\t\t\t- Total person detected in Prohibited Boarding Gate: {zone_total-1}")
                         # human_text_lines.append(f"\t\t- Total count in Prohibited Boarding Gate: {zone_total-1}")
 
                 
@@ -1485,7 +1485,7 @@ class IntrusionUseCase(BaseProcessor):
                 "person_categories": {
                     "type": "array",
                     "items": {"type": "string"},
-                    "default": ["person", "people", "human"],
+                    "default": ["person"],
                     "description": "Category names that represent people"
                 },
                 "enable_unique_counting": {
@@ -1547,7 +1547,7 @@ class IntrusionUseCase(BaseProcessor):
             "enable_analytics": True,
             "enable_unique_counting": True,
             "time_window_minutes": 60,
-            "person_categories": ["person", "people", "human"],
+            "person_categories": ["person"],
         }
         defaults.update(overrides)
         return IntrusionConfig(**defaults)