Integration Examples

# Advanced integration with tracking
from harpoon import DroneDetector, DroneTracker
import numpy as np

class DefenseSystem:
    def __init__(self):
        self.detector = DroneDetector("harpoon_v1.1.onnx")
        self.tracker = DroneTracker()
        self.threat_threshold = 0.7
        
    def process_frame(self, frame):
        # Detect drones
        detections = self.detector.detect(frame)
        
        # Update tracking
        tracked_objects = self.tracker.update(detections)
        
        # Assess threats
        for obj in tracked_objects:
            if obj.confidence > self.threat_threshold:
                self.handle_threat(obj)
                
    def handle_threat(self, threat):
        # Integration with defense systems
        threat_data = {
            'position': threat.bbox,
            'confidence': threat.confidence,
            'track_id': threat.id,
            'velocity': threat.velocity
        }
        
        # Send to command center
        self.notify_command_center(threat_data)
        
        # Activate countermeasures if needed
        if threat.confidence > 0.9:
            self.activate_countermeasures(threat)

# Real-time streaming integration
import asyncio
from harpoon import AsyncDroneDetector

async def stream_processor():
    detector = AsyncDroneDetector("harpoon_v1.1.onnx")
    
    # Connect to your camera stream
    stream_url = "rtsp://camera.local/stream"
    
    async for frame in camera_stream(stream_url):
        # Non-blocking detection
        detections = await detector.detect_async(frame)
        
        # Process results immediately
        if detections:
            await handle_detections(detections)
            
async def handle_detections(detections):
    for detection in detections:
        # Send real-time alerts
        await alert_system.notify_async(detection)
        
        # Update dashboard
        await dashboard.update_threats(detection)

# Run the stream processor
asyncio.run(stream_processor())

# Python API client integration
import requests
import cv2
import json

class HarpoonAPIClient:
    def __init__(self, api_url, api_key):
        self.api_url = api_url
        self.headers = {"Authorization": f"Bearer {api_key}"}
    
    def detect_drones(self, image_path, confidence=0.6):
        with open(image_path, 'rb') as img_file:
            files = {'image': img_file}
            data = {'confidence': confidence}
            
            response = requests.post(
                f"{self.api_url}/detect",
                headers=self.headers,
                files=files,
                data=data
            )
            
            return response.json()
    
    def stream_detect(self, camera_url):
        cap = cv2.VideoCapture(camera_url)
        
        while True:
            ret, frame = cap.read()
            if not ret:
                break
                
            # Save frame temporarily
            cv2.imwrite('temp_frame.jpg', frame)
            
            # Send for detection
            results = self.detect_drones('temp_frame.jpg')
            
            # Process results
            if results['detections']:
                self.handle_detections(results['detections'])

# Usage
client = HarpoonAPIClient("http://harpoon-api:8080", "your-api-key")
client.stream_detect("rtsp://camera.local/stream")

// JavaScript/Node.js integration
const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

class HarpoonClient {
    constructor(apiUrl, apiKey) {
        this.apiUrl = apiUrl;
        this.headers = { Authorization: `Bearer ${apiKey}` };
    }
    
    async detectDrones(imagePath, confidence = 0.6) {
        const formData = new FormData();
        formData.append('image', fs.createReadStream(imagePath));
        formData.append('confidence', confidence);
        
        try {
            const response = await axios.post(
                `${this.apiUrl}/detect`,
                formData,
                {
                    headers: {
                        ...this.headers,
                        ...formData.getHeaders()
                    }
                }
            );
            
            return response.data;
        } catch (error) {
            console.error('Detection failed:', error.message);
            throw error;
        }
    }
    
    async streamDetection(wsUrl) {
        const WebSocket = require('ws');
        const ws = new WebSocket(wsUrl, {
            headers: this.headers
        });
        
        ws.on('message', (data) => {
            const detection = JSON.parse(data);
            this.handleDetection(detection);
        });
        
        return ws;
    }
    
    handleDetection(detection) {
        if (detection.confidence > 0.7) {
            // Send alert to security system
            this.sendSecurityAlert(detection);
        }
        
        // Update monitoring dashboard
        this.updateDashboard(detection);
    }
}

// Usage
const client = new HarpoonClient('http://localhost:8080', 'your-api-key');
client.detectDrones('./camera_frame.jpg').then(console.log);

# Lightweight API server for system integration
# Perfect for adding to existing surveillance systems

# Pull and run API server
docker run -d -p 8080:8080 \
  --name harpoon-api \
  christiankhoury05/harpoon-model-api:1.1

# Test the API
curl -X POST -F "file=@drone_image.jpg" \
  http://localhost:8080/detect

# Response format:
# {
#   "detections": [
#     {
#       "bbox": [x1, y1, x2, y2],
#       "confidence": 0.94,
#       "class": "drone"
#     }
#   ],
#   "inference_time": 83.2,
#   "image_size": [640, 640]
# }

# Health check
curl http://localhost:8080/health

# Custom integration using Harpoon as base
FROM christiankhoury05/harpoon-model-api:1.1

# Add your custom security system integration
COPY security_integration.py /app/
COPY alert_system.py /app/
COPY config.yaml /app/config/

# Install additional dependencies
RUN pip install pika redis celery

# Custom startup script
COPY start_custom.sh /app/
RUN chmod +x /app/start_custom.sh

# Environment variables for your system
ENV ALERT_WEBHOOK_URL=""
ENV REDIS_URL="redis://localhost:6379"
ENV SECURITY_SYSTEM_API=""

# Custom entrypoint
CMD ["/app/start_custom.sh"]