Skip to content

Solutions Plugin Collection

Description

The Solutions plugin collection provides enterprise-grade, pre-built AI solutions for CVEDIA-RT that implement complete end-to-end workflows for industry-specific computer vision applications. These solutions combine multiple AI models, processing pipelines, and analytics engines into ready-to-deploy, production-ready packages designed for real-world security and surveillance deployments.

Key Features

  • Complete Solution Architecture: End-to-end security analytics platform with integrated AI models
  • Enterprise-Ready Deployment: Production-grade solutions with VMS integration and REST APIs
  • 16+ Analytics Types: Comprehensive security analytics including intrusion, loitering, crowding, and weapon detection
  • Multi-Modal Support: RGB and thermal imaging with adaptive processing
  • Scalable Architecture: Edge-to-cloud deployment options with centralized management
  • Real-Time Processing: Low-latency analytics with configurable performance profiles
  • Standards Compliance: OpenAPI 3.0 REST interfaces and industry-standard integration patterns

Available Solutions

SecuRT (Security Real-Time)

Primary Solution: Comprehensive security analytics platform
Industry Focus: Physical security, surveillance, and safety monitoring
Deployment Models: Edge, enterprise, and cloud-based installations

Core Capabilities: - Advanced object detection (Person, Vehicle, Animal, Face) - Behavioral analytics and anomaly detection - Perimeter security and access control - Crowd monitoring and safety compliance - License plate recognition (ALPR) - Weapon and threat detection - Face analysis and person re-identification

Use Cases

  • Critical Infrastructure: Airports, power plants, government facilities
  • Retail Security: Loss prevention, crowd management, safety monitoring
  • Corporate Security: Office buildings, campuses, parking facilities
  • Transportation: Stations, terminals, traffic monitoring
  • Smart Cities: Public safety, urban surveillance, event monitoring
  • Industrial Safety: Manufacturing facilities, hazardous area monitoring

SecuRT Solution Architecture

Core Components

1. AI Detection Engine - Multi-scale object detection with 256x256, 320x320, and 512x512 model variants - Hardware-accelerated inference (NVIDIA, Intel, Hailo, Blaize) - Motion-guided processing for computational efficiency - Adaptive sensitivity profiles (Low/Medium/High)

2. Analytics Processing Pipeline - Real-time behavioral analysis - Multi-object tracking and trajectory analysis - Event correlation and temporal reasoning - Configurable alert thresholds and filtering

3. Solution Manager - Dynamic configuration management - Instance lifecycle control - Performance monitoring and optimization - Enterprise integration interfaces

Analytics Types

Area-Based Analytics

Analytics Type Description Key Parameters
Intrusion Detection Unauthorized entry monitoring Duration threshold, object classes
Loitering Suspicious behavior detection Time threshold, sensitivity
Crowding Crowd density monitoring Person count limits, density
Occupancy Space utilization monitoring Max occupancy, duration
Crowd Estimation Accurate people counting Density calculation, flow analysis
Dwelling Extended presence detection Duration, object persistence
Object Left Abandoned object detection Duration, size filtering
Object Removed Theft detection Duration, change detection
Crossing Zone entry/exit monitoring Direction, dwell time
Armed Person Weapon detection Classification confidence
Fallen Person Safety incident detection Pose analysis, duration
Vehicle Guard Vehicle security monitoring Vehicle classification
Face Covered Mask/face covering detection Face analysis, coverage ratio

Line-Based Analytics

Analytics Type Description Key Parameters
Line Crossing Tripwire monitoring Direction, object filtering
People Counting Bidirectional flow counting In/out counting, accuracy
Tailgating Following behavior detection Time threshold, separation
Speed Detection Velocity measurement Distance calibration, time analysis

Requirements

Hardware Requirements

Minimum Edge Deployment: - Intel Core i5 or equivalent ARM processor - 8GB RAM - GPU with 2GB VRAM (NVIDIA GTX 1050 or equivalent) - Storage: 10GB available space

Recommended Enterprise Deployment: - Intel Xeon or high-performance CPU (8+ cores) - 32GB+ RAM - Dedicated GPU with 8GB+ VRAM (NVIDIA RTX series) - SSD storage: 100GB+ available space - Network: Gigabit Ethernet

Cloud Deployment: - Scalable compute instances (CPU/GPU configurations) - Load balancers and auto-scaling groups - Distributed storage systems - High-bandwidth network connectivity

