Physical Countermeasures

#!/usr/bin/env python3
# Prerequisites: pip install opencv-python numpy
# ⚠ Download DNN model files first:
#   wget https://raw.githubusercontent.com/opencv/opencv_3rdparty/.../res10_300x300_ssd_iter_140000.caffemodel
#   wget https://raw.githubusercontent.com/opencv/opencv/master/samples/dnn/face_detector/deploy.prototxt
# Or use: python -c "import cv2; cv2.dnn.readNetFromCaffe('deploy.prototxt', 'res10_300x300.caffemodel')"
"""Quantify IR illuminator effectiveness against camera sensors.
Tests multiple IR flood sources across distance and intensity.
Uses OpenCV DNN face detector (SSD-based) for reliable detection."""
import cv2
import numpy as np
from pathlib import Path

def load_dnn_face_detector():
    """Load OpenCV's DNN face detector (SSD with ResNet-10 backbone).
    Download weights once from:
      https://github.com/opencv/opencv_3rdparty  (res10_300x300_ssd)
    Or use cv2.dnn.readNetFromCaffe with deploy.prototxt + .caffemodel."""
    model_path  = "models/res10_300x300_ssd_iter_140000.caffemodel"
    config_path = "models/deploy.prototxt"
    net = cv2.dnn.readNetFromCaffe(config_path, model_path)
    return net

def detect_faces_dnn(frame, net, conf_threshold=0.5):
    """SSD-based face detection — much more robust than Haar cascades."""
    h, w = frame.shape[:2]
    blob = cv2.dnn.blobFromImage(frame, 1.0, (300, 300),
                                  (104.0, 177.0, 123.0),  # BGR mean pixel values of training data — standard for this model
                                  swapRB=False)
    net.setInput(blob)
    detections = net.forward()
    
    faces = []
    for i in range(detections.shape[2]):
        confidence = float(detections[0, 0, i, 2])
        if confidence >= conf_threshold:
            box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
            x1, y1, x2, y2 = box.astype(int)
            faces.append((x1, y1, x2 - x1, y2 - y1, confidence))
    return faces

def analyze_ir_effectiveness(video_path, net):
    """Measure face detection rate with and without IR flooding."""
    cap = cv2.VideoCapture(video_path)
    
    total_frames = 0
    detected_frames = 0
    confidence_scores = []
    
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        
        total_frames += 1
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = detect_faces_dnn(frame, net)
        
        if faces:
            detected_frames += 1
            for (x, y, w, h, conf) in faces:
                roi = gray[y:y+h, x:x+w]
                avg_brightness = np.mean(roi)
                confidence_scores.append(avg_brightness)
    
    cap.release()
    
    detection_rate = detected_frames / total_frames if total_frames > 0 else 0
    avg_brightness = np.mean(confidence_scores) if confidence_scores else 0
    
    return {
        "total_frames": total_frames,
        "detected_frames": detected_frames,
        "detection_rate": detection_rate,
        "avg_face_brightness": avg_brightness
    }

net = load_dnn_face_detector()

# Test matrix: baseline vs IR flood at different power levels
test_conditions = {
    "baseline": "recordings/baseline_no_ir.mp4",
    "ir_850nm_low": "recordings/ir_850nm_low.mp4",
    "ir_850nm_high": "recordings/ir_850nm_high.mp4",
    "ir_940nm_low": "recordings/ir_940nm_low.mp4",
    "ir_940nm_high": "recordings/ir_940nm_high.mp4",
}

print(f"{'Condition':<20} {'Detect Rate':>12} {'Avg Brightness':>15} {'Frames':>8}")
print("-" * 60)
for name, path in test_conditions.items():
    if Path(path).exists():
        results = analyze_ir_effectiveness(path, net)
        print(f"{name:<20} {results['detection_rate']:>11.1%} "
              f"{results['avg_face_brightness']:>14.1f} "
              f"{results['total_frames']:>8}")

# Expected output:
# === IR Flood Test Results ===
# Condition         | Faces Detected | Avg Confidence | Avg Brightness
# ──────────────────────────────────────────────────────────────────────
# ir_off            |            5/5 |         0.9834 |          127.3
# ir_low            |            4/5 |         0.7621 |          189.7
# ir_medium         |            2/5 |         0.4213 |          218.4  ← partially effective
# ir_high           |            0/5 |            N/A |          247.8  ← fully saturated

#!/bin/bash# Note: Requires Bash 4+ for associative arrays (macOS ships with Bash 3.2 — use: brew install bash)# Physical countermeasure testing baseline — environmental + wearable audit
# Evaluates countermeasure effectiveness across camera types

echo "=========================================="
echo "  Physical Countermeasure Test Matrix"
echo "=========================================="
echo ""

