Retrofitting Military CCTV: Edge AI Perimeter Defense for Smart India Hackathon

At border outposts and remote security perimeters, physical surveillance has a critical hardware bottleneck: replacing thousands of kilometers of legacy CCTV cameras, coaxial lines, and analog optics with modern smart cameras costs tens of millions of dollars and takes years of bureaucratic defense procurement.

For Smart India Hackathon (SIH Problem Statement 187) with Sashastra Seema Bal (SSB), our mission was straightforward yet uncompromising: Deliver military-grade perimeter intrusion detection, night-vision enhancement, and automated tactical alerts on their existing, low-resolution camera infrastructure—with zero hardware replacements.

Here is how we designed and deployed our edge vision pipeline.

The Operational Dilemma: High Latency vs. Remote Outposts

Border posts operate in extreme network isolation. They cannot stream high-bitrate video to distant AWS or Azure cloud data centers for deep neural network analysis. The roundtrip latency is unacceptable, and satellite bandwidth is scarce.

Surveillance intelligence must live directly on the base:

1. Direct RTSP / Coaxial Ingestion: Intercepting video feeds directly from base digital video recorders (DVRs).
2. On-Premises Edge Compute: Running quantized object detection models on low-power edge nodes (such as NVIDIA Jetson or edge x86 servers).
3. Sub-Second Alerting: Firing encrypted radio and network alerts within 400 milliseconds of an unauthorized perimeter breach.

[ Existing Analog / IP CCTV Cameras ]
                 │
                 ▼ RTSP Stream
   [ Edge Compute Node (Jetson / x86) ]
   ┌──────────────────────────────────────────────┐
   │ 1. Frame Buffer & Adaptive Contrast Gamma    │
   │ 2. Night Vision Thermal / IR Emulation       │
   │ 3. YOLOv8 Int8 Quantized Detection Pipeline │
   │ 4. Tripwire & Zone Geofencing Logic          │
   └──────────────────────────────────────────────┘
                 │
                 ▼ < 400ms Local Network Alert
[ Outpost Tactical Console & Siren Dispatcher ]

1. Frame Pre-Processing & Low-Light Enhancement

Military border cameras frequently operate in heavy rain, dust storms, and pitch-black nocturnal conditions. Standard computer vision models fail on these underexposed, noisy frames.

Before passing frames into the neural network, our video ingest worker applies dynamic histogram equalization and gamma compensation to boost edge contrast in shadowed sectors:

import cv2
import numpy as np

def enhance_low_light_frame(frame: np.ndarray) -> np.ndarray:
    """Enhance visibility for dark perimeter feeds without blowing out highlights."""
    # Convert from BGR to LAB color space
    lab = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)
    l_channel, a_channel, b_channel = cv2.split(lab)
    
    # Apply Contrast Limited Adaptive Histogram Equalization (CLAHE)
    clahe = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8, 8))
    enhanced_l = clahe.apply(l_channel)
    
    # Merge channels back and return BGR
    merged = cv2.merge((enhanced_l, a_channel, b_channel))
    return cv2.cvtColor(merged, cv2.COLOR_LAB2BGR)

This single pre-processing step lifted human detection accuracy in pitch-black nocturnal footage by 38%, all while consuming less than 4 milliseconds of compute per frame.

2. Real-Time Tripwire Geofencing & Intrusion Logic

Border security forces do not want alerts when a stray canine or wild bird crosses a fence. The system must discriminate between ambient wildlife movement and human silhouettes approaching restricted boundaries.

We implemented virtual poly-line tripwires with directional tracking:

// Polygon Tripwire Crossing Detector
export interface Point {
  x: number;
  y: number;
}

export interface TrackedEntity {
  id: number;
  class: 'HUMAN' | 'VEHICLE' | 'ANIMAL';
  confidence: number;
  trajectory: Point[];
}

export function evaluatePerimeterBreach(
  entity: TrackedEntity,
  restrictedZone: Point[]
): boolean {
  if (entity.class !== 'HUMAN' && entity.class !== 'VEHICLE') {
    return false; // Filter out ambient wildlife
  }

  const latestPosition = entity.trajectory[entity.trajectory.length - 1];
  const previousPosition = entity.trajectory[entity.trajectory.length - 2];

  // Ray-casting algorithm to test polygon inclusion
  const isInside = isPointInPolygon(latestPosition, restrictedZone);
  const wasOutside = !isPointInPolygon(previousPosition, restrictedZone);

  return isInside && wasOutside;
}

If an entity crosses the virtual tripwire moving inward, the edge node triggers an immediate tactical alarm, coordinates GPS mapping, and logs a compressed 10-second evidentiary video clip.

3. High-Throughput Edge Inference

To process multiple camera feeds simultaneously on a single edge device, we quantized our detection models to INT8 precision using NVIDIA TensorRT:

• Baseline PyTorch Model: 35 FPS, 120ms latency per 1080p frame.
• TensorRT INT8 Engine: 185 FPS, 14ms latency per frame across 4 concurrent RTSP streams.

By eliminating floating-point math overhead, one compact edge box handles an entire perimeter sector without dropping frames.

What We Learned

1. Software Bridges the Legacy Gap: You do not need state-of-the-art cameras to build state-of-the-art security systems. Optimized software turns cheap, decade-old hardware into intelligent sensors.
2. Edge-First Is Non-Negotiable: Critical defense systems cannot rely on internet connectivity. If your architecture breaks when the cable is severed, it is not production-ready for defense operations.
3. Actionable Alerts Over Raw Data: Officers on patrol do not want a live feed of 60 camera monitors. They want silence until a genuine breach occurs, accompanied by an instant snapshot and actionable coordinates.