Software Dependencies

Core Requirements: - CVEDIA-RT platform with SecuRT solution license - Compatible inference engines (TensorRT, OpenVINO, etc.) - Operating system: Windows 10+ or Linux (Ubuntu 20.04+)

Integration Dependencies: - REST API clients for VMS integration - Database systems for event storage (PostgreSQL, MySQL) - Message queuing systems (MQTT, Apache Kafka) - Web servers for dashboard interfaces

Network Requirements: - Bandwidth: 1-10 Mbps per camera stream (depending on resolution) - Latency: <100ms for real-time applications - Ports: 3546 (SecuRTRest API), configurable streaming ports - Protocols: HTTP/HTTPS, RTSP/RTP, MQTT

Configuration

Basic SecuRT Configuration

{
  "solution": {
    "id": "securt",
    "name": "Security Analytics Instance",
    "performance_profile": "Balanced",
    "sensitivity": "Medium",
    "detector_mode": "SmartDetection",
    "sensor_modality": "RGB",
    "max_fps": 30
  },
  "networks": {
    "detection_model": "auto://pva_det/rgb_thermal/medium_mosaic_rot90_256x256/250701",
    "face_model": "auto://face_reid/rgb/resnet18_112x112/240531",
    "lpr_model": "auto://licence_plate_recognition/rgb/lprnet_100x50/240415"
  },
  "features": {
    "person_reid": true,
    "face_detection": true,
    "license_plate_recognition": true,
    "attribute_extraction": ["armed", "fallen", "face_covered"]
  }
}

Advanced Enterprise Configuration

{
  "solution": {
    "id": "securt_enterprise",
    "name": "Enterprise Security Platform",
    "performance_profile": "Performance",
    "sensitivity": "High",
    "detector_mode": "SmartDetection",
    "multi_camera_tracking": true,
    "thermal_fusion": true
  },
  "analytics": {
    "intrusion_areas": [
      {
        "id": "perimeter_001",
        "name": "Main Perimeter",
        "coordinates": [
          {"x": 0.1, "y": 0.1},
          {"x": 0.9, "y": 0.1},
          {"x": 0.9, "y": 0.9},
          {"x": 0.1, "y": 0.9}
        ],
        "classes": ["Person", "Vehicle"],
        "duration_threshold": 2.0,
        "sensitivity": "High",
        "enable_tracking": true
      }
    ],
    "counting_lines": [
      {
        "id": "entrance_001",
        "name": "Main Entrance",
        "coordinates": [
          {"x": 0.3, "y": 0.5},
          {"x": 0.7, "y": 0.5}
        ],
        "direction": "Both",
        "classes": ["Person"],
        "enable_reid": true
      }
    ]
  },
  "integration": {
    "rest_api": {
      "enabled": true,
      "port": 3546,
      "authentication": "bearer_token"
    },
    "event_streaming": {
      "mqtt": {
        "enabled": true,
        "broker": "mqtt://broker.company.com:1883",
        "topics": {
          "alerts": "security/alerts",
          "counts": "security/counts",
          "events": "security/events"
        }
      }
    },
    "database": {
      "type": "postgresql",
      "host": "db.company.com",
      "database": "security_events",
      "retention_days": 90
    }
  },
  "performance": {
    "inference_optimization": {
      "batch_size": 4,
      "tensorrt_optimization": true,
      "fp16_precision": true
    },
    "memory_management": {
      "max_tracked_objects": 1000,
      "history_buffer_size": 3600,
      "garbage_collection_interval": 300
    }
  }
}

Configuration Schema

Parameter Type Default Description
solution.id string "securt" Solution identifier
solution.name string "SecuRT Instance" Human-readable instance name
solution.performance_profile enum "Balanced" Performance/Balanced/Accurate
solution.sensitivity enum "Medium" Low/Medium/High sensitivity
solution.detector_mode enum "SmartDetection" Detection mode
solution.sensor_modality enum "RGB" RGB/Thermal sensor type
solution.max_fps integer 30 Maximum processing frame rate
networks.detection_model string auto AI model for object detection
networks.face_model string auto Face recognition model
networks.lpr_model string auto License plate recognition model
features.person_reid boolean false Enable person re-identification
features.face_detection boolean false Enable face detection
features.license_plate_recognition boolean false Enable ALPR
analytics.intrusion_areas array [] Intrusion detection zones
analytics.counting_lines array [] People counting lines
integration.rest_api.enabled boolean true Enable REST API
integration.rest_api.port integer 3546 API server port
integration.event_streaming.mqtt.enabled boolean false Enable MQTT streaming
performance.inference_optimization.batch_size integer 1 Inference batch size
performance.memory_management.max_tracked_objects integer 500 Maximum tracked objects