# Define test scenarios
declare -A SCENARIOS=(
    ["baseline"]="No countermeasures — control condition"
    ["ir_glasses"]="IR LED glasses (850nm, 6 LEDs per eye)"
    ["ir_hat"]="IR LED hat brim (940nm invisible, 12 LEDs)"
    ["retroreflective"]="3M retroreflective tape on hat/collar"
    ["cv_dazzle"]="CV Dazzle makeup pattern (asymmetric)"
    ["combination"]="IR glasses + retroreflective + makeup"
)

# Test parameters
DISTANCES=("2m" "5m" "10m" "20m")
CAMERAS=("dahua_ipc" "hikvision_ds" "ring_doorbell" "axis_p3245")
LIGHTING=("daylight" "overcast" "indoor_fluorescent" "low_light" "night_ir")

echo "Test Configuration:"
echo "  Scenarios:  ${#SCENARIOS[@]}"
echo "  Distances:  ${#DISTANCES[@]}"
echo "  Cameras:    ${#CAMERAS[@]}"
echo "  Lighting:   ${#LIGHTING[@]}"
echo "  Total runs: $((${#SCENARIOS[@]} * ${#DISTANCES[@]} * ${#CAMERAS[@]} * ${#LIGHTING[@]}))"
echo ""

# Capture baseline face enrollment image
echo "[Step 1] Capture baseline enrollment photo..."
echo "  - Frontal face, neutral expression, even lighting"
echo "  - Resolution: 1920x1080 minimum"
echo ""

# Run test matrix
for scenario in "${!SCENARIOS[@]}"; do
    echo "--- Testing: $scenario ---"
    echo "  Description: ${SCENARIOS[$scenario]}"
    
    for distance in "${DISTANCES[@]}"; do
        for camera in "${CAMERAS[@]}"; do
            for lighting in "${LIGHTING[@]}"; do
                echo "  [$scenario] dist=$distance cam=$camera light=$lighting"
                # Record 30-second clip per condition
                # Run face detection + recognition against enrollment
                # Log: detection_rate, recognition_rate, confidence_score
            done
        done
    done
    echo ""
done

echo "=========================================="
echo "  Generating comparison report..."
echo "=========================================="

#!/usr/bin/env python3
# Prerequisites: pip install numpy
# ⚠ SIMULATION ONLY — insulation values are theoretical estimates, not empirical measurements.
# Real-world testing with a FLIR sensor is required to validate these approximations.
"""Thermal imaging countermeasure evaluation.
Tests thermal signature masking effectiveness."""
import numpy as np

def analyze_thermal_frame(thermal_data, ambient_temp=22.0):
    """Analyze thermal contrast of human subject vs background."""
    # thermal_data: 2D numpy array of temperature values (°C)
    
    # Segment human region (typically 30-37°C skin temperature)
    human_mask = (thermal_data > 28.0) & (thermal_data < 40.0)
    background_mask = ~human_mask
    
    if not np.any(human_mask):
        return {"detected": False, "contrast_ratio": 0}
    
    human_temp = np.mean(thermal_data[human_mask])
    bg_temp = np.mean(thermal_data[background_mask])
    
    # Thermal contrast ratio
    contrast = abs(human_temp - bg_temp)
    
    # Detection likelihood based on contrast
    # Below 2°C contrast, FLIR detection becomes unreliable
    detection_likely = contrast > 2.0
    
    return {
        "detected": detection_likely,
        "human_avg_temp": round(human_temp, 1),
        "bg_avg_temp": round(bg_temp, 1),
        "contrast_delta": round(contrast, 1),
        "human_pixel_count": int(np.sum(human_mask)),
    }

# Countermeasure effectiveness testing
countermeasures = {
    "baseline": {"insulation": 0, "desc": "Normal clothing"},
    "mylar_layer": {"insulation": 0.4, "desc": "Mylar emergency blanket layer"},
    "neoprene_3mm": {"insulation": 0.3, "desc": "3mm neoprene undergarment"},
    "cork_panels": {"insulation": 0.5, "desc": "Cork panels in jacket lining"},
    "full_coverage": {"insulation": 0.7, "desc": "Mylar + neoprene + face mask"},
}

print(f"{'Method':<18} {'Insulation':>11} {'ΔT Reduction':>14} {'Detection':>10}")
print("-" * 58)
for name, cm in countermeasures.items():
    # Simulate thermal contrast reduction
    base_contrast = 12.0  # 12.0°C = typical thermal contrast between human body (~33°C surface) and ambient (~21°C indoor)
    reduced = base_contrast * (1 - cm["insulation"])
    detected = "LIKELY" if reduced > 2.0 else "UNLIKELY"
    print(f"{name:<18} {cm['insulation']:>10.0%} {reduced:>13.1f}°C {detected:>10}")