security_surveillance_advanced.mbt

// 安防监控高级（v58.0.0）
// 入侵检测、人脸识别、行为分析、人群分析、车牌识别、异常事件检测

///|
/// 安防监控任务类型
pub(all) enum SecuritySurveillanceTaskType {
  IntrusionDetection
  FaceRecognition
  BehaviorAnalysis
  CrowdAnalysis
  LicensePlateRecognition
  AnomalyEventDetection
  ObjectTracking
  Unknown
} derive(Eq)

///|
/// 入侵类型
pub(all) enum IntrusionType {
  PerimeterBreach
  AreaEntry
  LineCrossing
  Loitering
  ObjectLeft
  ObjectRemoved
  Unknown
} derive(Eq)

///|
/// 行为类型
pub(all) enum BehaviorType {
  Walking
  Running
  Falling
  Fighting
  Aggressive
  Suspicious
  Crowding
  Panic
  Unknown
} derive(Eq)

///|
/// 警报级别
pub(all) enum AlertLevel {
  Info
  Warning
  Critical
  Emergency
  Unknown
} derive(Eq)

///|
/// 检测到的人员
pub(all) struct DetectedPerson {
  person_id : Int
  bounding_box : Array[Int]
  confidence : Double
  face_embedding : Array[Double]
  body_embedding : Array[Double]
  velocity : Array[Double]
  trajectory : Array[Array[Int]]
  age_estimate : Int
  gender_estimate : String
  is_known : Bool
  identity : String
}

///|
/// 入侵事件
pub(all) struct IntrusionEvent {
  event_id : Int
  intrusion_type : IntrusionType
  timestamp : Double
  location : Array[Double]
  bounding_box : Array[Int]
  confidence : Double
  alert_level : AlertLevel
  person_id : Int
  is_acknowledged : Bool
  video_clip_start : Double
  video_clip_end : Double
}

///|
/// 行为分析结果
pub(all) struct BehaviorAnalysisResult {
  person_id : Int
  behavior_type : BehaviorType
  confidence : Double
  timestamp : Double
  duration : Double
  location : Array[Double]
  is_suspicious : Bool
  risk_score : Double
}

///|
/// 人群分析结果
pub(all) struct CrowdAnalysisResult {
  num_people : Int
  density : Double
  density_map : Array[Array[Double]]
  crowd_direction : Array[Double]
  crowd_speed : Double
  is_overcrowded : Bool
  panic_level : Double
  hotspots : Array[Array[Double]]
  num_hotspots : Int
}

///|
/// 车牌识别结果
pub(all) struct LicensePlateResult {
  plate_number : String
  confidence : Double
  bounding_box : Array[Int]
  vehicle_type : String
  vehicle_color : String
  plate_color : String
  plate_type : String
  timestamp : Double
  is_valid : Bool
}

///|
/// 异常事件
pub(all) struct AnomalyEvent {
  event_id : Int
  event_type : String
  description : String
  timestamp : Double
  location : Array[Double]
  confidence : Double
  alert_level : AlertLevel
  affected_people : Array[Int]
  num_affected_people : Int
  is_verified : Bool
  video_clip_url : String
}

///|
/// 安防监控配置
pub(all) struct SecuritySurveillanceConfig {
  task_type : SecuritySurveillanceTaskType
  detection_threshold : Double
  recognition_threshold : Double
  alert_threshold : Double
  intrusion_zones : Array[Array[Int]]
  tripwires : Array[Array[Int]]
  loitering_time : Double
  min_person_size : Int
  max_person_size : Int
  use_face_recognition : Bool
  use_behavior_analysis : Bool
  use_crowd_analysis : Bool
  use_license_plate : Bool
  alert_cooldown : Double
  auto_alert : Bool
  recording_on_alert : Bool
  num_cameras : Int
  fps : Int
}

///|
/// 创建默认安防监控配置
pub fn create_default_security_config() -> SecuritySurveillanceConfig {
  SecuritySurveillanceConfig::{
    task_type: SecuritySurveillanceTaskType::IntrusionDetection,
    detection_threshold: 0.5,
    recognition_threshold: 0.7,
    alert_threshold: 0.8,
    intrusion_zones: [],
    tripwires: [],
    loitering_time: 30.0,
    min_person_size: 50,
    max_person_size: 1000,
    use_face_recognition: true,
    use_behavior_analysis: true,
    use_crowd_analysis: true,
    use_license_plate: false,
    alert_cooldown: 10.0,
    auto_alert: true,
    recording_on_alert: true,
    num_cameras: 1,
    fps: 15,
  }
}