API Reference

C++ Solution Interface

namespace cvedia::rt::iface {
    class SecuRT : virtual public SolutionManager {
    public:
        // Analytics Management
        virtual std::string getAnalyticsEntities(AnalyticsCategory category) const = 0;
        virtual expected<void> removeAnalyticsEntity(std::string const& entityId) = 0;

        // Area Analytics Creation
        virtual bool createIntrusionArea(std::string const& id, std::string const& name,
                                        std::vector<cv::Point2f> const& coordinates,
                                        std::vector<ObjectClass> const& classes,
                                        double durationThreshold, Sensitivity sensitivity) const = 0;

        virtual bool createLoiteringArea(std::string const& id, std::string const& name,
                                        std::vector<cv::Point2f> const& coordinates,
                                        std::vector<ObjectClass> const& classes,
                                        double durationThreshold, Sensitivity sensitivity) const = 0;

        virtual bool createCrowdingArea(std::string const& id, std::string const& name,
                                       std::vector<cv::Point2f> const& coordinates,
                                       std::vector<ObjectClass> const& classes,
                                       int maxPersons, double durationThreshold) const = 0;

        virtual bool createArmedPersonArea(std::string const& id, std::string const& name,
                                          std::vector<cv::Point2f> const& coordinates,
                                          double confidenceThreshold) const = 0;

        // Line Analytics Creation
        virtual bool createLineCrossing(std::string const& id, std::string const& name,
                                       std::vector<cv::Point2f> const& coordinates,
                                       std::vector<ObjectClass> const& classes,
                                       Direction direction) const = 0;

        virtual bool createTailgatingLine(std::string const& id, std::string const& name,
                                         std::vector<cv::Point2f> const& coordinates,
                                         std::vector<ObjectClass> const& classes,
                                         double timeThreshold) const = 0;

        // Configuration Management
        virtual bool setPerformanceProfile(PerformanceProfile profile) = 0;
        virtual bool setSensitivity(Sensitivity sensitivity) = 0;
        virtual bool setAttributesExtractionMode(AttributesExtractionMode mode) const = 0;
        virtual bool setFeatureExtraction(std::unordered_set<FeatureExtractionType> const& types) = 0;

        // Event Handling
        virtual void registerEventCallback(std::function<void(SecurityEvent const&)> callback) = 0;
        virtual std::vector<SecurityEvent> getRecentEvents(int limit = 100) const = 0;

        // Statistics and Monitoring
        virtual SolutionStats getStatistics() const = 0;
        virtual PerformanceMetrics getPerformanceMetrics() const = 0;
    };
}

Security Event Structure

struct SecurityEvent {
    std::string eventId;
    std::string instanceId;
    std::string analyticsId;
    EventType type;
    ObjectClass objectClass;
    cv::Rect2f boundingBox;
    std::vector<cv::Point2f> trajectory;
    double confidence;
    std::chrono::system_clock::time_point timestamp;
    std::unordered_map<std::string, std::string> attributes;
    std::optional<std::string> imageData; // Base64 encoded
};

enum class EventType {
    Intrusion,
    Loitering,
    Crowding,
    LineCrossing,
    ObjectLeft,
    ObjectRemoved,
    ArmedPerson,
    FallenPerson,
    Tailgating,
    FaceCovered,
    VehicleGuard
};

Solution Factory

namespace cvedia::rt::api::factory {
    class Solutions {
    public:
        static std::unique_ptr<iface::SecuRT> createSecuRT(const std::string& configPath);
        static std::vector<std::string> getAvailableSolutions();
        static SolutionInfo getSolutionInfo(const std::string& solutionId);
        static bool isSolutionLicensed(const std::string& solutionId);
    };
}

Examples

Basic SecuRT Instance Creation

#include "api/factory/solutions.h"
#include "interface/securt.h"

// Create SecuRT instance
auto secuRT = api::factory::Solutions::createSecuRT("config/securt_basic.json");
if (!secuRT) {
    PLOG_ERROR << "Failed to create SecuRT instance";
    return -1;
}

