단속 카메라: 데이터셋 하나, 작성자 하나

extension CameraDataset {
  public static let policeSource = "National Police Agency standard dataset 15028200 (data.go.kr)"

  /// The bundled dataset from a full pull: driving-relevant cameras only,
  /// each with an id unique across providers (the management number repeats
  /// between and even within institutions).
  public static func build(rows: [PoliceCameraRow], fetchedAt: String) -> CameraDataset {
    var seen: [String: Int] = [:]
    var cameras: [SpeedCamera] = []
    for row in rows {
      let base = [row.insttCode, row.mnlssRegltCameraManageNo].compactMap(PoliceCameraRow.text).joined(separator: "-")
      let count = seen[base, default: 0]
      seen[base] = count + 1
      let id = count == 0 ? base : "\(base)-\(count)"
      guard let camera = row.camera(id: id), camera.isDrivingRelevant else { continue }
      cameras.append(camera)
    }
    let dates = cameras.compactMap(\.referenceDate).sorted()
    return CameraDataset(
      source: "\(policeSource): \(cameras.count) driving-relevant of \(rows.count) rows",
      datasetModified: nil, fetchedAt: fetchedAt, newestReferenceDate: dates.last,
      oldestReferenceDate: dates.first, cameras: cameras)
  }
}

    var found: [CameraOnRoute] = []
    for (index, seen) in candidates {
      let camera = cameras[index]
      let window = (seen.lowerBound - Self.projectionReach)...(seen.upperBound + Self.projectionReach)
      guard camera.isDrivingRelevant,
        let match = polyline.project(camera.coordinate, within: window), match.lateral <= corridor
      else { continue }
      let side = Self.signedSide(of: camera.coordinate, from: match)
      if side < -leftTolerance { continue }
      found.append(CameraOnRoute(camera: camera, along: match.distanceAlong, lateral: match.lateral))
    }
    return found.sorted { $0.along < $1.along }
  }

  /// Signed cross-track distance: positive to the right of the direction of
  /// travel, negative to the left.
  static func signedSide(of point: Coordinate, from match: Polyline.Match) -> Double {
    let frame = Geo.LocalFrame(origin: match.coordinate)
    let (px, py) = frame.project(point)
    let heading = match.bearing * .pi / 180
    // Unit vector of travel (east = sin, north = cos); right-hand normal.
    let rightX = cos(heading)
    let rightY = -sin(heading)
    return px * rightX + py * rightY
  }

import Foundation

// A minimal sketch of Pathfinder's driving-side rule in a flat local frame
// (x east, y north, metres). The points are synthetic, not real cameras.
struct Point { var x: Double; var y: Double }

/// Signed cross-track distance: positive to the right of travel, negative to
/// the left (the same right-hand normal CameraIndex.signedSide uses).
func signedSide(of p: Point, from foot: Point, bearing degrees: Double) -> Double {
  let heading = degrees * .pi / 180
  let (px, py) = (p.x - foot.x, p.y - foot.y)
  return px * cos(heading) + py * -sin(heading)
}

func verdict(_ camera: Point, foot: Point, bearing: Double,
             corridor: Double = 30, leftTolerance: Double = 10) -> String {
  let lateral = hypot(camera.x - foot.x, camera.y - foot.y)
  guard lateral <= corridor else { return "not on this road (\(Int(lateral)) m off)" }
  let side = signedSide(of: camera, from: foot, bearing: bearing)
  if side < -leftTolerance { return "other carriageway (\(Int(side)) m)" }
  return "on the route (side \(Int(side)) m)"
}

// A road running due north (bearing 0) along x = 0; the foot of each camera
// is the closest point on the road.
let northbound: [(String, Point)] = [
  ("pole on the right shoulder", Point(x: 7, y: 120)),
  ("gantry over the median", Point(x: -4, y: 310)),
  ("pole across the median", Point(x: -18, y: 540)),
  ("camera on a side street", Point(x: 55, y: 800)),
]
for (name, camera) in northbound {
  print("north", name.padding(toLength: 28, withPad: " ", startingAt: 0),
        verdict(camera, foot: Point(x: 0, y: camera.y), bearing: 0))
}

// The same pole seen from the opposite direction (bearing 180) is on the right.
let pole = Point(x: -18, y: 540)
print("south", "pole across the median".padding(toLength: 28, withPad: " ", startingAt: 0),
      verdict(pole, foot: Point(x: 0, y: 540), bearing: 180))

// Output:
// north pole on the right shoulder   on the route (side 7 m)
// north gantry over the median       on the route (side -4 m)
// north pole across the median       other carriageway (-18 m)
// north camera on a side street      not on this road (55 m off)
// south pole across the median       on the route (side 18 m)