///|
/// 检测人员（简化版）
pub fn detect_people(
  image : Array[Double],
  width : Int,
  height : Int,
  config : SecuritySurveillanceConfig,
) -> Array[DetectedPerson] {
  ignore(config)
  ignore(image)
  let people : Array[DetectedPerson] = []

  let mut state = 42
  let num_people = 5

  for i in 0..<num_people {
    state = ((state * 11035 + 12345).reinterpret_as_uint() % 1000000).reinterpret_as_int()
    let x = state % (width - 200)
    state = ((state * 11035 + 12345).reinterpret_as_uint() % 1000000).reinterpret_as_int()
    let y = state % (height - 400)
    state = ((state * 11035 + 12345).reinterpret_as_uint() % 1000000).reinterpret_as_int()
    let w = state % 100 + 80
    state = ((state * 11035 + 12345).reinterpret_as_uint() % 1000000).reinterpret_as_int()
    let h = state % 200 + 150
    state = ((state * 11035 + 12345).reinterpret_as_uint() % 1000000).reinterpret_as_int()
    let confidence = (state % 1000).to_double() / 1000.0 * 0.3 + 0.7

    let bbox : Array[Int] = []
    bbox.push(x)
    bbox.push(y)
    bbox.push(x + w)
    bbox.push(y + h)

    let face_embedding : Array[Double] = []
    let body_embedding : Array[Double] = []
    for _ in 0..<128 {
      state = ((state * 11035 + 12345).reinterpret_as_uint() % 1000000).reinterpret_as_int()
      face_embedding.push((state % 1000).to_double() / 1000.0 - 0.5)
      state = ((state * 11035 + 12345).reinterpret_as_uint() % 1000000).reinterpret_as_int()
      body_embedding.push((state % 1000).to_double() / 1000.0 - 0.5)
    }

    let person = DetectedPerson::{
      person_id: i,
      bounding_box: bbox,
      confidence,
      face_embedding,
      body_embedding,
      velocity: [0.0, 0.0],
      trajectory: [],
      age_estimate: 30,
      gender_estimate: "unknown",
      is_known: false,
      identity: "unknown",
    }
    people.push(person)
  }

  people
}

///|
/// 检测入侵（简化版）
pub fn detect_intrusion(
  people : Array[DetectedPerson],
  intrusion_zone : Array[Int],
  config : SecuritySurveillanceConfig,
) -> Array[IntrusionEvent] {
  let events : Array[IntrusionEvent] = []

  for person in people {
    let bbox = person.bounding_box
    let cx = (bbox[0] + bbox[2]) / 2
    let cy = (bbox[1] + bbox[3]) / 2

    // 检查是否在入侵区域内
    let in_zone = cx >= intrusion_zone[0] &&
      cx <= intrusion_zone[2] &&
      cy >= intrusion_zone[1] &&
      cy <= intrusion_zone[3]

    if in_zone && person.confidence > config.detection_threshold {
      let alert_level = if person.confidence > config.alert_threshold {
        AlertLevel::Critical
      } else if person.confidence > 0.7 {
        AlertLevel::Warning
      } else {
        AlertLevel::Info
      }

      let event = IntrusionEvent::{
        event_id: events.length(),
        intrusion_type: IntrusionType::AreaEntry,
        timestamp: 0.0,
        location: [cx.to_double(), cy.to_double()],
        bounding_box: bbox,
        confidence: person.confidence,
        alert_level,
        person_id: person.person_id,
        is_acknowledged: false,
        video_clip_start: -5.0,
        video_clip_end: 10.0,
      }
      events.push(event)
    }
  }

  events
}

///|
/// 分析行为（简化版）
pub fn analyze_behavior(
  person : DetectedPerson,
  config : SecuritySurveillanceConfig,
) -> BehaviorAnalysisResult {
  ignore(config)
  // 简化的行为分析：基于速度
  let speed = person.velocity[0] * person.velocity[0] +
    person.velocity[1] * person.velocity[1]

  let behavior_type = if speed > 5.0 {
    BehaviorType::Running
  } else if speed > 2.0 {
    BehaviorType::Walking
  } else if speed < 0.5 {
    BehaviorType::Suspicious
  } else {
    BehaviorType::Walking
  }

  let is_suspicious = behavior_type == BehaviorType::Suspicious ||
    behavior_type == BehaviorType::Aggressive
  let risk_score = if is_suspicious { 0.8 } else { 0.2 }

  BehaviorAnalysisResult::{
    person_id: person.person_id,
    behavior_type,
    confidence: 0.75,
    timestamp: 0.0,
    duration: 5.0,
    location: [0.0, 0.0],
    is_suspicious,
    risk_score,
  }
}