// Configure basic intrusion detection
std::vector<cv::Point2f> perimeter = {
    {0.1f, 0.1f}, {0.9f, 0.1f}, {0.9f, 0.9f}, {0.1f, 0.9f}
};

bool success = secuRT->createIntrusionArea(
    "perimeter_001",
    "Main Perimeter",
    perimeter,
    {ObjectClass::Person, ObjectClass::Vehicle},
    2.0,  // 2 second threshold
    Sensitivity::High
);

if (success) {
    PLOG_INFO << "Intrusion detection area created successfully";
} else {
    PLOG_ERROR << "Failed to create intrusion detection area";
}

// Set up event callback
secuRT->registerEventCallback([](const SecurityEvent& event) {
    PLOG_INFO << "Security event: " << static_cast<int>(event.type)
              << " at " << event.timestamp.time_since_epoch().count();

    // Handle event (send alert, log to database, etc.)
    handleSecurityEvent(event);
});

// Start processing
secuRT->start();

// Monitor performance
while (secuRT->isRunning()) {
    auto stats = secuRT->getStatistics();
    auto metrics = secuRT->getPerformanceMetrics();

    PLOG_INFO << "Processing " << metrics.currentFps << " FPS, "
              << "Events: " << stats.totalEvents << ", "
              << "CPU: " << metrics.cpuUsage << "%";

    std::this_thread::sleep_for(std::chrono::seconds(10));
}

Multi-Analytics Enterprise Setup

#include "solutions/securt_enterprise.h"

class EnterpriseSecuritySystem {
public:
    EnterpriseSecuritySystem(const std::string& configPath) {
        // Load enterprise configuration
        config_ = loadConfiguration(configPath);

        // Create SecuRT instance with enterprise features
        secuRT_ = api::factory::Solutions::createSecuRT(configPath);

        if (!secuRT_) {
            throw std::runtime_error("Failed to create SecuRT instance");
        }

        setupAnalytics();
        setupIntegrations();
        setupMonitoring();
    }

    void start() {
        PLOG_INFO << "Starting enterprise security system";

        // Start SecuRT processing
        secuRT_->start();

        // Start integration services
        startEventStreaming();
        startRESTAPI();
        startDashboard();

        PLOG_INFO << "Enterprise security system started successfully";
    }

private:
    void setupAnalytics() {
        // Create multiple intrusion zones
        createPerimeterZones();
        createRestrictedAreas();
        createSafetyZones();

        // Create counting and monitoring lines
        createEntranceCounters();
        createTailgatingDetection();

        // Configure advanced analytics
        setupWeaponDetection();
        setupFallenPersonDetection();
        setupVehicleSecurity();
    }

    void createPerimeterZones() {
        for (const auto& zone : config_.perimeter_zones) {
            bool success = secuRT_->createIntrusionArea(
                zone.id,
                zone.name,
                zone.coordinates,
                zone.object_classes,
                zone.duration_threshold,
                zone.sensitivity
            );

            if (success) {
                PLOG_INFO << "Created perimeter zone: " << zone.name;
            } else {
                PLOG_ERROR << "Failed to create perimeter zone: " << zone.name;
            }
        }
    }

    void setupWeaponDetection() {
        for (const auto& area : config_.weapon_detection_areas) {
            bool success = secuRT_->createArmedPersonArea(
                area.id,
                area.name,
                area.coordinates,
                area.confidence_threshold
            );

            if (success) {
                PLOG_INFO << "Weapon detection enabled for area: " << area.name;

                // Set high-priority alert for weapon detection
                secuRT_->setAreaPriority(area.id, Priority::Critical);
            }
        }
    }

    void setupIntegrations() {
        // MQTT event streaming
        eventStreamer_ = std::make_unique<MQTTEventStreamer>(
            config_.mqtt_broker,
            config_.mqtt_topics
        );

        // Database integration
        eventDatabase_ = std::make_unique<EventDatabase>(
            config_.database_connection
        );

        // VMS integration
        vmsIntegrator_ = std::make_unique<VMSIntegrator>(
            config_.vms_settings
        );

        // Register event callback
        secuRT_->registerEventCallback([this](const SecurityEvent& event) {
            handleEnterpriseEvent(event);
        });
    }

