@trillboards/edge-sdk 0.2.246 → 0.2.254
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/deploy/detector/README.md +15 -0
- package/deploy/detector/pyproject.toml +1 -1
- package/deploy/detector/tests/test_actor_tracking.py +136 -0
- package/deploy/detector/tests/test_actor_tracking_wire.py +11 -0
- package/deploy/detector/tests/test_face_identity.py +448 -0
- package/deploy/detector/tests/test_loader.py +28 -1
- package/deploy/detector/tests/test_registry.py +53 -0
- package/deploy/detector/trillboards_detector/_version.py +2 -2
- package/deploy/detector/trillboards_detector/actor_tracking.py +95 -9
- package/deploy/detector/trillboards_detector/face_contract.py +166 -0
- package/deploy/detector/trillboards_detector/face_identity.py +467 -0
- package/deploy/detector/trillboards_detector/loader.py +40 -0
- package/deploy/detector/trillboards_detector/registry.py +72 -2
- package/deploy/detector/trillboards_detector/server.py +48 -6
- package/deploy/detector/trillboards_detector/tasks.py +12 -1
- package/deploy/windows/build-windows.ps1 +1 -0
- package/deploy/windows/ci/test-detector-looks-field.ps1 +15 -3
- package/deploy/windows/ci/test-detector-reinstall.ps1 +173 -2
- package/deploy/windows/ci/test-main-stream-gpu-decode.ps1 +119 -0
- package/deploy/windows/ci/test-rollout-proofs.ps1 +3 -2
- package/deploy/windows/ensure-detector.ps1 +255 -0
- package/deploy/windows/install-update.ps1 +4 -3
- package/deploy/windows/stop-existing.ps1 +1 -0
- package/deploy/windows/trillboards-edge.cmd +10 -22
- package/dist/CloudSensingManager.d.ts +14 -0
- package/dist/CloudSensingManager.d.ts.map +1 -1
- package/dist/CloudSensingManager.js +51 -5
- package/dist/CloudSensingManager.js.map +1 -1
- package/dist/ConnectorStatusClient.d.ts +26 -1
- package/dist/ConnectorStatusClient.d.ts.map +1 -1
- package/dist/ConnectorStatusClient.js +9 -0
- package/dist/ConnectorStatusClient.js.map +1 -1
- package/dist/DetectorFields.d.ts +77 -1
- package/dist/DetectorFields.d.ts.map +1 -1
- package/dist/DetectorFields.js +34 -4
- package/dist/DetectorFields.js.map +1 -1
- package/dist/EdgeAgent.js +1 -1
- package/dist/FaceIdentity.d.ts +122 -0
- package/dist/FaceIdentity.d.ts.map +1 -0
- package/dist/FaceIdentity.js +256 -0
- package/dist/FaceIdentity.js.map +1 -0
- package/dist/FaceSightingUploader.d.ts +95 -0
- package/dist/FaceSightingUploader.d.ts.map +1 -0
- package/dist/FaceSightingUploader.js +214 -0
- package/dist/FaceSightingUploader.js.map +1 -0
- package/dist/FaceWatchLane.d.ts +297 -0
- package/dist/FaceWatchLane.d.ts.map +1 -0
- package/dist/FaceWatchLane.js +660 -0
- package/dist/FaceWatchLane.js.map +1 -0
- package/dist/FaceWatchPolicy.d.ts +154 -0
- package/dist/FaceWatchPolicy.d.ts.map +1 -0
- package/dist/FaceWatchPolicy.js +101 -0
- package/dist/FaceWatchPolicy.js.map +1 -0
- package/dist/LocalDetectorClient.d.ts +30 -0
- package/dist/LocalDetectorClient.d.ts.map +1 -1
- package/dist/LocalDetectorClient.js +72 -4
- package/dist/LocalDetectorClient.js.map +1 -1
- package/dist/MainStreamRing.d.ts +63 -1
- package/dist/MainStreamRing.d.ts.map +1 -1
- package/dist/MainStreamRing.js +101 -7
- package/dist/MainStreamRing.js.map +1 -1
- package/dist/NativeReadiness.d.ts +21 -2
- package/dist/NativeReadiness.d.ts.map +1 -1
- package/dist/NativeReadiness.js +32 -9
- package/dist/NativeReadiness.js.map +1 -1
- package/dist/OrderedReviewClient.d.ts +3 -0
- package/dist/OrderedReviewClient.d.ts.map +1 -1
- package/dist/OrderedReviewClient.js +3 -0
- package/dist/OrderedReviewClient.js.map +1 -1
- package/dist/ReviewPriority.d.ts +9 -0
- package/dist/ReviewPriority.d.ts.map +1 -1
- package/dist/ReviewPriority.js +6 -1
- package/dist/ReviewPriority.js.map +1 -1
- package/dist/ScopedVlmReview.d.ts +11 -2
- package/dist/ScopedVlmReview.d.ts.map +1 -1
- package/dist/ScopedVlmReview.js +43 -16
- package/dist/ScopedVlmReview.js.map +1 -1
- package/dist/SensingProfileClient.d.ts +14 -0
- package/dist/SensingProfileClient.d.ts.map +1 -1
- package/dist/SensingProfileClient.js +9 -0
- package/dist/SensingProfileClient.js.map +1 -1
- package/dist/TemporalReviewClient.d.ts +3 -0
- package/dist/TemporalReviewClient.d.ts.map +1 -1
- package/dist/TemporalReviewClient.js +3 -0
- package/dist/TemporalReviewClient.js.map +1 -1
- package/dist/UniformSceneStore.d.ts +6 -0
- package/dist/UniformSceneStore.d.ts.map +1 -1
- package/dist/UniformSceneStore.js +22 -1
- package/dist/UniformSceneStore.js.map +1 -1
- package/dist/VideoSegmentUploader.d.ts +11 -0
- package/dist/VideoSegmentUploader.d.ts.map +1 -1
- package/dist/VideoSegmentUploader.js +28 -2
- package/dist/VideoSegmentUploader.js.map +1 -1
- package/dist/VlmCandidateBuffer.d.ts +2 -0
- package/dist/VlmCandidateBuffer.d.ts.map +1 -1
- package/dist/VlmCandidateBuffer.js.map +1 -1
- package/dist/WatchlistClient.d.ts +55 -0
- package/dist/WatchlistClient.d.ts.map +1 -0
- package/dist/WatchlistClient.js +161 -0
- package/dist/WatchlistClient.js.map +1 -0
- package/dist/autoSense.d.ts.map +1 -1
- package/dist/autoSense.js +6 -0
- package/dist/autoSense.js.map +1 -1
- package/dist/cli.d.ts.map +1 -1
- package/dist/cli.js +6 -0
- package/dist/cli.js.map +1 -1
- package/dist/connectorUpdate.d.ts +34 -9
- package/dist/connectorUpdate.d.ts.map +1 -1
- package/dist/connectorUpdate.js +96 -9
- package/dist/connectorUpdate.js.map +1 -1
- package/dist/connectorUpdateApply.d.ts +20 -1
- package/dist/connectorUpdateApply.d.ts.map +1 -1
- package/dist/connectorUpdateApply.js +55 -1
- package/dist/connectorUpdateApply.js.map +1 -1
- package/dist/connectorUpdateApplyMac.d.ts +3 -1
- package/dist/connectorUpdateApplyMac.d.ts.map +1 -1
- package/dist/connectorUpdateApplyMac.js +6 -0
- package/dist/connectorUpdateApplyMac.js.map +1 -1
- package/dist/detectorEndpointState.d.ts +30 -0
- package/dist/detectorEndpointState.d.ts.map +1 -0
- package/dist/detectorEndpointState.js +125 -0
- package/dist/detectorEndpointState.js.map +1 -0
- package/dist/detectorLauncher.d.ts +23 -0
- package/dist/detectorLauncher.d.ts.map +1 -0
- package/dist/detectorLauncher.js +94 -0
- package/dist/detectorLauncher.js.map +1 -0
- package/dist/diagnose.d.ts +1 -1
- package/dist/diagnose.js +1 -1
- package/dist/hostCpu.d.ts +56 -0
- package/dist/hostCpu.d.ts.map +1 -0
- package/dist/hostCpu.js +113 -0
- package/dist/hostCpu.js.map +1 -0
- package/dist/localSensing.d.ts +86 -0
- package/dist/localSensing.d.ts.map +1 -1
- package/dist/localSensing.js +263 -30
- package/dist/localSensing.js.map +1 -1
- package/package.json +2 -2
- package/retained/ProfileAuthorityClient.cjs +4 -0
- package/retained/RetainedCaptureClient.cjs +6 -0
- package/retained/WebsiteAdmissionCaptureClient.cjs +3 -1
- package/retained/__tests__/website-admission-realtime.test.cjs +27 -2
|
@@ -30,8 +30,23 @@ POST /detect { image_b64, classes?, min_confidence }
|
|
|
30
30
|
GET /health 200 when the PINNED model's load completed AND its probe
|
|
31
31
|
inference succeeded; 503 otherwise, with the reason. Also
|
|
32
32
|
reports which models are resident. Runs no inference.
|
|
33
|
+
|
|
34
|
+
POST /v1/faces { image_b64, detector:{modelId,sha256}, embedder:{modelId,sha256},
|
|
35
|
+
minScore, minEyePx, maxAbsYaw, minSharpness, maxFaces }
|
|
36
|
+
200 { version, imageSha256, frameSize, detector, embedder,
|
|
37
|
+
faces: [{ box, score, landmarks, eyeDistancePx, yaw, sharpness,
|
|
38
|
+
quality, gate, embedding|null }], inferenceMs }
|
|
39
|
+
400 / 409 / 503 / 500 malformed / another artifact / not resident / refused
|
|
33
40
|
```
|
|
34
41
|
|
|
42
|
+
`/v1/faces` (`face_contract.py`, `face_identity.py`) is the door camera's face
|
|
43
|
+
task: YuNet 2023mar finds each face and its five landmarks on the original
|
|
44
|
+
face-zone JPEG, a 5-point similarity warp aligns it to the ArcFace 112x112
|
|
45
|
+
template, and EdgeFace-XS (the ONNX twin of the tablet's TFLite) gives a face
|
|
46
|
+
that passes every bar a unit 512-d vector. Both artifacts are task models in
|
|
47
|
+
`tasks.py`, admitted together through the same portfolio; the answer is
|
|
48
|
+
re-checked field by field before it leaves.
|
|
49
|
+
|
|
35
50
|
* `label` is the class **name**, never an index.
|
|
36
51
|
* `box` is in **pixels of the submitted frame**, not normalised.
|
|
37
52
|
* `classes` filters at the **service**, so the wire stays small. Absent means
|
|
@@ -10,7 +10,7 @@ name = "trillboards-detector"
|
|
|
10
10
|
# constant, a `labels.py`-only change survives `uv tool install` AND
|
|
11
11
|
# `uv tool install --force`; move the version and a bare `uv tool install`
|
|
12
12
|
# reinstalls. See `stamp_version.py`.
|
|
13
|
-
version = "0.2.0+src.
|
|
13
|
+
version = "0.2.0+src.18ad6e3937e7"
|
|
14
14
|
description = "On-device object-detector service for the Trillboards BYO-CCTV connector (loopback HTTP, ONNX Runtime)."
|
|
15
15
|
requires-python = ">=3.10"
|
|
16
16
|
|
|
@@ -218,6 +218,142 @@ class ActorTrackingTest(unittest.TestCase):
|
|
|
218
218
|
with self.assertRaisesRegex(TrackingError, "Corrupt"):
|
|
219
219
|
self.track(1400)
|
|
220
220
|
|
|
221
|
+
# ── each frame's own records (server.py:669 Codex P2) ────────────────────
|
|
222
|
+
|
|
223
|
+
def track_and_records(self, at, detections=None, **kwargs):
|
|
224
|
+
return self.journal.track_and_records(
|
|
225
|
+
request(at, **kwargs), detections if detections is not None else [person()],
|
|
226
|
+
image_sha256=SHA, model_hashes=MODEL, frame_size=(640, 480))
|
|
227
|
+
|
|
228
|
+
def test_two_interleaved_requests_on_one_camera_each_get_their_own_records(self):
|
|
229
|
+
"""The bug: the server read the records with a second lock acquisition after
|
|
230
|
+
track(), so a request for the camera's next frame could commit in between and this
|
|
231
|
+
frame was answered with the next frame's records. Here the next frame's request is
|
|
232
|
+
started from INSIDE this frame's transaction; it must wait, and each answer must be
|
|
233
|
+
its own frame's."""
|
|
234
|
+
import threading
|
|
235
|
+
self.track(1000)
|
|
236
|
+
original = self.journal._write_track_records
|
|
237
|
+
other = {}
|
|
238
|
+
def write_then_start_the_next_frame(*args):
|
|
239
|
+
original(*args)
|
|
240
|
+
if "thread" not in other:
|
|
241
|
+
other["thread"] = threading.Thread(
|
|
242
|
+
target=lambda: other.setdefault("answer", self.track_and_records(1400, [person(14, .9)])))
|
|
243
|
+
other["thread"].start()
|
|
244
|
+
other["thread"].join(.3) # it cannot get in: this frame still holds the journal
|
|
245
|
+
other["waited"] = other["thread"].is_alive()
|
|
246
|
+
self.journal._write_track_records = write_then_start_the_next_frame
|
|
247
|
+
result, records = self.track_and_records(1200)
|
|
248
|
+
other["thread"].join(10)
|
|
249
|
+
self.journal._write_track_records = original
|
|
250
|
+
self.assertTrue(other["waited"])
|
|
251
|
+
record, = records
|
|
252
|
+
self.assertEqual((record["lastSeenAtMs"], record["frames"], record["box"]["x"]), (1200, 1, 10))
|
|
253
|
+
self.assertEqual(record["actorId"], result["actors"][0]["actor"]["id"])
|
|
254
|
+
_, next_records = other["answer"]
|
|
255
|
+
self.assertEqual((next_records[0]["lastSeenAtMs"], next_records[0]["frames"],
|
|
256
|
+
next_records[0]["box"]["x"]), (1400, 2, 14))
|
|
257
|
+
# The live records moved on; the first answer did not move with them.
|
|
258
|
+
live, = self.journal.track_records("cam_a")
|
|
259
|
+
self.assertEqual((live.last_seen_ms, live.frames), (1400, 2))
|
|
260
|
+
|
|
261
|
+
def test_a_replay_serves_the_frames_own_saved_records_not_the_live_ones(self):
|
|
262
|
+
self.track(1000)
|
|
263
|
+
result, records = self.track_and_records(1200)
|
|
264
|
+
self.track(1400, [person(14, .9)])
|
|
265
|
+
self.assertEqual(self.track_and_records(1200), (result, records))
|
|
266
|
+
self.journal.close()
|
|
267
|
+
self.journal = ActorTrackerJournal(self.path)
|
|
268
|
+
self.assertEqual(self.track_and_records(1200), (result, records))
|
|
269
|
+
self.assertEqual(self.track(1200), result)
|
|
270
|
+
|
|
271
|
+
def test_a_frame_with_no_records_kept_replays_no_records(self):
|
|
272
|
+
"""A frame journalled before the snapshot existed, or by an older build."""
|
|
273
|
+
import sqlite3
|
|
274
|
+
self.track(1000)
|
|
275
|
+
result, records = self.track_and_records(1200)
|
|
276
|
+
self.assertEqual(len(records), 1)
|
|
277
|
+
with sqlite3.connect(self.path) as db:
|
|
278
|
+
db.execute("DELETE FROM actor_frame_records WHERE frame_id='frame_1200'")
|
|
279
|
+
self.assertEqual(self.track_and_records(1200), (result, []))
|
|
280
|
+
|
|
281
|
+
def test_records_kept_for_different_bytes_under_the_same_frame_id_are_not_served(self):
|
|
282
|
+
import sqlite3
|
|
283
|
+
self.track(1000)
|
|
284
|
+
result, _ = self.track_and_records(1200)
|
|
285
|
+
with sqlite3.connect(self.path) as db:
|
|
286
|
+
db.execute("UPDATE actor_frame_records SET fingerprint=? WHERE frame_id='frame_1200'", ("d" * 64,))
|
|
287
|
+
self.assertEqual(self.track_and_records(1200), (result, []))
|
|
288
|
+
|
|
289
|
+
def test_a_journal_from_before_the_snapshot_gains_its_table_and_keeps_its_frames(self):
|
|
290
|
+
import sqlite3
|
|
291
|
+
self.track(1000)
|
|
292
|
+
result, _ = self.track_and_records(1200)
|
|
293
|
+
self.journal.close()
|
|
294
|
+
with sqlite3.connect(self.path) as db:
|
|
295
|
+
db.execute("DROP TABLE actor_frame_records")
|
|
296
|
+
self.journal = ActorTrackerJournal(self.path)
|
|
297
|
+
self.assertEqual(self.track_and_records(1200), (result, []))
|
|
298
|
+
_, records = self.track_and_records(1400)
|
|
299
|
+
self.assertEqual(records[0]["frames"], 2)
|
|
300
|
+
self.assertEqual(self.track_and_records(1400)[1], records)
|
|
301
|
+
|
|
302
|
+
def test_an_older_build_can_still_write_this_journal_after_a_rollback(self):
|
|
303
|
+
"""Older builds insert frames by position (7 values): actor_frame keeps its columns."""
|
|
304
|
+
import sqlite3
|
|
305
|
+
self.track(1000)
|
|
306
|
+
with sqlite3.connect(self.path) as db:
|
|
307
|
+
self.assertEqual([r[1] for r in db.execute("PRAGMA table_info(actor_frame)")],
|
|
308
|
+
["camera_id", "frame_id", "seq", "epoch", "fingerprint", "input_json", "result_json"])
|
|
309
|
+
|
|
310
|
+
def test_records_kept_beside_frames_are_pruned_with_them(self):
|
|
311
|
+
import sqlite3
|
|
312
|
+
for at in range(1000, 1000 + 300 * 200, 200):
|
|
313
|
+
self.track(at)
|
|
314
|
+
with sqlite3.connect(self.path) as db:
|
|
315
|
+
frames = db.execute("SELECT count(*) FROM actor_frame WHERE camera_id='cam_a'").fetchone()[0]
|
|
316
|
+
kept = db.execute("SELECT count(*) FROM actor_frame_records WHERE camera_id='cam_a'").fetchone()[0]
|
|
317
|
+
orphans = db.execute("SELECT count(*) FROM actor_frame_records r WHERE NOT EXISTS (SELECT 1 FROM "
|
|
318
|
+
"actor_frame f WHERE f.camera_id=r.camera_id AND f.frame_id=r.frame_id)").fetchone()[0]
|
|
319
|
+
self.assertLessEqual(frames, 256)
|
|
320
|
+
self.assertEqual((kept, orphans), (frames, 0))
|
|
321
|
+
|
|
322
|
+
def test_a_replay_serves_a_face_only_while_its_actor_still_holds_that_slot(self):
|
|
323
|
+
import sqlite3
|
|
324
|
+
from trillboards_detector.track_records import FaceSlot
|
|
325
|
+
who = self.confirmed()
|
|
326
|
+
face = FaceSlot("face_model", "c" * 64, (0.6, 0.8), "frame_1200", 1200, .7)
|
|
327
|
+
self.assertTrue(self.journal.record_face("cam_a", who["id"], face))
|
|
328
|
+
_, records = self.track_and_records(1400)
|
|
329
|
+
self.assertEqual(records[0]["face"], face.to_wire())
|
|
330
|
+
self.assertEqual(self.track_and_records(1400)[1], records)
|
|
331
|
+
# The journal row keeps the slot's digest, never the vector: a face never
|
|
332
|
+
# outlives its track (track_records.py).
|
|
333
|
+
with sqlite3.connect(self.path) as db:
|
|
334
|
+
stored = db.execute("SELECT records_json FROM actor_frame_records WHERE frame_id='frame_1400'").fetchone()[0]
|
|
335
|
+
self.assertNotIn("0.6", stored)
|
|
336
|
+
self.assertNotIn("face_model", stored)
|
|
337
|
+
# A newer slot on the live record is not the one this frame had.
|
|
338
|
+
newer = FaceSlot("face_model", "c" * 64, (0.8, 0.6), "frame_1400", 1400, .9)
|
|
339
|
+
self.assertTrue(self.journal.record_face("cam_a", who["id"], newer))
|
|
340
|
+
replayed, = self.track_and_records(1400)[1]
|
|
341
|
+
self.assertIsNone(replayed["face"])
|
|
342
|
+
self.assertEqual({k: v for k, v in replayed.items() if k != "face"},
|
|
343
|
+
{k: v for k, v in records[0].items() if k != "face"})
|
|
344
|
+
# And once the actor ends, no replay brings its face back.
|
|
345
|
+
self.assertTrue(self.journal.record_face("cam_a", who["id"], face))
|
|
346
|
+
self.track(10000)
|
|
347
|
+
self.assertIsNone(self.track_and_records(1400)[1][0]["face"])
|
|
348
|
+
|
|
349
|
+
def test_a_corrupt_records_snapshot_is_not_an_idempotent_success(self):
|
|
350
|
+
import sqlite3
|
|
351
|
+
self.confirmed()
|
|
352
|
+
with sqlite3.connect(self.path) as db:
|
|
353
|
+
db.execute("UPDATE actor_frame_records SET records_json='{\"not\":\"a list\"}' WHERE frame_id='frame_1200'")
|
|
354
|
+
with self.assertRaisesRegex(TrackingError, "Corrupt"):
|
|
355
|
+
self.track_and_records(1200)
|
|
356
|
+
|
|
221
357
|
|
|
222
358
|
if __name__ == "__main__":
|
|
223
359
|
unittest.main()
|
|
@@ -92,6 +92,17 @@ class ActorTrackingWireTest(unittest.TestCase):
|
|
|
92
92
|
self.assertEqual(self.post(1400)[1]["tracks"][0]["frames"],2)
|
|
93
93
|
self.assertNotIn("tracks",self.post(1600,tracking=None)[1])
|
|
94
94
|
|
|
95
|
+
def test_a_replayed_frame_serves_its_own_tracks_not_the_live_ones(self):
|
|
96
|
+
self.post(1000)
|
|
97
|
+
_,second=self.post(1200)
|
|
98
|
+
_,third=self.post(1400)
|
|
99
|
+
self.assertEqual(third["tracks"][0]["frames"],2)
|
|
100
|
+
status,replayed=self.post(1200)
|
|
101
|
+
self.assertEqual(status,200)
|
|
102
|
+
self.assertEqual(replayed["tracking"],second["tracking"])
|
|
103
|
+
self.assertEqual(replayed["tracks"],second["tracks"])
|
|
104
|
+
self.assertEqual(replayed["tracks"][0]["frames"],1)
|
|
105
|
+
|
|
95
106
|
def test_invalid_or_unavailable_tracking_never_becomes_an_empty_scene(self):
|
|
96
107
|
for change in [{"tracking":{}},{"min_confidence":.5},{"expected_model":None},
|
|
97
108
|
{"classes":["cell phone"]}]:
|
|
@@ -0,0 +1,448 @@
|
|
|
1
|
+
"""The door faces task: the wire, the answer check, the catalogue, the admission, the geometry.
|
|
2
|
+
|
|
3
|
+
Three lanes, like the other task suites. The wire refusals, the answer re-check,
|
|
4
|
+
the catalogue and the shared admission are stdlib only and run on every runner.
|
|
5
|
+
The alignment, the YuNet decode and the gates need numpy + OpenCV (the CPU SDK
|
|
6
|
+
lane). The real artifacts are OTA'd and never committed, so the end-to-end case
|
|
7
|
+
runs only where TRILLBOARDS_FACE_DETECTOR_MODEL / TRILLBOARDS_FACE_EMBEDDER_MODEL
|
|
8
|
+
name them (and TRILLBOARDS_FACE_TEST_FRAMES a directory of JPEGs with faces).
|
|
9
|
+
"""
|
|
10
|
+
import base64
|
|
11
|
+
import copy
|
|
12
|
+
import hashlib
|
|
13
|
+
import importlib.util
|
|
14
|
+
import json
|
|
15
|
+
import math
|
|
16
|
+
import os
|
|
17
|
+
import tempfile
|
|
18
|
+
import threading
|
|
19
|
+
import unittest
|
|
20
|
+
import urllib.error
|
|
21
|
+
import urllib.request
|
|
22
|
+
from pathlib import Path
|
|
23
|
+
|
|
24
|
+
from trillboards_detector import face_contract as fc
|
|
25
|
+
from trillboards_detector.errors import DetectorNotReady, ModelVerificationError
|
|
26
|
+
from trillboards_detector.labels import RFDETR_MEDIUM
|
|
27
|
+
from trillboards_detector.registry import ModelEntry, ModelRegistry
|
|
28
|
+
from trillboards_detector.server import DetectorServer
|
|
29
|
+
from trillboards_detector.tasks import BUILTIN_TASK_MODELS, FACE_DETECTOR, FACE_EMBEDDER
|
|
30
|
+
|
|
31
|
+
_missing = [name for name in ("numpy", "cv2", "PIL", "onnxruntime") if importlib.util.find_spec(name) is None]
|
|
32
|
+
needs_numeric = unittest.skipIf(_missing, "detector[cpu] dependencies absent: " + ", ".join(_missing))
|
|
33
|
+
JPEG = b"\xff\xd8\xff\xe0 refused or faked before any decode"
|
|
34
|
+
DETECTOR_PIN = {"modelId": fc.FACE_DETECTOR_MODEL_ID, "sha256": fc.FACE_DETECTOR_SHA256}
|
|
35
|
+
EMBEDDER_PIN = {"modelId": fc.FACE_EMBEDDER_MODEL_ID, "sha256": fc.FACE_EMBEDDER_SHA256}
|
|
36
|
+
BARS = {"minScore": 0.6, "minEyePx": 12, "maxAbsYaw": 0.35, "minSharpness": 15.0, "maxFaces": 8}
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
def request_body(**over):
|
|
40
|
+
return {"image_b64": base64.b64encode(JPEG).decode(), "detector": dict(DETECTOR_PIN),
|
|
41
|
+
"embedder": dict(EMBEDDER_PIN), **BARS, **over}
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
def unit_vector(seed=1):
|
|
45
|
+
values = [math.sin(seed * (i + 1)) for i in range(fc.EMBEDDING_DIM)]
|
|
46
|
+
norm = math.sqrt(sum(v * v for v in values))
|
|
47
|
+
return [round(v / norm, 6) for v in values]
|
|
48
|
+
|
|
49
|
+
|
|
50
|
+
def face(gate="passed", score=0.9, eye=20.0, yaw=0.05, sharp=40.0, x=10.0):
|
|
51
|
+
return {"box": {"x": x, "y": 12.0, "width": 40.0, "height": 48.0}, "score": score,
|
|
52
|
+
"landmarks": [[x + 10, 30.0], [x + 30, 30.0], [x + 20, 40.0], [x + 12, 50.0], [x + 28, 50.0]],
|
|
53
|
+
"eyeDistancePx": eye, "yaw": yaw, "sharpness": sharp, "quality": 0.5, "gate": gate,
|
|
54
|
+
"embedding": unit_vector() if gate == "passed" else None}
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def answer(faces, jpeg=JPEG):
|
|
58
|
+
return {"version": 1, "imageSha256": hashlib.sha256(jpeg).hexdigest(),
|
|
59
|
+
"frameSize": {"width": 640, "height": 480},
|
|
60
|
+
"detector": {**DETECTOR_PIN, "preprocessing": fc.FACE_DETECT_PREPROCESSING},
|
|
61
|
+
"embedder": {**EMBEDDER_PIN, "preprocessing": fc.FACE_EMBED_PREPROCESSING},
|
|
62
|
+
"faces": faces, "inferenceMs": {"detect": 4.1, "embed": 2.9}}
|
|
63
|
+
|
|
64
|
+
|
|
65
|
+
class RequestTest(unittest.TestCase):
|
|
66
|
+
def test_a_complete_request_parses(self):
|
|
67
|
+
jpeg, detector, embedder, bars = fc.validate_faces_request(request_body())
|
|
68
|
+
self.assertEqual(jpeg, JPEG)
|
|
69
|
+
self.assertEqual((detector, embedder), (DETECTOR_PIN, EMBEDDER_PIN))
|
|
70
|
+
self.assertEqual(bars, {**BARS, "minEyePx": 12.0})
|
|
71
|
+
self.assertIs(type(bars["maxFaces"]), int)
|
|
72
|
+
|
|
73
|
+
def test_refusals(self):
|
|
74
|
+
bad = [
|
|
75
|
+
{k: v for k, v in request_body().items() if k != "minEyePx"},
|
|
76
|
+
{**request_body(), "extra": 1},
|
|
77
|
+
request_body(image_b64=""), request_body(image_b64="!!not base64"),
|
|
78
|
+
request_body(detector={"modelId": "yunet_2023mar"}),
|
|
79
|
+
request_body(detector={"modelId": "rfdetr_medium", "sha256": "a" * 64}),
|
|
80
|
+
request_body(embedder={"modelId": fc.FACE_EMBEDDER_MODEL_ID, "sha256": "A" * 64}),
|
|
81
|
+
request_body(minScore=0), request_body(minScore=1.2), request_body(minScore=True),
|
|
82
|
+
request_body(minEyePx=0.5), request_body(maxAbsYaw=0), request_body(minSharpness=-1),
|
|
83
|
+
request_body(maxFaces=0), request_body(maxFaces=17), request_body(maxFaces=2.0),
|
|
84
|
+
request_body(minScore=float("nan")), "not an object",
|
|
85
|
+
]
|
|
86
|
+
for body in bad:
|
|
87
|
+
with self.subTest(body=body if isinstance(body, str) else {k: v for k, v in body.items() if k != "image_b64"}):
|
|
88
|
+
with self.assertRaises(ValueError):
|
|
89
|
+
fc.validate_faces_request(body)
|
|
90
|
+
|
|
91
|
+
def test_a_right_model_with_another_sha_is_left_to_the_registry(self):
|
|
92
|
+
_, detector, _, _ = fc.validate_faces_request(request_body(detector={**DETECTOR_PIN, "sha256": "b" * 64}))
|
|
93
|
+
self.assertEqual(detector["sha256"], "b" * 64)
|
|
94
|
+
|
|
95
|
+
|
|
96
|
+
class AnswerCheckTest(unittest.TestCase):
|
|
97
|
+
def check(self, result, bars=BARS):
|
|
98
|
+
fc.check_faces_response(result, JPEG, DETECTOR_PIN, EMBEDDER_PIN, bars)
|
|
99
|
+
|
|
100
|
+
def test_a_consistent_answer_passes(self):
|
|
101
|
+
self.check(answer([face(), face("eye_distance", score=0.8, eye=9.0, x=100.0),
|
|
102
|
+
face("score", score=0.55, x=200.0)]))
|
|
103
|
+
self.check(answer([]))
|
|
104
|
+
|
|
105
|
+
def test_every_corruption_is_refused(self):
|
|
106
|
+
good = answer([face(), face("yaw", score=0.7, yaw=0.5, x=100.0)])
|
|
107
|
+
corruptions = {
|
|
108
|
+
"another image": lambda r: r.update(imageSha256="0" * 64),
|
|
109
|
+
"another detector": lambda r: r["detector"].update(sha256="c" * 64),
|
|
110
|
+
"another preprocessing": lambda r: r["embedder"].update(preprocessing="other"),
|
|
111
|
+
"extra key": lambda r: r.update(extra=1),
|
|
112
|
+
"box off the frame": lambda r: r["faces"][0]["box"].update(x=620.0),
|
|
113
|
+
"box without extent": lambda r: r["faces"][0]["box"].update(width=0),
|
|
114
|
+
"score above 1": lambda r: r["faces"][0].update(score=1.5),
|
|
115
|
+
"worse face first": lambda r: r["faces"].reverse(),
|
|
116
|
+
"mirrored eyes": lambda r: r["faces"][0]["landmarks"].reverse(),
|
|
117
|
+
"four landmarks": lambda r: r["faces"][0]["landmarks"].pop(),
|
|
118
|
+
"gate not from measures": lambda r: r["faces"][1].update(gate="passed", embedding=unit_vector()),
|
|
119
|
+
"vector it did not earn": lambda r: r["faces"][1].update(embedding=unit_vector()),
|
|
120
|
+
"passed without a vector": lambda r: r["faces"][0].update(embedding=None),
|
|
121
|
+
"short vector": lambda r: r["faces"][0].update(embedding=unit_vector()[:511]),
|
|
122
|
+
"vector not unit": lambda r: r["faces"][0].update(embedding=[v * 2 for v in unit_vector()]),
|
|
123
|
+
"non-finite vector": lambda r: r["faces"][0]["embedding"].__setitem__(3, float("nan")),
|
|
124
|
+
"unknown gate": lambda r: r["faces"][0].update(gate="maybe"),
|
|
125
|
+
"quality above 1": lambda r: r["faces"][0].update(quality=1.01),
|
|
126
|
+
"negative timing": lambda r: r["inferenceMs"].update(detect=-1),
|
|
127
|
+
}
|
|
128
|
+
for name, corrupt in corruptions.items():
|
|
129
|
+
result = copy.deepcopy(good)
|
|
130
|
+
corrupt(result)
|
|
131
|
+
with self.subTest(name), self.assertRaises(ValueError):
|
|
132
|
+
self.check(result)
|
|
133
|
+
|
|
134
|
+
def test_more_faces_than_asked_is_refused(self):
|
|
135
|
+
with self.assertRaises(ValueError):
|
|
136
|
+
self.check(answer([face(), face(x=100.0)]), {**BARS, "maxFaces": 1})
|
|
137
|
+
|
|
138
|
+
|
|
139
|
+
class CatalogueTest(unittest.TestCase):
|
|
140
|
+
def test_both_tasks_are_in_the_builtin_catalogue_with_their_measured_reservations(self):
|
|
141
|
+
self.assertIn(FACE_DETECTOR, BUILTIN_TASK_MODELS)
|
|
142
|
+
self.assertIn(FACE_EMBEDDER, BUILTIN_TASK_MODELS)
|
|
143
|
+
self.assertEqual((FACE_DETECTOR.model_name, FACE_DETECTOR.task, FACE_DETECTOR.sha256),
|
|
144
|
+
("yunet_2023mar", "face_detection_landmarks5", fc.FACE_DETECTOR_SHA256))
|
|
145
|
+
self.assertEqual((FACE_EMBEDDER.model_name, FACE_EMBEDDER.task, FACE_EMBEDDER.sha256),
|
|
146
|
+
("edgeface_xs_gamma_06", "face_identity_embedding", fc.FACE_EMBEDDER_SHA256))
|
|
147
|
+
self.assertEqual(FACE_DETECTOR.approx_ram_bytes, 256 * 1024**2)
|
|
148
|
+
self.assertEqual(FACE_EMBEDDER.approx_ram_bytes, 96 * 1024**2)
|
|
149
|
+
|
|
150
|
+
|
|
151
|
+
class FakeFaceSession:
|
|
152
|
+
def __init__(self, name, sha, result=None):
|
|
153
|
+
self.model_name, self.model_sha256, self.result, self.calls = name, sha, result, []
|
|
154
|
+
|
|
155
|
+
def estimate(self, jpeg, request, embedder):
|
|
156
|
+
self.calls.append((jpeg, request, embedder.model_name))
|
|
157
|
+
return self.result
|
|
158
|
+
|
|
159
|
+
|
|
160
|
+
class AdmissionTest(unittest.TestCase):
|
|
161
|
+
def registry(self, budget, result):
|
|
162
|
+
tmp = tempfile.TemporaryDirectory()
|
|
163
|
+
self.addCleanup(tmp.cleanup)
|
|
164
|
+
root = Path(tmp.name)
|
|
165
|
+
paths = {}
|
|
166
|
+
for name in ("det", fc.FACE_DETECTOR_MODEL_ID, fc.FACE_EMBEDDER_MODEL_ID):
|
|
167
|
+
paths[name] = root / f"{name}.onnx"
|
|
168
|
+
paths[name].write_bytes(name.encode())
|
|
169
|
+
self.loads = []
|
|
170
|
+
|
|
171
|
+
def factory(entry):
|
|
172
|
+
self.loads.append(entry.name)
|
|
173
|
+
if entry.name == fc.FACE_DETECTOR_MODEL_ID:
|
|
174
|
+
return FakeFaceSession(entry.name, fc.FACE_DETECTOR_SHA256, result)
|
|
175
|
+
return FakeFaceSession(entry.name, fc.FACE_EMBEDDER_SHA256)
|
|
176
|
+
|
|
177
|
+
reg = ModelRegistry([ModelEntry(RFDETR_MEDIUM, paths["det"], pinned=True),
|
|
178
|
+
ModelEntry(FACE_DETECTOR, paths[fc.FACE_DETECTOR_MODEL_ID]),
|
|
179
|
+
ModelEntry(FACE_EMBEDDER, paths[fc.FACE_EMBEDDER_MODEL_ID])],
|
|
180
|
+
factory, lambda session: None, budget, log=lambda line: None)
|
|
181
|
+
reg.refresh()
|
|
182
|
+
return reg
|
|
183
|
+
|
|
184
|
+
def test_both_sessions_are_admitted_together_and_counted(self):
|
|
185
|
+
reg = self.registry(2000 * 1024**2, answer([]))
|
|
186
|
+
out = reg.estimate_faces(JPEG, BARS, DETECTOR_PIN, EMBEDDER_PIN)
|
|
187
|
+
self.assertEqual(out["faces"], [])
|
|
188
|
+
self.assertEqual(self.loads, ["rfdetr_medium", fc.FACE_DETECTOR_MODEL_ID, fc.FACE_EMBEDDER_MODEL_ID])
|
|
189
|
+
snap = reg.snapshot()["models"]
|
|
190
|
+
self.assertEqual(snap[fc.FACE_DETECTOR_MODEL_ID]["detect_count"], 1)
|
|
191
|
+
self.assertEqual(snap[fc.FACE_EMBEDDER_MODEL_ID]["task"], "face_identity_embedding")
|
|
192
|
+
|
|
193
|
+
def test_a_different_pin_is_a_verification_error(self):
|
|
194
|
+
reg = self.registry(2000 * 1024**2, answer([]))
|
|
195
|
+
for detector, embedder in (({**DETECTOR_PIN, "sha256": "b" * 64}, EMBEDDER_PIN),
|
|
196
|
+
(DETECTOR_PIN, {**EMBEDDER_PIN, "sha256": "b" * 64}),
|
|
197
|
+
(EMBEDDER_PIN, DETECTOR_PIN)):
|
|
198
|
+
with self.subTest(detector=detector, embedder=embedder), self.assertRaises(ModelVerificationError):
|
|
199
|
+
reg.estimate_faces(JPEG, BARS, detector, embedder)
|
|
200
|
+
|
|
201
|
+
def test_an_answer_naming_another_contract_is_refused_and_counted(self):
|
|
202
|
+
wrong = answer([])
|
|
203
|
+
wrong["embedder"]["preprocessing"] = "something_else"
|
|
204
|
+
reg = self.registry(2000 * 1024**2, wrong)
|
|
205
|
+
with self.assertRaises(ModelVerificationError):
|
|
206
|
+
reg.estimate_faces(JPEG, BARS, DETECTOR_PIN, EMBEDDER_PIN)
|
|
207
|
+
self.assertEqual(reg.snapshot()["models"][fc.FACE_DETECTOR_MODEL_ID]["detect_failures"], 1)
|
|
208
|
+
|
|
209
|
+
def test_no_ram_ceiling_refuses_rather_than_answering_half(self):
|
|
210
|
+
reg = self.registry(None, answer([]))
|
|
211
|
+
with self.assertRaises(DetectorNotReady):
|
|
212
|
+
reg.estimate_faces(JPEG, BARS, DETECTOR_PIN, EMBEDDER_PIN)
|
|
213
|
+
|
|
214
|
+
|
|
215
|
+
class EndpointTest(unittest.TestCase):
|
|
216
|
+
def serve(self, loader):
|
|
217
|
+
server = DetectorServer(("127.0.0.1", 0), loader, log_line=lambda _m: None)
|
|
218
|
+
threading.Thread(target=lambda: server.serve_forever(poll_interval=0.02), daemon=True).start()
|
|
219
|
+
self.addCleanup(server.server_close)
|
|
220
|
+
self.addCleanup(server.shutdown)
|
|
221
|
+
host, port = server.server_address[:2]
|
|
222
|
+
return f"http://{host}:{port}/v1/faces"
|
|
223
|
+
|
|
224
|
+
def post(self, url, body):
|
|
225
|
+
request = urllib.request.Request(url, data=json.dumps(body).encode(), method="POST")
|
|
226
|
+
request.add_header("Content-Type", "application/json")
|
|
227
|
+
try:
|
|
228
|
+
with urllib.request.urlopen(request, timeout=10) as res:
|
|
229
|
+
return res.status, json.loads(res.read().decode())
|
|
230
|
+
except urllib.error.HTTPError as err:
|
|
231
|
+
with err:
|
|
232
|
+
return err.code, json.loads(err.read().decode())
|
|
233
|
+
|
|
234
|
+
def loader(self, result=None, error=None):
|
|
235
|
+
class Loader:
|
|
236
|
+
calls = []
|
|
237
|
+
|
|
238
|
+
def estimate_faces(self, jpeg, bars, detector, embedder):
|
|
239
|
+
self.calls.append((jpeg, bars, detector, embedder))
|
|
240
|
+
if error is not None:
|
|
241
|
+
raise error
|
|
242
|
+
return result
|
|
243
|
+
|
|
244
|
+
return Loader()
|
|
245
|
+
|
|
246
|
+
def test_answers_the_request(self):
|
|
247
|
+
loader = self.loader(answer([face()]))
|
|
248
|
+
status, out = self.post(self.serve(loader), request_body())
|
|
249
|
+
self.assertEqual(status, 200)
|
|
250
|
+
self.assertEqual(out["faces"][0]["gate"], "passed")
|
|
251
|
+
self.assertEqual(loader.calls[0][1], {**BARS, "minEyePx": 12.0})
|
|
252
|
+
|
|
253
|
+
def test_refuses_a_malformed_request_before_inference(self):
|
|
254
|
+
loader = self.loader(answer([]))
|
|
255
|
+
url = self.serve(loader)
|
|
256
|
+
for body in (request_body(maxFaces=0), {**request_body(), "x": 1}, request_body(image_b64="!!")):
|
|
257
|
+
with self.subTest(body={k: v for k, v in body.items() if k != "image_b64"}):
|
|
258
|
+
self.assertEqual(self.post(url, body)[0], 400)
|
|
259
|
+
self.assertEqual(loader.calls, [])
|
|
260
|
+
|
|
261
|
+
def test_status_codes_for_each_refusal(self):
|
|
262
|
+
for error, status in ((ModelVerificationError("other bytes"), 409), (DetectorNotReady("absent"), 503),
|
|
263
|
+
(ValueError("not a jpeg"), 400), (RuntimeError("boom"), 500)):
|
|
264
|
+
with self.subTest(error=type(error).__name__):
|
|
265
|
+
self.assertEqual(self.post(self.serve(self.loader(error=error)), request_body())[0], status)
|
|
266
|
+
|
|
267
|
+
def test_a_malformed_answer_is_a_500_not_a_200(self):
|
|
268
|
+
bad = answer([face()])
|
|
269
|
+
bad["faces"][0]["embedding"] = None
|
|
270
|
+
status, out = self.post(self.serve(self.loader(bad)), request_body())
|
|
271
|
+
self.assertEqual(status, 500)
|
|
272
|
+
self.assertIn("refused malformed face output", out["error"])
|
|
273
|
+
|
|
274
|
+
def test_an_older_loader_is_503(self):
|
|
275
|
+
class OldLoader:
|
|
276
|
+
pass
|
|
277
|
+
|
|
278
|
+
self.assertEqual(self.post(self.serve(OldLoader()), request_body())[0], 503)
|
|
279
|
+
|
|
280
|
+
|
|
281
|
+
@needs_numeric
|
|
282
|
+
class GeometryTest(unittest.TestCase):
|
|
283
|
+
"""Golden numbers are the tablet's (FaceEmbeddingAlignmentTest.kt, from skimage/cv2)."""
|
|
284
|
+
|
|
285
|
+
def setUp(self):
|
|
286
|
+
import numpy as np
|
|
287
|
+
|
|
288
|
+
from trillboards_detector import face_identity as fi
|
|
289
|
+
self.np, self.fi = np, fi
|
|
290
|
+
self.ref = fi.ARCFACE_REFERENCE_112
|
|
291
|
+
|
|
292
|
+
def close(self, got, expected, tol=1e-3):
|
|
293
|
+
self.assertIsNotNone(got)
|
|
294
|
+
self.assertLess(float(self.np.max(self.np.abs(got.reshape(-1) - self.np.asarray(expected)))), tol)
|
|
295
|
+
|
|
296
|
+
def test_identity_scale_and_shift(self):
|
|
297
|
+
self.close(self.fi.umeyama(self.ref, self.ref), [1, 0, 0, 0, 1, 0], 1e-6)
|
|
298
|
+
src = self.ref * 2 + self.np.array([10.0, 20.0])
|
|
299
|
+
self.close(self.fi.umeyama(src, self.ref), [0.5, 0, -5, 0, 0.5, -10])
|
|
300
|
+
|
|
301
|
+
def test_rotation_and_realistic_goldens(self):
|
|
302
|
+
rotated = self.np.array([[16.468790714189396, 75.84533481235152], [56.79088068770203, 97.58467938422059],
|
|
303
|
+
[24.206694589922115, 109.75911116312703], [-5.165269981353294, 124.27159194683668],
|
|
304
|
+
[28.226224502304305, 142.2743599070328]])
|
|
305
|
+
self.close(self.fi.umeyama(rotated, self.ref), [0.6750635091464405, 0.36878887584938713, -0.7937954147865156,
|
|
306
|
+
-0.3687888758493872, 0.6750635091464408, 6.5693889432719885])
|
|
307
|
+
realistic = self.np.array([[120, 140], [180, 138], [150, 175], [128, 205], [176, 204]], float)
|
|
308
|
+
self.close(self.fi.umeyama(realistic, self.ref), [0.6093380958941857, -0.014717125930008273, -33.324792350509796,
|
|
309
|
+
0.014717125930008275, 0.6093380958941859, -35.36845032240289])
|
|
310
|
+
|
|
311
|
+
def test_degenerate_points_have_no_transform(self):
|
|
312
|
+
self.assertIsNone(self.fi.umeyama(self.np.full((5, 2), 50.0), self.ref))
|
|
313
|
+
self.assertIsNone(self.fi.umeyama(self.np.zeros((2, 2)), self.np.zeros((2, 2))))
|
|
314
|
+
|
|
315
|
+
def test_order_is_by_image_position_not_by_name(self):
|
|
316
|
+
a = [[30, 50], [70, 52], [50, 70], [35, 90], [68, 91]]
|
|
317
|
+
b = [[70, 52], [30, 50], [50, 70], [68, 91], [35, 90]]
|
|
318
|
+
self.assertEqual(self.fi.arcface_order(a).tolist(), self.fi.arcface_order(b).tolist())
|
|
319
|
+
self.assertEqual(self.fi.arcface_order(b)[0].tolist(), [30, 50])
|
|
320
|
+
|
|
321
|
+
def test_yaw_is_signed_along_the_eye_line_and_zero_when_frontal(self):
|
|
322
|
+
chip = self.np.zeros((112, 112, 3), self.np.uint8)
|
|
323
|
+
frontal = [[40, 50], [70, 50], [55, 65], [45, 80], [65, 80]]
|
|
324
|
+
eye, yaw, sharp = self.fi.face_measures(frontal, chip)
|
|
325
|
+
self.assertAlmostEqual(eye, 30.0)
|
|
326
|
+
self.assertAlmostEqual(yaw, 0.0)
|
|
327
|
+
self.assertEqual(sharp, 0.0)
|
|
328
|
+
turned = [[40, 50], [70, 50], [64, 65], [45, 80], [65, 80]]
|
|
329
|
+
self.assertAlmostEqual(self.fi.face_measures(turned, chip)[1], 0.3)
|
|
330
|
+
# The same face rolled 90 degrees: still frontal along its own eye line.
|
|
331
|
+
rolled = [[50, 40], [50, 70], [35, 55], [20, 45], [20, 65]]
|
|
332
|
+
self.assertAlmostEqual(self.fi.face_measures(rolled, chip)[1], 0.0)
|
|
333
|
+
|
|
334
|
+
def test_gate_order_and_quality_bounds(self):
|
|
335
|
+
gate = self.fi.face_gate
|
|
336
|
+
self.assertEqual(gate(0.5, 5, 0.9, 1, BARS), "score")
|
|
337
|
+
self.assertEqual(gate(0.9, 11.99, 0.9, 1, BARS), "eye_distance")
|
|
338
|
+
self.assertEqual(gate(0.9, 12, -0.36, 1, BARS), "yaw")
|
|
339
|
+
self.assertEqual(gate(0.9, 12, 0.35, 14.99, BARS), "sharpness")
|
|
340
|
+
self.assertEqual(gate(0.9, 12, 0.35, 15, BARS), "passed")
|
|
341
|
+
self.assertEqual(self.fi.face_quality(1.0, 48, 0, 500), 1.0)
|
|
342
|
+
self.assertEqual(self.fi.face_quality(0.9, 12, 0.5, 30), 0.0)
|
|
343
|
+
self.assertAlmostEqual(self.fi.face_quality(0.8, 12, 0.25, 30), 0.8 * 0.5 * 0.5 * 0.5)
|
|
344
|
+
|
|
345
|
+
def test_decode_follows_opencv_on_constructed_heads(self):
|
|
346
|
+
np = self.np
|
|
347
|
+
pad_w, pad_h = 64, 32
|
|
348
|
+
outputs = {}
|
|
349
|
+
for stride in self.fi.YUNET_STRIDES:
|
|
350
|
+
n = (pad_w // stride) * (pad_h // stride)
|
|
351
|
+
outputs[f"cls_{stride}"] = np.zeros((1, n, 1), np.float32)
|
|
352
|
+
outputs[f"obj_{stride}"] = np.zeros((1, n, 1), np.float32)
|
|
353
|
+
outputs[f"bbox_{stride}"] = np.zeros((1, n, 4), np.float32)
|
|
354
|
+
outputs[f"kps_{stride}"] = np.zeros((1, n, 10), np.float32)
|
|
355
|
+
# One face at stride 8, anchor (row 1, col 2): score sqrt(0.81 * 1) = 0.9.
|
|
356
|
+
idx = 1 * (pad_w // 8) + 2
|
|
357
|
+
outputs["cls_8"][0, idx, 0], outputs["obj_8"][0, idx, 0] = 0.81, 1.2 # obj clamps to 1
|
|
358
|
+
outputs["bbox_8"][0, idx] = [0.5, 0.25, math.log(2), 0.0]
|
|
359
|
+
outputs["kps_8"][0, idx] = [0, 0, 1, 0, 0.5, 0.5, 0, 1, 1, 1]
|
|
360
|
+
# A weaker overlapping duplicate is suppressed by NMS; a below-threshold anchor never appears.
|
|
361
|
+
outputs["cls_8"][0, idx + 1, 0], outputs["obj_8"][0, idx + 1, 0] = 0.64, 1.0
|
|
362
|
+
outputs["bbox_8"][0, idx + 1] = [-0.5, 0.25, math.log(2), 0.0]
|
|
363
|
+
outputs["cls_16"][0, 0, 0], outputs["obj_16"][0, 0, 0] = 0.1, 0.1
|
|
364
|
+
rows = self.fi.decode_yunet(outputs, pad_w, pad_h, 0.5)
|
|
365
|
+
self.assertEqual(len(rows), 1)
|
|
366
|
+
x, y, w, h = rows[0][:4]
|
|
367
|
+
self.assertEqual([round(v, 4) for v in (x, y, w, h)], [12.0, 6.0, 16.0, 8.0])
|
|
368
|
+
self.assertEqual([round(v, 4) for v in rows[0][4:14]], [16, 8, 24, 8, 20, 12, 16, 16, 24, 16])
|
|
369
|
+
self.assertAlmostEqual(rows[0][14], 0.9, places=6)
|
|
370
|
+
|
|
371
|
+
def test_nms_matches_opencv_semantics(self):
|
|
372
|
+
np = self.np
|
|
373
|
+
boxes = np.array([[0, 0, 10, 10], [1, 1, 10, 10], [50, 50, 10, 10]], float)
|
|
374
|
+
scores = np.array([0.9, 0.8, 0.7])
|
|
375
|
+
self.assertEqual(self.fi.nms_boxes(boxes, scores, 0.5, 0.3, 5000).tolist(), [0, 2])
|
|
376
|
+
self.assertEqual(self.fi.nms_boxes(boxes, scores, 0.5, 0.3, 1).tolist(), [0])
|
|
377
|
+
# A score exactly at the threshold is dropped, as GetMaxScoreIndex drops it.
|
|
378
|
+
self.assertEqual(self.fi.nms_boxes(boxes, np.array([0.9, 0.5, 0.5]), 0.5, 0.3, 5000).tolist(), [0])
|
|
379
|
+
|
|
380
|
+
|
|
381
|
+
def _artifact(variable, model_id):
|
|
382
|
+
value = os.environ.get(variable, "").strip()
|
|
383
|
+
path = Path(value) if value else Path.home() / ".trillboards" / "models" / model_id / "model.onnx"
|
|
384
|
+
return path if path.is_file() else None
|
|
385
|
+
|
|
386
|
+
|
|
387
|
+
DETECTOR_ARTIFACT = _artifact("TRILLBOARDS_FACE_DETECTOR_MODEL", fc.FACE_DETECTOR_MODEL_ID)
|
|
388
|
+
EMBEDDER_ARTIFACT = _artifact("TRILLBOARDS_FACE_EMBEDDER_MODEL", fc.FACE_EMBEDDER_MODEL_ID)
|
|
389
|
+
FRAMES = Path(os.environ["TRILLBOARDS_FACE_TEST_FRAMES"]) if os.environ.get("TRILLBOARDS_FACE_TEST_FRAMES") else None
|
|
390
|
+
|
|
391
|
+
|
|
392
|
+
@needs_numeric
|
|
393
|
+
@unittest.skipUnless(DETECTOR_ARTIFACT and EMBEDDER_ARTIFACT, "face artifacts absent (they are OTA'd, never committed)")
|
|
394
|
+
class RealModelTest(unittest.TestCase):
|
|
395
|
+
"""The real pinned artifacts: the answer passes the wire check; the decode is OpenCV's."""
|
|
396
|
+
|
|
397
|
+
@classmethod
|
|
398
|
+
def setUpClass(cls):
|
|
399
|
+
from trillboards_detector import face_identity as fi
|
|
400
|
+
cls.fi = fi
|
|
401
|
+
cls.detector = fi.YunetFaceDetector(DETECTOR_ARTIFACT, intra_op_threads=1)
|
|
402
|
+
cls.embedder = fi.EdgeFaceEmbedder(EMBEDDER_ARTIFACT, intra_op_threads=1)
|
|
403
|
+
|
|
404
|
+
def frames(self):
|
|
405
|
+
if FRAMES is None or not FRAMES.is_dir():
|
|
406
|
+
self.skipTest("TRILLBOARDS_FACE_TEST_FRAMES names no directory of JPEGs with faces")
|
|
407
|
+
return sorted(FRAMES.glob("*.jpg"))[:40]
|
|
408
|
+
|
|
409
|
+
def test_probes_complete(self):
|
|
410
|
+
self.detector.probe()
|
|
411
|
+
self.embedder.probe()
|
|
412
|
+
|
|
413
|
+
def test_answers_pass_the_wire_check_and_vectors_are_unit(self):
|
|
414
|
+
faces = 0
|
|
415
|
+
for path in self.frames():
|
|
416
|
+
jpeg = path.read_bytes()
|
|
417
|
+
out = self.detector.estimate(jpeg, BARS, self.embedder)
|
|
418
|
+
fc.check_faces_response(out, jpeg, DETECTOR_PIN, EMBEDDER_PIN, BARS)
|
|
419
|
+
faces += len(out["faces"])
|
|
420
|
+
self.assertGreater(faces, 0)
|
|
421
|
+
|
|
422
|
+
def test_landmarks_put_the_image_left_eye_first_and_match_opencv(self):
|
|
423
|
+
import cv2
|
|
424
|
+
import numpy as np
|
|
425
|
+
|
|
426
|
+
published = os.environ.get("TRILLBOARDS_FACE_DETECTOR_PUBLISHED")
|
|
427
|
+
compared = 0
|
|
428
|
+
for path in self.frames():
|
|
429
|
+
bgr = cv2.imread(str(path))
|
|
430
|
+
ours = self.detector.detect(bgr, 0.5)
|
|
431
|
+
for _box, _score, landmarks in ours:
|
|
432
|
+
self.assertLess(landmarks[0][0], landmarks[1][0])
|
|
433
|
+
if published:
|
|
434
|
+
reference = cv2.FaceDetectorYN.create(published, "", (bgr.shape[1], bgr.shape[0]), 0.5, 0.3, 5000)
|
|
435
|
+
_, rows = reference.detect(bgr)
|
|
436
|
+
rows = [] if rows is None else np.asarray(rows, np.float64).reshape(-1, 15)
|
|
437
|
+
self.assertEqual(len(rows), len(ours))
|
|
438
|
+
for (box, score, landmarks), row in zip(ours, rows):
|
|
439
|
+
got = np.concatenate([box, np.asarray(landmarks).reshape(-1)])
|
|
440
|
+
self.assertLess(float(np.max(np.abs(got - row[:14]))), 1e-2)
|
|
441
|
+
self.assertAlmostEqual(score, float(row[14]), places=4)
|
|
442
|
+
compared += 1
|
|
443
|
+
if published:
|
|
444
|
+
self.assertGreater(compared, 0)
|
|
445
|
+
|
|
446
|
+
|
|
447
|
+
if __name__ == "__main__":
|
|
448
|
+
unittest.main()
|