///|

///|
/// 分析人群（简化版）
pub fn analyze_crowd(
  people : Array[DetectedPerson],
  width : Int,
  height : Int,
  config : SecuritySurveillanceConfig,
) -> CrowdAnalysisResult {
  ignore(config)
  let num_people = people.length()
  let area = width.to_double() * height.to_double()
  let density = num_people.to_double() / area * 10000.0

  let is_overcrowded = density > 1.0
  let panic_level = if is_overcrowded { 0.7 } else { 0.2 }

  CrowdAnalysisResult::{
    num_people,
    density,
    density_map: [],
    crowd_direction: [0.0, 0.0],
    crowd_speed: 0.5,
    is_overcrowded,
    panic_level,
    hotspots: [],
    num_hotspots: 0,
  }
}

///|
/// 识别车牌（简化版）
pub fn recognize_license_plate(
  image : Array[Double],
  width : Int,
  height : Int,
  config : SecuritySurveillanceConfig,
) -> LicensePlateResult {
  ignore(config)
  ignore(height)
  ignore(image)
  ignore(width)
  // 简化的车牌识别：生成虚拟车牌号
  let plate_chars = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
  let mut plate = ""

  let mut state = 42
  for i in 0..<7 {
    state = ((state * 11035 + 12345).reinterpret_as_uint() % 1000000).reinterpret_as_int()
    if i < 3 {
      let char_idx = state % 8
      plate = plate + plate_chars[char_idx].to_string()
    } else {
      plate = plate + (state % 10).to_string()
    }
  }

  LicensePlateResult::{
    plate_number: plate,
    confidence: 0.85,
    bounding_box: [100, 100, 300, 200],
    vehicle_type: "sedan",
    vehicle_color: "white",
    plate_color: "blue",
    plate_type: "standard",
    timestamp: 0.0,
    is_valid: true,
  }
}

///|
/// 生成安防监控报告
pub fn security_surveillance_report_to_string(
  task_type : SecuritySurveillanceTaskType,
  config : SecuritySurveillanceConfig,
  result_description : String,
) -> String {
  let mut report = "## 安防监控高级报告\n\n"

  report = report + "### 任务信息\n\n"
  report = report + "| 指标 | 值 |\n|------|------|\n"
  report = report +
    "| 任务类型 | " +
    (match task_type {
      SecuritySurveillanceTaskType::IntrusionDetection => "入侵检测"
      SecuritySurveillanceTaskType::FaceRecognition => "人脸识别"
      SecuritySurveillanceTaskType::BehaviorAnalysis => "行为分析"
      SecuritySurveillanceTaskType::CrowdAnalysis => "人群分析"
      SecuritySurveillanceTaskType::LicensePlateRecognition => "车牌识别"
      SecuritySurveillanceTaskType::AnomalyEventDetection =>
        "异常事件检测"
      SecuritySurveillanceTaskType::ObjectTracking => "目标跟踪"
      _ => "未知"
    }) +
    " |\n"
  report = report +
    "| 检测阈值 | " +
    config.detection_threshold.to_string() +
    " |\n"
  report = report +
    "| 识别阈值 | " +
    config.recognition_threshold.to_string() +
    " |\n"
  report = report +
    "| 警报阈值 | " +
    config.alert_threshold.to_string() +
    " |\n"
  report = report +
    "| 徘徊时间 | " +
    config.loitering_time.to_string() +
    " s |\n"
  report = report +
    "| 人脸识别 | " +
    (if config.use_face_recognition { "开启" } else { "关闭" }) +
    " |\n"
  report = report +
    "| 行为分析 | " +
    (if config.use_behavior_analysis { "开启" } else { "关闭" }) +
    " |\n"
  report = report +
    "| 人群分析 | " +
    (if config.use_crowd_analysis { "开启" } else { "关闭" }) +
    " |\n"
  report = report +
    "| 自动警报 | " +
    (if config.auto_alert { "开启" } else { "关闭" }) +
    " |\n"
  report = report +
    "| 摄像头数 | " +
    config.num_cameras.to_string() +
    " |\n"
  report = report + "| 帧率 | " + config.fps.to_string() + " fps |\n"

  report = report + "\n### 结果\n\n"
  report = report + result_description + "\n"

  report
}
src\process\security_surveillance_advanced\security_surveillance_advanced.mbt

81.32%