    void handleEnterpriseEvent(const SecurityEvent& event) {
        // Log to database
        eventDatabase_->storeEvent(event);

        // Stream to MQTT
        eventStreamer_->publishEvent(event);

        // Forward to VMS
        if (event.type == EventType::Intrusion || 
            event.type == EventType::ArmedPerson) {
            vmsIntegrator_->sendHighPriorityAlert(event);
        }

        // Send to dashboard
        dashboardNotifier_->sendEvent(event);

        // Execute custom business logic
        processBusinessRules(event);
    }

    void startMonitoring() {
        monitoringThread_ = std::thread([this]() {
            while (running_) {
                auto stats = secuRT_->getStatistics();
                auto metrics = secuRT_->getPerformanceMetrics();

                // Monitor system health
                if (metrics.currentFps < config_.min_fps_threshold) {
                    PLOG_WARNING << "FPS below threshold: " << metrics.currentFps;
                    // Trigger performance optimization
                    optimizePerformance();
                }

                // Monitor memory usage
                if (metrics.memoryUsage > config_.max_memory_mb) {
                    PLOG_WARNING << "Memory usage high: " << metrics.memoryUsage << "MB";
                    // Trigger garbage collection
                    secuRT_->optimizeMemory();
                }

                // Update dashboard metrics
                updateSystemMetrics(stats, metrics);

                std::this_thread::sleep_for(std::chrono::seconds(30));
            }
        });
    }

    std::unique_ptr<iface::SecuRT> secuRT_;
    EnterpriseConfig config_;
    std::unique_ptr<MQTTEventStreamer> eventStreamer_;
    std::unique_ptr<EventDatabase> eventDatabase_;
    std::unique_ptr<VMSIntegrator> vmsIntegrator_;
    std::thread monitoringThread_;
    std::atomic<bool> running_{true};
};

Python Integration Example

import json
import requests
import threading
import time
from datetime import datetime
from typing import Dict, List, Callable

class SecuRTManager:
    def __init__(self, rest_api_url: str = "http://localhost:3546/v1/securt"):
        self.api_url = rest_api_url
        self.session = requests.Session()
        self.session.headers.update({'Content-Type': 'application/json'})
        self.instances = {}
        self.event_callbacks = []

    def create_security_instance(self, config: Dict) -> str:
        """Create new security instance with analytics"""

        # Create base instance
        response = self.session.post(f"{self.api_url}/instance", json=config)
        response.raise_for_status()
        instance_id = response.json()['id']

        self.instances[instance_id] = {
            'config': config,
            'created_at': datetime.now(),
            'areas': [],
            'lines': []
        }

        return instance_id

    def deploy_comprehensive_security(self, instance_id: str, security_config: Dict):
        """Deploy comprehensive security analytics"""

        # Deploy intrusion detection areas
        for area in security_config.get('intrusion_areas', []):
            area_id = self.create_intrusion_area(instance_id, area)
            self.instances[instance_id]['areas'].append({
                'id': area_id,
                'type': 'intrusion',
                'config': area
            })

        # Deploy loitering detection
        for area in security_config.get('loitering_areas', []):
            area_id = self.create_loitering_area(instance_id, area)
            self.instances[instance_id]['areas'].append({
                'id': area_id,
                'type': 'loitering',
                'config': area
            })

        # Deploy weapon detection zones
        for area in security_config.get('weapon_detection_areas', []):
            area_id = self.create_armed_person_area(instance_id, area)
            self.instances[instance_id]['areas'].append({
                'id': area_id,
                'type': 'armed_person',
                'config': area
            })

        # Deploy counting lines
        for line in security_config.get('counting_lines', []):
            line_id = self.create_crossing_line(instance_id, line)
            self.instances[instance_id]['lines'].append({
                'id': line_id,
                'type': 'crossing',
                'config': line
            })

        # Configure performance profile
        if 'performance_profile' in security_config:
            self.set_performance_profile(instance_id, security_config['performance_profile'])

    def create_intrusion_area(self, instance_id: str, area_config: Dict) -> str:
        """Create intrusion detection area"""
        url = f"{self.api_url}/instance/{instance_id}/area/intrusion"
        response = self.session.post(url, json=area_config)
        response.raise_for_status()
        return response.json()['id']

    def create_loitering_area(self, instance_id: str, area_config: Dict) -> str:
        """Create loitering detection area"""
        url = f"{self.api_url}/instance/{instance_id}/area/loitering"
        response = self.session.post(url, json=area_config)
        response.raise_for_status()
        return response.json()['id']

    def create_armed_person_area(self, instance_id: str, area_config: Dict) -> str:
        """Create weapon detection area"""
        url = f"{self.api_url}/instance/{instance_id}/area/armedperson"
        response = self.session.post(url, json=area_config)
        response.raise_for_status()
        return response.json()['id']

    def create_crossing_line(self, instance_id: str, line_config: Dict) -> str:
        """Create people counting line"""
        url = f"{self.api_url}/instance/{instance_id}/line/crossing"
        response = self.session.post(url, json=line_config)
        response.raise_for_status()
        return response.json()['id']

    def monitor_all_instances(self) -> Dict:
        """Get monitoring data for all instances"""
        monitoring_data = {}

        for instance_id in self.instances.keys():
            try:
                stats = self.get_instance_stats(instance_id)
                areas = self.get_instance_areas(instance_id)

                monitoring_data[instance_id] = {
                    'statistics': stats,
                    'areas': areas,
                    'status': 'active',
                    'last_check': datetime.now().isoformat()
                }
            except requests.RequestException as e:
                monitoring_data[instance_id] = {
                    'status': 'error',
                    'error': str(e),
                    'last_check': datetime.now().isoformat()
                }

        return monitoring_data

    def start_monitoring_loop(self, interval: int = 30):
        """Start continuous monitoring loop"""
        def monitor_loop():
            while True:
                try:
                    monitoring_data = self.monitor_all_instances()

                    for instance_id, data in monitoring_data.items():
                        if data['status'] == 'active':
                            stats = data['statistics']
                            print(f"Instance {instance_id}: "
                                  f"FPS={stats.get('averageFps', 0):.1f}, "
                                  f"Events={stats.get('totalEvents', 0)}, "
                                  f"CPU={stats.get('cpuUsage', 0):.1f}%")
                        else:
                            print(f"Instance {instance_id}: ERROR - {data.get('error', 'Unknown')}")

                    # Trigger callbacks
                    for callback in self.event_callbacks:
                        callback(monitoring_data)

                except Exception as e:
                    print(f"Monitoring error: {e}")

                time.sleep(interval)

        monitoring_thread = threading.Thread(target=monitor_loop, daemon=True)
        monitoring_thread.start()
        return monitoring_thread

