reverb-m1

CalibrationChecks.swift (5410B)

---

 import Foundation
 import simd
 func check(_ ok: Bool, _ what: String) { print(ok ? "PASS" : "FAIL", what); if !ok { exit(1) } }
 func near(_ a: Double, _ b: Double, _ eps: Double = 1e-9) -> Bool { abs(a - b) <= eps }
 
 /// 3x3 identity mixing matrix, 4 temperature coefficients per entry (constant term first).
 func identityMixModel() -> [Double] {
     var v: [Double] = []
     for i in 0 ..< 9 { v += [i % 4 == 0 ? 1 : 0, 0, 0, 0] }
     return v
 }
 
 /// Synthetic G1-like panel: 4320x2160, eye centers in each half, focal ~1000 px, mild positive k1.
 func fixtureJSON(k1: Double, chroma: Double = 0) -> Data {
     func display(_ eye: String, _ cx: Double, _ tx: Double) -> [String: Any] {
         let f = 1000.0
         let affine = [f, 0, cx, 0, f, 1080, 0, 0, 1] // tangent-plane -> pixels; inverse maps pixels -> tangents
         func dist(_ k: Double) -> [String: Any] {
             ["ModelType": "CALIBRATION_DisplayDistortionModelPolynomial3K", "ModelParameterCount": 5,
              "ModelParameters": [cx, 1080, k, 0, 0]]
         }
         return ["AssignedEye": eye, "Affine": affine, "DisplayWidth": 4320, "DisplayHeight": 2160,
                 "VisibleAreaCenter": ["X": cx, "Y": 1080], "VisibleAreaRadius": 1050,
                 "Rt": ["Rotation": [1, 0, 0, 0, 1, 0, 0, 0, 1], "Translation": [tx, 0, 0]],
                 "DistortionRed": dist(k1 * (1 + chroma)), "DistortionGreen": dist(k1), "DistortionBlue": dist(k1 * (1 - chroma))]
     }
     let gyro: [String: Any] = ["SensorType": "CALIBRATION_InertialSensorType_Gyro",
                                "Rt": ["Rotation": [0, 1, 0, -1, 0, 0, 0, 0, 1], "Translation": [0, 0, 0]],
                                "BiasTemperatureModel": [0.01, 0, 0, 0, 0.02, 0, 0, 0, 0.03, 0, 0, 0],
                                "MixingMatrixTemperatureModel": identityMixModel()]
     let root: [String: Any] = ["CalibrationInformation": [
         "Displays": [display("CALIBRATION_DisplayEyeLeft", 1080, -0.0315), display("CALIBRATION_DisplayEyeRight", 3240, 0.0315)],
         "InertialSensors": [gyro], "Cameras": [] as [Any]]]
     return try! JSONSerialization.data(withJSONObject: root)
 }
 
 @main
 struct CalibrationChecks {
 static func main() {
 
 do {
     check(wmrConfigKey.count == 1024 && wmrConfigKey.prefix(4) == [0x2F, 0xC8, 0x0F, 0x38], "key: 1024 bytes, upstream prefix")
     check(WMRConfigProtocol.request(0x0b) == [0x02, 0x0b] + [UInt8](repeating: 0, count: 62), "request layout")
     var chunk = [UInt8](repeating: 0, count: 33); chunk[0] = 2; chunk[1] = 1; chunk[2] = 3; chunk[3] = 7; chunk[4] = 8; chunk[5] = 9
     check(WMRConfigProtocol.parseChunk(chunk) == .data([7, 8, 9]), "chunk reply parse")
     chunk[1] = 2; check(WMRConfigProtocol.parseChunk(chunk) == .end, "end reply parse")
     check(WMRConfigProtocol.dataSize(fromMetadata: [0x34, 0x12]) == 0x1234, "metadata size LE")
 
     // 1. Block round trip: encode synthetic JSON like the headset store, decode it back.
     let json = fixtureJSON(k1: 0)
     let block = try WMRConfigBlock(raw: WMRConfigBlock.encodeForTesting(json: json))
     check(block.json == json && block.name == "Test Headset", "config block XOR/header round trip")
 
     // 2. Parse and identity model: k = 0 and a pure scale affine => sample coords equal output coords.
     let cal = try HeadsetCalibration(json: block.json)
     check(cal.eyes.count == 2 && cal.sensors.count == 1 && cal.sensors[0].kind == .gyro, "parse displays + gyro")
     check(near(EyeCalibration.ipd(cal.eyes[0], cal.eyes[1]), 0.063), "IPD from Rt translations")
     check(near(cal.sensors[0].biasOffsets.y, 0.02), "gyro bias constant terms")
     for view in 0 ..< 2 {
         let eye = cal.eyes[view], b = eye.distortionBounds(view: view)
         check(near(b.texXRange.x, -1.08) && near(b.texXRange.y, 1.08) && near(b.texYRange.x, -1.08) && near(b.texYRange.y, 1.08),
               "view \(view): identity bounds = +-1080/1000")
         for (u, v) in [(0.0, 0.0), (0.5, 0.5), (0.25, 0.8), (1.0, 1.0)] {
             let s = eye.distort(view: view, u: u, v: v, bounds: b)
             check(near(s.g.x, u, 1e-9) && near(s.g.y, v, 1e-9) && s.r == s.g && s.b == s.g, "view \(view) identity (\(u), \(v))")
         }
     }
 
     // 3. Barrel/pincushion behaviour: k1 > 0 pushes edge samples outward, centre unchanged, symmetric.
     let k1 = 1e-7
     let cal2 = try HeadsetCalibration(json: fixtureJSON(k1: k1, chroma: 0.05))
     let eye = cal2.eyes[0], b = eye.distortionBounds(view: 0)
     let centre = eye.distort(view: 0, u: 0.5, v: 0.5, bounds: b)
     check(near(centre.g.x, 0.5) && near(centre.g.y, 0.5), "k1>0: centre maps to centre")
     let edge = eye.distort(view: 0, u: 0.9, v: 0.5, bounds: b), mirror = eye.distort(view: 0, u: 0.1, v: 0.5, bounds: b)
     check(near(edge.g.x + mirror.g.x, 1, 1e-9), "k1>0: left/right symmetric")
     // Hand-computed expectation for u = 0.9: pix.x = 864, d = 1 + k1 * 864^2, tangent = 864 * d / 1000.
     let d = 1 + k1 * 864 * 864, tan = 864 * d / 1000
     check(near(edge.g.x, (tan - b.texXRange.x) / (b.texXRange.y - b.texXRange.x), 1e-12), "k1>0: matches hand calculation")
     check(edge.r.x > edge.g.x && edge.b.x < edge.g.x, "chromatic: red samples farther out than green, blue nearer")
     check(b.angleLeft < 0 && b.angleRight > 0 && b.angleUp > 0 && b.angleDown < 0, "bounds -> asymmetric FOV angles")
     print("all calibration self-tests passed")
 } catch {
     print("FAIL", error); exit(1)
 }
 
 }
 }