# Usage Example
if __name__ == "__main__":
    # Create SecuRT manager
    manager = SecuRTManager()

    # Define comprehensive security configuration
    instance_config = {
        "name": "Corporate HQ Security",
        "detectorMode": "SmartDetection",
        "sensitivity": "High",
        "sensorModality": "RGB",
        "metadataMode": True,
        "statisticsMode": True,
        "maxFps": 30
    }

    security_config = {
        "intrusion_areas": [
            {
                "name": "Executive Floor",
                "coordinates": [
                    {"x": 0.2, "y": 0.2},
                    {"x": 0.8, "y": 0.2},
                    {"x": 0.8, "y": 0.8},
                    {"x": 0.2, "y": 0.8}
                ],
                "classes": ["Person"],
                "color": "#FF0000",
                "durationThreshold": 1.0,
                "sensitivity": "High"
            }
        ],
        "loitering_areas": [
            {
                "name": "Parking Garage",
                "coordinates": [
                    {"x": 0.0, "y": 0.0},
                    {"x": 1.0, "y": 0.0},
                    {"x": 1.0, "y": 0.4},
                    {"x": 0.0, "y": 0.4}
                ],
                "classes": ["Person"],
                "color": "#FFA500",
                "durationThreshold": 30.0,
                "sensitivity": "Medium"
            }
        ],
        "weapon_detection_areas": [
            {
                "name": "Security Checkpoint",
                "coordinates": [
                    {"x": 0.3, "y": 0.4},
                    {"x": 0.7, "y": 0.4},
                    {"x": 0.7, "y": 0.6},
                    {"x": 0.3, "y": 0.6}
                ],
                "color": "#FF00FF",
                "confidenceThreshold": 0.7
            }
        ],
        "counting_lines": [
            {
                "name": "Main Lobby Entrance",
                "coordinates": [
                    {"x": 0.1, "y": 0.5},
                    {"x": 0.9, "y": 0.5}
                ],
                "classes": ["Person"],
                "color": "#00FF00",
                "direction": "Both"
            }
        ],
        "performance_profile": "Performance"
    }

    # Deploy security system
    try:
        instance_id = manager.create_security_instance(instance_config)
        print(f"Created security instance: {instance_id}")

        manager.deploy_comprehensive_security(instance_id, security_config)
        print("Deployed comprehensive security analytics")

        # Start monitoring
        def handle_monitoring_data(data):
            # Custom handling of monitoring data
            for instance_id, instance_data in data.items():
                if instance_data.get('status') == 'active':
                    stats = instance_data['statistics']
                    if stats.get('averageFps', 0) < 20:
                        print(f"WARNING: Low FPS detected for instance {instance_id}")

        manager.event_callbacks.append(handle_monitoring_data)
        monitoring_thread = manager.start_monitoring_loop(interval=15)

        print("Security system deployed and monitoring started")
        print("Press Ctrl+C to stop...")

        # Keep main thread alive
        try:
            while True:
                time.sleep(1)
        except KeyboardInterrupt:
            print("\nShutting down security system...")

    except Exception as e:
        print(f"Failed to deploy security system: {e}")

Deployment Patterns

Edge Deployment

#!/bin/bash
# Edge deployment script for single-camera setup

# Configuration for edge device
cat > edge_securt_config.json << EOF
{
  "solution": {
    "id": "securt_edge",
    "name": "Edge Security Camera",
    "performance_profile": "Performance",
    "sensitivity": "Medium",
    "detector_mode": "SmartDetection",
    "sensor_modality": "RGB",
    "max_fps": 15
  },
  "optimization": {
    "model_size": "256x256",
    "fp16_inference": true,
    "batch_size": 1,
    "max_tracked_objects": 50
  },
  "local_storage": {
    "enable_local_events": true,
    "max_events": 1000,
    "retention_hours": 24
  }
}
EOF

# Deploy edge configuration
echo "Deploying edge SecuRT configuration..."
cvedia-rt --config edge_securt_config.json --mode edge

echo "Edge deployment complete"

Enterprise Multi-Camera Deployment

# docker-compose.yml for enterprise deployment
version: '3.8'

services:
  securt-manager:
    image: cvedia/securt-enterprise:latest
    ports:
      - "3546:3546"  # REST API
      - "8080:8080"  # Dashboard
    environment:
      - SECURT_LICENSE_KEY=${LICENSE_KEY}
      - PERFORMANCE_PROFILE=Balanced
      - DB_CONNECTION_STRING=${DB_URL}
      - MQTT_BROKER=${MQTT_BROKER}
    volumes:
      - ./config:/app/config
      - ./models:/app/models
      - securt-data:/app/data
    depends_on:
      - postgres
      - mqtt-broker

  postgres:
    image: postgres:13
    environment:
      - POSTGRES_DB=securt_events
      - POSTGRES_USER=securt
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - postgres-data:/var/lib/postgresql/data

  mqtt-broker:
    image: eclipse-mosquitto:2
    ports:
      - "1883:1883"
    volumes:
      - ./mqtt.conf:/mosquitto/config/mosquitto.conf

  dashboard:
    image: cvedia/securt-dashboard:latest
    ports:
      - "3000:3000"
    environment:
      - SECURT_API_URL=http://securt-manager:3546
      - MQTT_URL=mqtt://mqtt-broker:1883
    depends_on:
      - securt-manager

volumes:
  securt-data:
  postgres-data:

Performance Optimization

Model Selection and Optimization

// Performance tuning for different deployment scenarios
class SecuRTPerformanceOptimizer {
public:
    void optimizeForEdgeDevice(iface::SecuRT* secuRT) {
        // Use smaller model for edge deployment
        secuRT->setModelConfiguration({
            {"detection_model", "auto://pva_det/rgb/small_256x256/latest"},
            {"batch_size", 1},
            {"fp16_precision", true},
            {"max_tracked_objects", 50}
        });

        // Conservative performance profile
        secuRT->setPerformanceProfile(PerformanceProfile::Performance);

        // Reduced analytics for resource conservation
        secuRT->setFeatureExtraction({FeatureExtractionType::Basic});
    }

    void optimizeForServerDeployment(iface::SecuRT* secuRT) {
        // Use high-accuracy model for server
        secuRT->setModelConfiguration({
            {"detection_model", "auto://pva_det/rgb/large_512x512/latest"},
            {"batch_size", 4},
            {"tensorrt_optimization", true},
            {"max_tracked_objects", 1000}
        });

        // Accuracy-focused profile
        secuRT->setPerformanceProfile(PerformanceProfile::Accurate);

        // Full feature extraction
        secuRT->setFeatureExtraction({
            FeatureExtractionType::PersonReID,
            FeatureExtractionType::FaceReID,
            FeatureExtractionType::VehicleReID,
            FeatureExtractionType::AttributeExtraction
        });
    }

    void optimizeForCloudDeployment(iface::SecuRT* secuRT) {
        // Balanced configuration for cloud scaling
        secuRT->setModelConfiguration({
            {"detection_model", "auto://pva_det/rgb/medium_384x384/latest"},
            {"batch_size", 8},
            {"dynamic_batching", true},
            {"auto_scaling", true}
        });

        // Balanced performance profile
        secuRT->setPerformanceProfile(PerformanceProfile::Balanced);

        // Cloud-optimized settings
        secuRT->enableCloudFeatures({
            CloudFeature::LoadBalancing,
            CloudFeature::AutoScaling,
            CloudFeature::DistributedProcessing
        });
    }
};

Troubleshooting

Common Issues

License Validation Errors 

# Check SecuRT license status
cvedia-rt --check-license securt

# Validate license server connectivity
telnet license.cvedia.com 443

Performance Issues 

// Performance monitoring and optimization
class PerformanceMonitor {
public:
    void diagnosePerformance(iface::SecuRT* secuRT) {
        auto metrics = secuRT->getPerformanceMetrics();

        if (metrics.currentFps < 15) {
            PLOG_WARNING << "Low FPS detected: " << metrics.currentFps;

            // Check GPU utilization
            if (metrics.gpuUtilization < 50) {
                PLOG_INFO << "GPU underutilized, consider increasing batch size";
                optimizeBatchProcessing(secuRT);
            }

            // Check memory usage
            if (metrics.memoryUsage > 80) {
                PLOG_WARNING << "High memory usage: " << metrics.memoryUsage << "%";
                optimizeMemoryUsage(secuRT);
            }
        }

        if (metrics.trackingLag > 100) {
            PLOG_WARNING << "High tracking lag: " << metrics.trackingLag << "ms";
            optimizeTrackingSettings(secuRT);
        }
    }
};

Analytics Configuration Issues 

# Python diagnostic tool
def diagnose_analytics_config(manager, instance_id):
    try:
        areas = manager.get_instance_areas(instance_id)
        lines = manager.get_instance_lines(instance_id)

        # Check for overlapping areas
        for i, area1 in enumerate(areas):
            for j, area2 in enumerate(areas[i+1:], i+1):
                if check_polygon_overlap(area1['coordinates'], area2['coordinates']):
                    print(f"WARNING: Areas '{area1['name']}' and '{area2['name']}' overlap")

        # Check coordinate validity
        for area in areas:
            for coord in area['coordinates']:
                if not (0.0 <= coord['x'] <= 1.0 and 0.0 <= coord['y'] <= 1.0):
                    print(f"ERROR: Invalid coordinates in area '{area['name']}'")

        print(f"Analytics configuration valid: {len(areas)} areas, {len(lines)} lines")

    except Exception as e:
        print(f"Analytics configuration error: {e}")

Best Practices

Solution Architecture

  1. Modular Design: Design analytics configurations as reusable modules
  2. Performance Profiling: Match performance profiles to deployment constraints
  3. Scalable Configuration: Use configuration templates for consistent deployment
  4. Event Handling: Implement robust event processing with error recovery

Security and Compliance

  1. Data Privacy: Configure data retention and anonymization policies
  2. Access Control: Implement proper authentication and authorization
  3. Audit Logging: Enable comprehensive audit trails for compliance
  4. Secure Communications: Use encrypted channels for data transmission

Operations and Monitoring

  1. Health Monitoring: Implement comprehensive system health checks
  2. Performance Monitoring: Track key performance indicators and trends
  3. Alerting: Configure intelligent alerting for system and security events
  4. Backup and Recovery: Implement configuration backup and disaster recovery

Integration Guidelines

  1. API Best Practices: Follow REST API conventions and error handling
  2. Event Processing: Design efficient event processing pipelines
  3. Database Design: Optimize database schemas for event storage and retrieval
  4. Scalability Planning: Design for horizontal and vertical scaling requirements

See Also