@kubohiroya/turbowarp-camera-source 0.5.0 → 0.7.0
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/README.ja.md +56 -3
- package/README.md +197 -11
- package/dist/camera-source.js +1215 -43
- package/dist/extension-manifest.json +139 -3
- package/dist/runtime.d.ts +76 -0
- package/dist/runtime.d.ts.map +1 -0
- package/dist/runtime.js +34 -0
- package/dist/runtime.js.map +1 -0
- package/package.json +9 -3
- package/schemas/camera-intrinsics-v1.json +346 -0
- package/schemas/extension-manifest.schema.json +49 -0
package/dist/camera-source.js
CHANGED
|
@@ -17,6 +17,10 @@
|
|
|
17
17
|
license: "MPL-2.0",
|
|
18
18
|
unsandboxed: true
|
|
19
19
|
};
|
|
20
|
+
//#endregion
|
|
21
|
+
//#region config/feature-flags.ts
|
|
22
|
+
var overrides = globalThis.__TWCS_FEATURE_FLAGS__;
|
|
23
|
+
var featureFlags = Object.freeze({ calibrationProfilesV1: overrides?.calibrationProfilesV1 === true });
|
|
20
24
|
var block_definitions_default = {
|
|
21
25
|
extensionName: "Camera Source",
|
|
22
26
|
blocks: [
|
|
@@ -24,7 +28,6 @@
|
|
|
24
28
|
"opcode": "startSharedCamera",
|
|
25
29
|
"blockType": "COMMAND",
|
|
26
30
|
"text": "start shared camera [CAMERA_ID] with device ID [DEVICE_ID]",
|
|
27
|
-
"description": "Starts or keeps a named shared MediaDevices camera stream.",
|
|
28
31
|
"arguments": {
|
|
29
32
|
"CAMERA_ID": {
|
|
30
33
|
"type": "STRING",
|
|
@@ -40,7 +43,6 @@
|
|
|
40
43
|
"opcode": "stopSharedCamera",
|
|
41
44
|
"blockType": "COMMAND",
|
|
42
45
|
"text": "stop shared camera [CAMERA_ID]",
|
|
43
|
-
"description": "Stops a named shared camera stream and releases its tracks.",
|
|
44
46
|
"arguments": { "CAMERA_ID": {
|
|
45
47
|
"type": "STRING",
|
|
46
48
|
"defaultValue": "default"
|
|
@@ -50,7 +52,24 @@
|
|
|
50
52
|
"opcode": "isCameraRunning",
|
|
51
53
|
"blockType": "BOOLEAN",
|
|
52
54
|
"text": "shared camera [CAMERA_ID] is running?",
|
|
53
|
-
"
|
|
55
|
+
"arguments": { "CAMERA_ID": {
|
|
56
|
+
"type": "STRING",
|
|
57
|
+
"defaultValue": "default"
|
|
58
|
+
} }
|
|
59
|
+
},
|
|
60
|
+
{
|
|
61
|
+
"opcode": "cameraErrorCode",
|
|
62
|
+
"blockType": "REPORTER",
|
|
63
|
+
"text": "shared camera [CAMERA_ID] error code",
|
|
64
|
+
"arguments": { "CAMERA_ID": {
|
|
65
|
+
"type": "STRING",
|
|
66
|
+
"defaultValue": "default"
|
|
67
|
+
} }
|
|
68
|
+
},
|
|
69
|
+
{
|
|
70
|
+
"opcode": "cameraError",
|
|
71
|
+
"blockType": "REPORTER",
|
|
72
|
+
"text": "shared camera [CAMERA_ID] error",
|
|
54
73
|
"arguments": { "CAMERA_ID": {
|
|
55
74
|
"type": "STRING",
|
|
56
75
|
"defaultValue": "default"
|
|
@@ -60,7 +79,6 @@
|
|
|
60
79
|
"opcode": "cameraDeviceIdReporter",
|
|
61
80
|
"blockType": "REPORTER",
|
|
62
81
|
"text": "shared camera [CAMERA_ID] device ID",
|
|
63
|
-
"description": "Returns the active device ID for a named shared camera when available.",
|
|
64
82
|
"arguments": { "CAMERA_ID": {
|
|
65
83
|
"type": "STRING",
|
|
66
84
|
"defaultValue": "default"
|
|
@@ -69,16 +87,16 @@
|
|
|
69
87
|
{
|
|
70
88
|
"opcode": "showCameraPreview",
|
|
71
89
|
"blockType": "COMMAND",
|
|
72
|
-
"text": "show shared camera [CAMERA_ID] preview
|
|
73
|
-
"description": "Shows the named shared camera with the GPU-backed stage preview.",
|
|
90
|
+
"text": "show shared camera [CAMERA_ID] preview flipped [PREVIEW_FLIP]",
|
|
74
91
|
"arguments": {
|
|
75
92
|
"CAMERA_ID": {
|
|
76
93
|
"type": "STRING",
|
|
77
94
|
"defaultValue": "default"
|
|
78
95
|
},
|
|
79
|
-
"
|
|
96
|
+
"PREVIEW_FLIP": {
|
|
80
97
|
"type": "STRING",
|
|
81
|
-
"defaultValue": "
|
|
98
|
+
"defaultValue": "horizontal",
|
|
99
|
+
"menu": "flips"
|
|
82
100
|
}
|
|
83
101
|
}
|
|
84
102
|
},
|
|
@@ -86,7 +104,6 @@
|
|
|
86
104
|
"opcode": "hideCameraPreview",
|
|
87
105
|
"blockType": "COMMAND",
|
|
88
106
|
"text": "hide shared camera [CAMERA_ID] preview",
|
|
89
|
-
"description": "Hides the block-owned preview without stopping leases owned by other consumers.",
|
|
90
107
|
"arguments": { "CAMERA_ID": {
|
|
91
108
|
"type": "STRING",
|
|
92
109
|
"defaultValue": "default"
|
|
@@ -96,7 +113,6 @@
|
|
|
96
113
|
"opcode": "cameraFrameWidth",
|
|
97
114
|
"blockType": "REPORTER",
|
|
98
115
|
"text": "shared camera [CAMERA_ID] frame width",
|
|
99
|
-
"description": "Returns the active video frame width in pixels, or zero while the camera is not running.",
|
|
100
116
|
"arguments": { "CAMERA_ID": {
|
|
101
117
|
"type": "STRING",
|
|
102
118
|
"defaultValue": "default"
|
|
@@ -106,7 +122,6 @@
|
|
|
106
122
|
"opcode": "cameraFrameHeight",
|
|
107
123
|
"blockType": "REPORTER",
|
|
108
124
|
"text": "shared camera [CAMERA_ID] frame height",
|
|
109
|
-
"description": "Returns the active video frame height in pixels, or zero while the camera is not running.",
|
|
110
125
|
"arguments": { "CAMERA_ID": {
|
|
111
126
|
"type": "STRING",
|
|
112
127
|
"defaultValue": "default"
|
|
@@ -116,7 +131,6 @@
|
|
|
116
131
|
"opcode": "cameraFrameRate",
|
|
117
132
|
"blockType": "REPORTER",
|
|
118
133
|
"text": "shared camera [CAMERA_ID] frame rate",
|
|
119
|
-
"description": "Returns the active video track frame rate, or zero when it is unavailable.",
|
|
120
134
|
"arguments": { "CAMERA_ID": {
|
|
121
135
|
"type": "STRING",
|
|
122
136
|
"defaultValue": "default"
|
|
@@ -126,21 +140,18 @@
|
|
|
126
140
|
"opcode": "refreshCameraDevices",
|
|
127
141
|
"blockType": "COMMAND",
|
|
128
142
|
"text": "refresh camera devices",
|
|
129
|
-
"description": "Refreshes the browser camera device list.",
|
|
130
143
|
"arguments": {}
|
|
131
144
|
},
|
|
132
145
|
{
|
|
133
146
|
"opcode": "cameraDeviceCount",
|
|
134
147
|
"blockType": "REPORTER",
|
|
135
148
|
"text": "camera device count",
|
|
136
|
-
"description": "Returns the number of known camera devices after refresh.",
|
|
137
149
|
"arguments": {}
|
|
138
150
|
},
|
|
139
151
|
{
|
|
140
152
|
"opcode": "cameraDeviceIdAt",
|
|
141
153
|
"blockType": "REPORTER",
|
|
142
154
|
"text": "camera device ID at [INDEX]",
|
|
143
|
-
"description": "Returns the one-based camera device ID at the requested index.",
|
|
144
155
|
"arguments": { "INDEX": {
|
|
145
156
|
"type": "STRING",
|
|
146
157
|
"defaultValue": "1"
|
|
@@ -150,15 +161,937 @@
|
|
|
150
161
|
"opcode": "cameraDeviceLabelAt",
|
|
151
162
|
"blockType": "REPORTER",
|
|
152
163
|
"text": "camera device label at [INDEX]",
|
|
153
|
-
"description": "Returns the one-based camera device label at the requested index when the browser exposes it.",
|
|
154
164
|
"arguments": { "INDEX": {
|
|
155
165
|
"type": "STRING",
|
|
156
166
|
"defaultValue": "1"
|
|
157
167
|
} }
|
|
168
|
+
},
|
|
169
|
+
{
|
|
170
|
+
"opcode": "registerCameraProfile",
|
|
171
|
+
"feature": "calibrationProfilesV1",
|
|
172
|
+
"blockType": "COMMAND",
|
|
173
|
+
"text": "register camera profile [PROFILE_JSON]",
|
|
174
|
+
"arguments": { "PROFILE_JSON": {
|
|
175
|
+
"type": "STRING",
|
|
176
|
+
"defaultValue": "{}"
|
|
177
|
+
} }
|
|
178
|
+
},
|
|
179
|
+
{
|
|
180
|
+
"opcode": "forgetCameraProfile",
|
|
181
|
+
"feature": "calibrationProfilesV1",
|
|
182
|
+
"blockType": "COMMAND",
|
|
183
|
+
"text": "forget camera profile for [CAMERA_ID]",
|
|
184
|
+
"arguments": { "CAMERA_ID": {
|
|
185
|
+
"type": "STRING",
|
|
186
|
+
"defaultValue": "default"
|
|
187
|
+
} }
|
|
188
|
+
},
|
|
189
|
+
{
|
|
190
|
+
"opcode": "cameraProfileRegistered",
|
|
191
|
+
"feature": "calibrationProfilesV1",
|
|
192
|
+
"blockType": "BOOLEAN",
|
|
193
|
+
"text": "camera [CAMERA_ID] is calibrated?",
|
|
194
|
+
"arguments": { "CAMERA_ID": {
|
|
195
|
+
"type": "STRING",
|
|
196
|
+
"defaultValue": "default"
|
|
197
|
+
} }
|
|
198
|
+
},
|
|
199
|
+
{
|
|
200
|
+
"opcode": "cameraProfileJson",
|
|
201
|
+
"feature": "calibrationProfilesV1",
|
|
202
|
+
"blockType": "REPORTER",
|
|
203
|
+
"text": "camera profile JSON for [CAMERA_ID]",
|
|
204
|
+
"arguments": { "CAMERA_ID": {
|
|
205
|
+
"type": "STRING",
|
|
206
|
+
"defaultValue": "default"
|
|
207
|
+
} }
|
|
208
|
+
},
|
|
209
|
+
{
|
|
210
|
+
"opcode": "cameraProfileError",
|
|
211
|
+
"feature": "calibrationProfilesV1",
|
|
212
|
+
"blockType": "REPORTER",
|
|
213
|
+
"text": "camera profile error",
|
|
214
|
+
"arguments": {}
|
|
215
|
+
},
|
|
216
|
+
{
|
|
217
|
+
"opcode": "cameraProfileErrorDetail",
|
|
218
|
+
"feature": "calibrationProfilesV1",
|
|
219
|
+
"blockType": "REPORTER",
|
|
220
|
+
"text": "camera profile error detail",
|
|
221
|
+
"arguments": {}
|
|
222
|
+
},
|
|
223
|
+
{
|
|
224
|
+
"opcode": "cameraProfileCompatibility",
|
|
225
|
+
"feature": "calibrationProfilesV1",
|
|
226
|
+
"blockType": "REPORTER",
|
|
227
|
+
"text": "camera profile compatibility for [CAMERA_ID]",
|
|
228
|
+
"arguments": { "CAMERA_ID": {
|
|
229
|
+
"type": "STRING",
|
|
230
|
+
"defaultValue": "default"
|
|
231
|
+
} }
|
|
232
|
+
},
|
|
233
|
+
{
|
|
234
|
+
"opcode": "cameraProfileCompatibilityDetail",
|
|
235
|
+
"feature": "calibrationProfilesV1",
|
|
236
|
+
"blockType": "REPORTER",
|
|
237
|
+
"text": "camera profile compatibility detail for [CAMERA_ID]",
|
|
238
|
+
"arguments": { "CAMERA_ID": {
|
|
239
|
+
"type": "STRING",
|
|
240
|
+
"defaultValue": "default"
|
|
241
|
+
} }
|
|
242
|
+
},
|
|
243
|
+
{
|
|
244
|
+
"opcode": "cameraProfileAdaptation",
|
|
245
|
+
"feature": "calibrationProfilesV1",
|
|
246
|
+
"blockType": "REPORTER",
|
|
247
|
+
"text": "camera profile adaptation for [CAMERA_ID]",
|
|
248
|
+
"arguments": { "CAMERA_ID": {
|
|
249
|
+
"type": "STRING",
|
|
250
|
+
"defaultValue": "default"
|
|
251
|
+
} }
|
|
252
|
+
},
|
|
253
|
+
{
|
|
254
|
+
"opcode": "cameraProfileIntrinsicsJson",
|
|
255
|
+
"feature": "calibrationProfilesV1",
|
|
256
|
+
"blockType": "REPORTER",
|
|
257
|
+
"text": "camera intrinsics JSON for [CAMERA_ID]",
|
|
258
|
+
"arguments": { "CAMERA_ID": {
|
|
259
|
+
"type": "STRING",
|
|
260
|
+
"defaultValue": "default"
|
|
261
|
+
} }
|
|
262
|
+
},
|
|
263
|
+
{
|
|
264
|
+
"opcode": "cameraConditionsJson",
|
|
265
|
+
"feature": "calibrationProfilesV1",
|
|
266
|
+
"blockType": "REPORTER",
|
|
267
|
+
"text": "camera conditions JSON for [CAMERA_ID]",
|
|
268
|
+
"arguments": { "CAMERA_ID": {
|
|
269
|
+
"type": "STRING",
|
|
270
|
+
"defaultValue": "default"
|
|
271
|
+
} }
|
|
272
|
+
},
|
|
273
|
+
{
|
|
274
|
+
"opcode": "cameraConditionsGeneration",
|
|
275
|
+
"feature": "calibrationProfilesV1",
|
|
276
|
+
"blockType": "REPORTER",
|
|
277
|
+
"text": "camera conditions generation for [CAMERA_ID]",
|
|
278
|
+
"arguments": { "CAMERA_ID": {
|
|
279
|
+
"type": "STRING",
|
|
280
|
+
"defaultValue": "default"
|
|
281
|
+
} }
|
|
158
282
|
}
|
|
159
|
-
]
|
|
283
|
+
],
|
|
284
|
+
menus: { "flips": {
|
|
285
|
+
"acceptReporters": true,
|
|
286
|
+
"items": [
|
|
287
|
+
"none",
|
|
288
|
+
"horizontal",
|
|
289
|
+
"vertical",
|
|
290
|
+
"both"
|
|
291
|
+
]
|
|
292
|
+
} }
|
|
160
293
|
};
|
|
161
294
|
//#endregion
|
|
295
|
+
//#region src/calibration/conditions.ts
|
|
296
|
+
function positiveNumber(value) {
|
|
297
|
+
return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
|
|
298
|
+
}
|
|
299
|
+
function nonNegativeNumber(value) {
|
|
300
|
+
return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
|
|
301
|
+
}
|
|
302
|
+
function nonEmptyText(value) {
|
|
303
|
+
if (typeof value !== "string") return void 0;
|
|
304
|
+
const text = value.trim();
|
|
305
|
+
return text.length === 0 ? void 0 : text;
|
|
306
|
+
}
|
|
307
|
+
function pixelCount(value) {
|
|
308
|
+
return Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
|
|
309
|
+
}
|
|
310
|
+
/**
|
|
311
|
+
* Builds the conditions record.
|
|
312
|
+
*
|
|
313
|
+
* Frame size comes from the delivered frame rather than from the track settings: a track can report
|
|
314
|
+
* a requested size that the browser then satisfies with something else, and the number a consumer
|
|
315
|
+
* has to match its intrinsics against is the size of the image it is actually handed.
|
|
316
|
+
*/
|
|
317
|
+
function readCameraConditions(frame, settings = {}) {
|
|
318
|
+
const label = nonEmptyText(frame.label);
|
|
319
|
+
const frameRate = positiveNumber(settings.frameRate);
|
|
320
|
+
const facingMode = nonEmptyText(settings.facingMode);
|
|
321
|
+
const resizeMode = nonEmptyText(settings.resizeMode);
|
|
322
|
+
const zoom = positiveNumber(settings.zoom);
|
|
323
|
+
const focusMode = nonEmptyText(settings.focusMode);
|
|
324
|
+
const focusDistance = nonNegativeNumber(settings.focusDistance);
|
|
325
|
+
return {
|
|
326
|
+
width: pixelCount(frame.width),
|
|
327
|
+
height: pixelCount(frame.height),
|
|
328
|
+
deviceId: nonEmptyText(frame.deviceId) ?? nonEmptyText(settings.deviceId) ?? "",
|
|
329
|
+
previewFlip: frame.previewFlip,
|
|
330
|
+
...label === void 0 ? {} : { label },
|
|
331
|
+
...frameRate === void 0 ? {} : { frameRate },
|
|
332
|
+
...facingMode === void 0 ? {} : { facingMode },
|
|
333
|
+
...resizeMode === void 0 ? {} : { resizeMode },
|
|
334
|
+
...zoom === void 0 ? {} : { zoom },
|
|
335
|
+
...focusMode === void 0 ? {} : { focusMode },
|
|
336
|
+
...focusDistance === void 0 ? {} : { focusDistance }
|
|
337
|
+
};
|
|
338
|
+
}
|
|
339
|
+
//#endregion
|
|
340
|
+
//#region src/calibration/compatibility.ts
|
|
341
|
+
/** Zoom readings are device-reported floats; compare them with a tolerance rather than exactly. */
|
|
342
|
+
var ZOOM_TOLERANCE = 1e-6;
|
|
343
|
+
var FOCUS_DISTANCE_TOLERANCE = 1e-6;
|
|
344
|
+
function finding(code, state, decisive, detail) {
|
|
345
|
+
return {
|
|
346
|
+
code,
|
|
347
|
+
state,
|
|
348
|
+
decisive,
|
|
349
|
+
detail
|
|
350
|
+
};
|
|
351
|
+
}
|
|
352
|
+
function describe(value) {
|
|
353
|
+
return value === void 0 ? "not reported" : String(value);
|
|
354
|
+
}
|
|
355
|
+
/**
|
|
356
|
+
* Compares one optical member.
|
|
357
|
+
*
|
|
358
|
+
* Absent on both sides is agreement, not ignorance: the device reported no such control when the
|
|
359
|
+
* calibration was solved and reports none now. Present on one side only is a change nobody can
|
|
360
|
+
* quantify, so it is left unknown rather than guessed in either direction.
|
|
361
|
+
*/
|
|
362
|
+
function compareMember(code, name, recorded, observed, equal) {
|
|
363
|
+
if (recorded === void 0 && observed === void 0) return finding(code, "matched", true, `Neither the profile nor the camera reports ${name}.`);
|
|
364
|
+
if (recorded === void 0 || observed === void 0) return finding(code, "unknown", true, `${name} is ${describe(recorded)} in the profile and ${describe(observed)} now, so the two cannot be compared.`);
|
|
365
|
+
const same = equal(recorded, observed);
|
|
366
|
+
return finding(code, same ? "matched" : "mismatched", true, same ? `${name} is ${describe(observed)} in both.` : `${name} was ${describe(recorded)} at calibration and is ${describe(observed)} now.`);
|
|
367
|
+
}
|
|
368
|
+
var sameText = (left, right) => left === right;
|
|
369
|
+
var nearlyEqual = (tolerance) => (left, right) => Math.abs(left - right) <= tolerance;
|
|
370
|
+
function captureFindings(capture, conditions) {
|
|
371
|
+
return [
|
|
372
|
+
compareMember("resize-mode", "Resize mode", capture.resizeMode, conditions.resizeMode, sameText),
|
|
373
|
+
compareMember("zoom", "Zoom", capture.zoom, conditions.zoom, nearlyEqual(ZOOM_TOLERANCE)),
|
|
374
|
+
compareMember("focus-mode", "Focus mode", capture.focusMode, conditions.focusMode, sameText),
|
|
375
|
+
compareMember("focus-distance", "Focus distance", capture.focusDistance, conditions.focusDistance, nearlyEqual(FOCUS_DISTANCE_TOLERANCE))
|
|
376
|
+
];
|
|
377
|
+
}
|
|
378
|
+
function imageSizeFinding(profile, conditions) {
|
|
379
|
+
const expected = `${profile.image.width}x${profile.image.height}`;
|
|
380
|
+
if (conditions.width === 0 || conditions.height === 0) return finding("image-size", "unknown", true, `The camera has delivered no frame yet, so its size cannot be compared with the calibrated ${expected}.`);
|
|
381
|
+
const actual = `${conditions.width}x${conditions.height}`;
|
|
382
|
+
return actual === expected ? finding("image-size", "matched", true, `The frame is ${actual}, as calibrated.`) : finding("image-size", "mismatched", true, `The calibration was solved at ${expected} and the camera now delivers ${actual}.`);
|
|
383
|
+
}
|
|
384
|
+
function deviceFindings(profile, conditions) {
|
|
385
|
+
const recordedLabel = profile.device?.label;
|
|
386
|
+
const observedLabel = conditions.label;
|
|
387
|
+
const label = recordedLabel !== void 0 && observedLabel !== void 0 ? finding("device-label", recordedLabel === observedLabel ? "matched" : "mismatched", true, recordedLabel === observedLabel ? `The camera still reports itself as ${observedLabel}.` : `The profile was solved on ${recordedLabel} and the camera now reports ${observedLabel}.`) : finding("device-label", "unknown", false, "A device label is missing on one side, which is normal before the browser grants camera permission.");
|
|
388
|
+
const recordedId = profile.device?.deviceId;
|
|
389
|
+
const observedId = conditions.deviceId.length === 0 ? void 0 : conditions.deviceId;
|
|
390
|
+
return [label, finding("device-id", recordedId !== void 0 && observedId !== void 0 && recordedId === observedId ? "matched" : "unknown", false, "A device id is scoped to one browser and profile, so it changes without the camera changing. It is a hint for ordering candidates, never proof of identity.")];
|
|
391
|
+
}
|
|
392
|
+
/**
|
|
393
|
+
* Judges a profile against the conditions a camera reports.
|
|
394
|
+
*
|
|
395
|
+
* The verdict is `incompatible` when any decisive finding mismatched, `undetermined` when any
|
|
396
|
+
* decisive finding could not be settled, and `compatible` only when every decisive finding matched.
|
|
397
|
+
* Unknown never resolves upward into `compatible`.
|
|
398
|
+
*/
|
|
399
|
+
function evaluateProfileCompatibility(profile, conditions) {
|
|
400
|
+
const findings = [imageSizeFinding(profile, conditions)];
|
|
401
|
+
if (profile.image.undistorted) findings.push(finding("undistorted-frames", "unknown", true, "The profile describes already undistorted images. This extension hands over the camera frames as captured and cannot confirm that something upstream corrects them."));
|
|
402
|
+
if (profile.capture === void 0) findings.push(finding("capture-conditions", "unknown", true, "The profile records no capture conditions, so whether the optics are configured as they were at calibration cannot be decided."));
|
|
403
|
+
else findings.push(...captureFindings(profile.capture, conditions));
|
|
404
|
+
findings.push(finding("frame-rate", "matched", false, `Frame rate was ${describe(profile.capture?.frameRate)} at calibration and is ${describe(conditions.frameRate)} now. It does not change how the lens projects.`), finding("facing-mode", "matched", false, `Facing mode was ${describe(profile.capture?.facingMode)} at calibration and is ${describe(conditions.facingMode)} now.`), ...deviceFindings(profile, conditions));
|
|
405
|
+
const decisive = findings.filter((entry) => entry.decisive);
|
|
406
|
+
return {
|
|
407
|
+
state: decisive.some((entry) => entry.state === "mismatched") ? "incompatible" : decisive.some((entry) => entry.state === "unknown") ? "undetermined" : "compatible",
|
|
408
|
+
findings
|
|
409
|
+
};
|
|
410
|
+
}
|
|
411
|
+
/** The findings that decided the verdict, in the order they were made. */
|
|
412
|
+
function decisiveFindings(report) {
|
|
413
|
+
return report.findings.filter((entry) => entry.decisive && entry.state !== "matched");
|
|
414
|
+
}
|
|
415
|
+
//#endregion
|
|
416
|
+
//#region src/calibration/adaptation.ts
|
|
417
|
+
/** Aspect ratios are compared with a tolerance; reported sizes are whole pixels. */
|
|
418
|
+
var ASPECT_TOLERANCE = .001;
|
|
419
|
+
function adaptProfileToConditions(profile, conditions) {
|
|
420
|
+
const { width: calibratedWidth, height: calibratedHeight } = profile.image;
|
|
421
|
+
const { width, height } = conditions;
|
|
422
|
+
if (width === 0 || height === 0) return {
|
|
423
|
+
state: "unavailable",
|
|
424
|
+
code: "no-frame",
|
|
425
|
+
width,
|
|
426
|
+
height,
|
|
427
|
+
scale: 1,
|
|
428
|
+
detail: "The camera has delivered no frame yet, so there is no size to adapt to."
|
|
429
|
+
};
|
|
430
|
+
if (width === calibratedWidth && height === calibratedHeight) return {
|
|
431
|
+
state: "exact",
|
|
432
|
+
code: "exact",
|
|
433
|
+
intrinsics: profile.intrinsics,
|
|
434
|
+
width,
|
|
435
|
+
height,
|
|
436
|
+
scale: 1,
|
|
437
|
+
detail: `The frame is ${width}x${height}, as calibrated.`
|
|
438
|
+
};
|
|
439
|
+
if (profile.image.undistorted) return {
|
|
440
|
+
state: "unavailable",
|
|
441
|
+
code: "undistorted-frames",
|
|
442
|
+
width,
|
|
443
|
+
height,
|
|
444
|
+
scale: 1,
|
|
445
|
+
detail: "The profile describes already undistorted images, so it cannot be re-expressed for a different frame size here."
|
|
446
|
+
};
|
|
447
|
+
if (profile.capture?.resizeMode === "crop-and-scale") return {
|
|
448
|
+
state: "unavailable",
|
|
449
|
+
code: "cropped",
|
|
450
|
+
width,
|
|
451
|
+
height,
|
|
452
|
+
scale: 1,
|
|
453
|
+
detail: "The track was calibrated with crop-and-scale resizing, so a different frame size may be a crop rather than a scale and the principal point cannot be placed."
|
|
454
|
+
};
|
|
455
|
+
const scaleX = width / calibratedWidth;
|
|
456
|
+
const scaleY = height / calibratedHeight;
|
|
457
|
+
if (Math.abs(scaleX - scaleY) > ASPECT_TOLERANCE) return {
|
|
458
|
+
state: "unavailable",
|
|
459
|
+
code: "aspect-changed",
|
|
460
|
+
width,
|
|
461
|
+
height,
|
|
462
|
+
scale: 1,
|
|
463
|
+
detail: `The calibrated ${calibratedWidth}x${calibratedHeight} and the current ${width}x${height} have different aspect ratios, so the difference is not a scale.`
|
|
464
|
+
};
|
|
465
|
+
const scale = (scaleX + scaleY) / 2;
|
|
466
|
+
return {
|
|
467
|
+
state: "scaled",
|
|
468
|
+
code: "uniform-scale",
|
|
469
|
+
intrinsics: scaleIntrinsics(profile.intrinsics, scale),
|
|
470
|
+
width,
|
|
471
|
+
height,
|
|
472
|
+
scale,
|
|
473
|
+
detail: `The calibrated ${calibratedWidth}x${calibratedHeight} has been scaled by ${scale} to the current ${width}x${height}.`
|
|
474
|
+
};
|
|
475
|
+
}
|
|
476
|
+
function scaleIntrinsics(intrinsics, scale) {
|
|
477
|
+
return {
|
|
478
|
+
fx: intrinsics.fx * scale,
|
|
479
|
+
fy: intrinsics.fy * scale,
|
|
480
|
+
cx: intrinsics.cx * scale,
|
|
481
|
+
cy: intrinsics.cy * scale,
|
|
482
|
+
skew: intrinsics.skew
|
|
483
|
+
};
|
|
484
|
+
}
|
|
485
|
+
/**
|
|
486
|
+
* The intrinsics to use, if there are any.
|
|
487
|
+
*
|
|
488
|
+
* Both conditions have to hold, and they are different questions. Compatibility asks whether this
|
|
489
|
+
* profile describes this camera as it is configured now; adaptation asks whether the numbers can be
|
|
490
|
+
* expressed for the frame size in front of us. A profile can fit the camera and still have no usable
|
|
491
|
+
* form — a crop, say — and it can adapt cleanly while belonging to a different camera entirely.
|
|
492
|
+
*
|
|
493
|
+
* Returning undefined rather than the stored numbers is the whole point. Intrinsics from another
|
|
494
|
+
* configuration do not fail visibly: they project, and the geometry that comes back looks like a
|
|
495
|
+
* slightly different camera pose rather than like a mistake.
|
|
496
|
+
*/
|
|
497
|
+
function usableIntrinsics(compatibility, adaptation) {
|
|
498
|
+
if (compatibility.state !== "compatible") return void 0;
|
|
499
|
+
if (adaptation.intrinsics === void 0) return void 0;
|
|
500
|
+
return {
|
|
501
|
+
...adaptation.intrinsics,
|
|
502
|
+
width: adaptation.width,
|
|
503
|
+
height: adaptation.height,
|
|
504
|
+
scale: adaptation.scale,
|
|
505
|
+
adaptation: adaptation.state
|
|
506
|
+
};
|
|
507
|
+
}
|
|
508
|
+
//#endregion
|
|
509
|
+
//#region src/calibration/profile.ts
|
|
510
|
+
var CAMERA_INTRINSIC_PROFILE_SCHEMA = "twcs/camera-intrinsics";
|
|
511
|
+
/** The application-specific format this contract replaces. Read for migration, never written. */
|
|
512
|
+
var LEGACY_CALIBRATION_SCHEMA = "twrmc/camera-calibration";
|
|
513
|
+
var IDENTIFIER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,63}$/;
|
|
514
|
+
var UTC_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?Z$/;
|
|
515
|
+
var MAXIMUM_IMAGE_EDGE = 16384;
|
|
516
|
+
var MAXIMUM_PIXEL_MAGNITUDE = 1e7;
|
|
517
|
+
var MAXIMUM_DISTORTION_MAGNITUDE = 1e4;
|
|
518
|
+
var MAXIMUM_SAMPLE_COUNT = 1e4;
|
|
519
|
+
var MAXIMUM_REPROJECTION_ERROR_PX = 1e4;
|
|
520
|
+
var MAXIMUM_TEXT_LENGTH = 256;
|
|
521
|
+
var MAXIMUM_FRAME_RATE = 1e3;
|
|
522
|
+
var MAXIMUM_ZOOM = 1e3;
|
|
523
|
+
var MAXIMUM_FOCUS_DISTANCE = 1e4;
|
|
524
|
+
var MAXIMUM_SCAN_DEPTH = 16;
|
|
525
|
+
var AFFINE_ROW_TOLERANCE = 1e-6;
|
|
526
|
+
var DISTORTION_MODELS = [
|
|
527
|
+
"none",
|
|
528
|
+
"brown-conrady",
|
|
529
|
+
"kannala-brandt"
|
|
530
|
+
];
|
|
531
|
+
var RESIZE_MODES = ["none", "crop-and-scale"];
|
|
532
|
+
var FOCUS_MODES = [
|
|
533
|
+
"none",
|
|
534
|
+
"manual",
|
|
535
|
+
"single-shot",
|
|
536
|
+
"continuous"
|
|
537
|
+
];
|
|
538
|
+
/**
|
|
539
|
+
* Coefficient counts each model accepts.
|
|
540
|
+
*
|
|
541
|
+
* The Brown-Conrady lengths are the OpenCV sets that consumers already handle: four, the usual five
|
|
542
|
+
* with k3, and eight for the rational model. Longer OpenCV vectors (thin prism, tilted sensor) are
|
|
543
|
+
* rejected rather than carried, because no consumer in this family implements them and a profile
|
|
544
|
+
* that is accepted but only partly applied is worse than one that is refused.
|
|
545
|
+
*/
|
|
546
|
+
var DISTORTION_COEFFICIENT_LENGTHS = {
|
|
547
|
+
none: [0],
|
|
548
|
+
"brown-conrady": [
|
|
549
|
+
4,
|
|
550
|
+
5,
|
|
551
|
+
8
|
|
552
|
+
],
|
|
553
|
+
"kannala-brandt": [4]
|
|
554
|
+
};
|
|
555
|
+
/**
|
|
556
|
+
* Key names that carry pairing or authentication material.
|
|
557
|
+
*
|
|
558
|
+
* Signaling data is short-lived session state and a calibration profile is a document operators keep
|
|
559
|
+
* and copy between venues. Rejecting the whole document is deliberate: a profile that reached here
|
|
560
|
+
* carrying an SDP is evidence that something upstream is mixing the two, and quietly stripping the
|
|
561
|
+
* key would hide that.
|
|
562
|
+
*/
|
|
563
|
+
var FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
|
|
564
|
+
"accesstoken",
|
|
565
|
+
"answer",
|
|
566
|
+
"apikey",
|
|
567
|
+
"authorization",
|
|
568
|
+
"candidate",
|
|
569
|
+
"credential",
|
|
570
|
+
"credentials",
|
|
571
|
+
"ice",
|
|
572
|
+
"icecandidate",
|
|
573
|
+
"offer",
|
|
574
|
+
"passphrase",
|
|
575
|
+
"password",
|
|
576
|
+
"secret",
|
|
577
|
+
"sdp",
|
|
578
|
+
"token"
|
|
579
|
+
]);
|
|
580
|
+
var ProfileRejection = class extends Error {
|
|
581
|
+
constructor(detail) {
|
|
582
|
+
super(detail.message);
|
|
583
|
+
this.name = "ProfileRejection";
|
|
584
|
+
this.detail = detail;
|
|
585
|
+
}
|
|
586
|
+
};
|
|
587
|
+
function reject(code, path, message) {
|
|
588
|
+
throw new ProfileRejection({
|
|
589
|
+
code,
|
|
590
|
+
path,
|
|
591
|
+
message
|
|
592
|
+
});
|
|
593
|
+
}
|
|
594
|
+
function isRecord(value) {
|
|
595
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
596
|
+
}
|
|
597
|
+
function member(path, name) {
|
|
598
|
+
return path.length === 0 ? name : `${path}.${name}`;
|
|
599
|
+
}
|
|
600
|
+
/** Normalizes a key so `ICE-Candidate`, `iceCandidate` and `ice_candidate` all match one entry. */
|
|
601
|
+
function comparableKey(key) {
|
|
602
|
+
return key.toLowerCase().replace(/[^a-z0-9]/g, "");
|
|
603
|
+
}
|
|
604
|
+
function assertNoForbiddenKeys(value, path, depth, seen) {
|
|
605
|
+
if (depth > MAXIMUM_SCAN_DEPTH) reject("invalid-value", path, "The document is nested more deeply than a profile ever is.");
|
|
606
|
+
if (typeof value !== "object" || value === null) return;
|
|
607
|
+
if (seen.has(value)) reject("invalid-value", path, "The document contains a cycle.");
|
|
608
|
+
seen.add(value);
|
|
609
|
+
if (Array.isArray(value)) {
|
|
610
|
+
value.forEach((item, index) => assertNoForbiddenKeys(item, `${path}[${index}]`, depth + 1, seen));
|
|
611
|
+
return;
|
|
612
|
+
}
|
|
613
|
+
for (const [key, child] of Object.entries(value)) {
|
|
614
|
+
if (FORBIDDEN_KEYS.has(comparableKey(key))) reject("forbidden-field", member(path, key), "Pairing and authentication material must not travel inside a calibration profile.");
|
|
615
|
+
assertNoForbiddenKeys(child, member(path, key), depth + 1, seen);
|
|
616
|
+
}
|
|
617
|
+
}
|
|
618
|
+
function requireRecord(value, path) {
|
|
619
|
+
if (!isRecord(value)) reject(path.length === 0 ? "not-an-object" : "invalid-type", path, "Expected an object.");
|
|
620
|
+
return value;
|
|
621
|
+
}
|
|
622
|
+
/** Rejects unknown members as well as missing ones, so an unrecognized field is never ignored. */
|
|
623
|
+
function requireExactKeys(record, path, required, optional = []) {
|
|
624
|
+
const known = /* @__PURE__ */ new Set([...required, ...optional]);
|
|
625
|
+
for (const key of Object.keys(record)) if (!known.has(key)) reject("unexpected-field", member(path, key), "Unknown member.");
|
|
626
|
+
for (const key of required) if (!(key in record)) reject("missing-field", member(path, key), "Required member is missing.");
|
|
627
|
+
}
|
|
628
|
+
function requireText(value, path) {
|
|
629
|
+
if (typeof value !== "string") reject("invalid-type", path, "Expected a string.");
|
|
630
|
+
if (value.length === 0 || value.length > MAXIMUM_TEXT_LENGTH) reject("out-of-range", path, `Expected between 1 and ${MAXIMUM_TEXT_LENGTH} characters.`);
|
|
631
|
+
return value;
|
|
632
|
+
}
|
|
633
|
+
function requireIdentifier(value, path) {
|
|
634
|
+
const text = requireText(value, path);
|
|
635
|
+
if (!IDENTIFIER_PATTERN.test(text)) reject("invalid-value", path, "Expected letters, digits, dot, underscore, colon or hyphen.");
|
|
636
|
+
return text;
|
|
637
|
+
}
|
|
638
|
+
function requireUtcTimestamp(value, path) {
|
|
639
|
+
const text = requireText(value, path);
|
|
640
|
+
if (!UTC_TIMESTAMP_PATTERN.test(text) || !Number.isFinite(Date.parse(text))) reject("invalid-value", path, "Expected an RFC 3339 timestamp in UTC, such as 2026-09-15T04:05:06Z.");
|
|
641
|
+
return text;
|
|
642
|
+
}
|
|
643
|
+
function requireBoolean(value, path) {
|
|
644
|
+
if (typeof value !== "boolean") reject("invalid-type", path, "Expected a boolean.");
|
|
645
|
+
return value;
|
|
646
|
+
}
|
|
647
|
+
function requireFinite(value, path) {
|
|
648
|
+
if (typeof value !== "number") reject("invalid-type", path, "Expected a number.");
|
|
649
|
+
if (!Number.isFinite(value)) reject("invalid-value", path, "Expected a finite number.");
|
|
650
|
+
return value;
|
|
651
|
+
}
|
|
652
|
+
function requireInteger(value, path, minimum, maximum) {
|
|
653
|
+
const numeric = requireFinite(value, path);
|
|
654
|
+
if (!Number.isInteger(numeric)) reject("invalid-value", path, "Expected an integer.");
|
|
655
|
+
if (numeric < minimum || numeric > maximum) reject("out-of-range", path, `Expected between ${minimum} and ${maximum}.`);
|
|
656
|
+
return numeric;
|
|
657
|
+
}
|
|
658
|
+
function requireBounded(value, path, minimum, maximum) {
|
|
659
|
+
const numeric = requireFinite(value, path);
|
|
660
|
+
if (numeric < minimum || numeric > maximum) reject("out-of-range", path, `Expected between ${minimum} and ${maximum}.`);
|
|
661
|
+
return numeric;
|
|
662
|
+
}
|
|
663
|
+
function requireLiteral(value, path, expected, code) {
|
|
664
|
+
if (value !== expected) reject(code, path, `Expected ${JSON.stringify(expected)}.`);
|
|
665
|
+
return expected;
|
|
666
|
+
}
|
|
667
|
+
function readImage(value, path) {
|
|
668
|
+
const record = requireRecord(value, path);
|
|
669
|
+
requireExactKeys(record, path, [
|
|
670
|
+
"width",
|
|
671
|
+
"height",
|
|
672
|
+
"undistorted"
|
|
673
|
+
]);
|
|
674
|
+
return {
|
|
675
|
+
width: requireInteger(record["width"], member(path, "width"), 1, MAXIMUM_IMAGE_EDGE),
|
|
676
|
+
height: requireInteger(record["height"], member(path, "height"), 1, MAXIMUM_IMAGE_EDGE),
|
|
677
|
+
undistorted: requireBoolean(record["undistorted"], member(path, "undistorted"))
|
|
678
|
+
};
|
|
679
|
+
}
|
|
680
|
+
/**
|
|
681
|
+
* Reads the pinhole parameters.
|
|
682
|
+
*
|
|
683
|
+
* The principal point is allowed to sit outside the frame — a cropped or shifted sensor puts it
|
|
684
|
+
* there legitimately — but not arbitrarily far, because a principal point far outside the image is
|
|
685
|
+
* the signature of values given in the wrong unit rather than of an unusual lens.
|
|
686
|
+
*/
|
|
687
|
+
function readIntrinsics(value, path, image) {
|
|
688
|
+
const record = requireRecord(value, path);
|
|
689
|
+
requireExactKeys(record, path, [
|
|
690
|
+
"fx",
|
|
691
|
+
"fy",
|
|
692
|
+
"cx",
|
|
693
|
+
"cy",
|
|
694
|
+
"skew"
|
|
695
|
+
]);
|
|
696
|
+
return {
|
|
697
|
+
fx: requireBounded(record["fx"], member(path, "fx"), Number.MIN_VALUE, MAXIMUM_PIXEL_MAGNITUDE),
|
|
698
|
+
fy: requireBounded(record["fy"], member(path, "fy"), Number.MIN_VALUE, MAXIMUM_PIXEL_MAGNITUDE),
|
|
699
|
+
cx: requireBounded(record["cx"], member(path, "cx"), -image.width, image.width * 2),
|
|
700
|
+
cy: requireBounded(record["cy"], member(path, "cy"), -image.height, image.height * 2),
|
|
701
|
+
skew: requireBounded(record["skew"], member(path, "skew"), -1e7, MAXIMUM_PIXEL_MAGNITUDE)
|
|
702
|
+
};
|
|
703
|
+
}
|
|
704
|
+
function readDistortion(value, path) {
|
|
705
|
+
const record = requireRecord(value, path);
|
|
706
|
+
requireExactKeys(record, path, ["model", "coefficients"]);
|
|
707
|
+
const modelPath = member(path, "model");
|
|
708
|
+
const rawModel = record["model"];
|
|
709
|
+
if (typeof rawModel !== "string" || !DISTORTION_MODELS.includes(rawModel)) reject("invalid-distortion", modelPath, `Expected one of ${DISTORTION_MODELS.join(", ")}.`);
|
|
710
|
+
const model = rawModel;
|
|
711
|
+
const coefficientsPath = member(path, "coefficients");
|
|
712
|
+
const rawCoefficients = record["coefficients"];
|
|
713
|
+
if (!Array.isArray(rawCoefficients)) reject("invalid-type", coefficientsPath, "Expected an array.");
|
|
714
|
+
const allowed = DISTORTION_COEFFICIENT_LENGTHS[model];
|
|
715
|
+
if (!allowed.includes(rawCoefficients.length)) reject("invalid-distortion", coefficientsPath, `The ${model} model takes ${allowed.join(" or ")} coefficients, not ${rawCoefficients.length}.`);
|
|
716
|
+
return {
|
|
717
|
+
model,
|
|
718
|
+
coefficients: rawCoefficients.map((coefficient, index) => requireBounded(coefficient, `${coefficientsPath}[${index}]`, -1e4, MAXIMUM_DISTORTION_MAGNITUDE))
|
|
719
|
+
};
|
|
720
|
+
}
|
|
721
|
+
function requireEnum(value, path, allowed) {
|
|
722
|
+
const text = requireText(value, path);
|
|
723
|
+
if (!allowed.includes(text)) reject("invalid-value", path, `Expected one of ${allowed.join(", ")}.`);
|
|
724
|
+
return text;
|
|
725
|
+
}
|
|
726
|
+
function readCapture(value, path) {
|
|
727
|
+
const record = requireRecord(value, path);
|
|
728
|
+
requireExactKeys(record, path, [], [
|
|
729
|
+
"frameRate",
|
|
730
|
+
"facingMode",
|
|
731
|
+
"resizeMode",
|
|
732
|
+
"zoom",
|
|
733
|
+
"focusMode",
|
|
734
|
+
"focusDistance"
|
|
735
|
+
]);
|
|
736
|
+
const read = (name, reader) => name in record ? reader(record[name], member(path, name)) : void 0;
|
|
737
|
+
const frameRate = read("frameRate", (raw, at) => requireBounded(raw, at, Number.MIN_VALUE, MAXIMUM_FRAME_RATE));
|
|
738
|
+
const facingMode = read("facingMode", requireText);
|
|
739
|
+
const resizeMode = read("resizeMode", (raw, at) => requireEnum(raw, at, RESIZE_MODES));
|
|
740
|
+
const zoom = read("zoom", (raw, at) => requireBounded(raw, at, Number.MIN_VALUE, MAXIMUM_ZOOM));
|
|
741
|
+
const focusMode = read("focusMode", (raw, at) => requireEnum(raw, at, FOCUS_MODES));
|
|
742
|
+
const focusDistance = read("focusDistance", (raw, at) => requireBounded(raw, at, 0, MAXIMUM_FOCUS_DISTANCE));
|
|
743
|
+
return {
|
|
744
|
+
...frameRate === void 0 ? {} : { frameRate },
|
|
745
|
+
...facingMode === void 0 ? {} : { facingMode },
|
|
746
|
+
...resizeMode === void 0 ? {} : { resizeMode },
|
|
747
|
+
...zoom === void 0 ? {} : { zoom },
|
|
748
|
+
...focusMode === void 0 ? {} : { focusMode },
|
|
749
|
+
...focusDistance === void 0 ? {} : { focusDistance }
|
|
750
|
+
};
|
|
751
|
+
}
|
|
752
|
+
function readQuality(value, path) {
|
|
753
|
+
const record = requireRecord(value, path);
|
|
754
|
+
requireExactKeys(record, path, ["sampleCount", "reprojectionErrorPx"]);
|
|
755
|
+
return {
|
|
756
|
+
sampleCount: requireInteger(record["sampleCount"], member(path, "sampleCount"), 1, MAXIMUM_SAMPLE_COUNT),
|
|
757
|
+
reprojectionErrorPx: requireBounded(record["reprojectionErrorPx"], member(path, "reprojectionErrorPx"), 0, MAXIMUM_REPROJECTION_ERROR_PX)
|
|
758
|
+
};
|
|
759
|
+
}
|
|
760
|
+
function readDevice(value, path) {
|
|
761
|
+
const record = requireRecord(value, path);
|
|
762
|
+
requireExactKeys(record, path, [], ["label", "deviceId"]);
|
|
763
|
+
const label = "label" in record ? requireText(record["label"], member(path, "label")) : void 0;
|
|
764
|
+
const deviceId = "deviceId" in record ? requireText(record["deviceId"], member(path, "deviceId")) : void 0;
|
|
765
|
+
return {
|
|
766
|
+
...label === void 0 ? {} : { label },
|
|
767
|
+
...deviceId === void 0 ? {} : { deviceId }
|
|
768
|
+
};
|
|
769
|
+
}
|
|
770
|
+
function readProfile(input) {
|
|
771
|
+
assertNoForbiddenKeys(input, "", 0, /* @__PURE__ */ new WeakSet());
|
|
772
|
+
const record = requireRecord(input, "");
|
|
773
|
+
requireLiteral(record["schema"], "schema", CAMERA_INTRINSIC_PROFILE_SCHEMA, "unsupported-schema");
|
|
774
|
+
requireLiteral(record["version"], "version", 1, "unsupported-version");
|
|
775
|
+
requireExactKeys(record, "", [
|
|
776
|
+
"schema",
|
|
777
|
+
"version",
|
|
778
|
+
"profileId",
|
|
779
|
+
"cameraId",
|
|
780
|
+
"calibratedAt",
|
|
781
|
+
"producer",
|
|
782
|
+
"cameraModel",
|
|
783
|
+
"image",
|
|
784
|
+
"intrinsics",
|
|
785
|
+
"distortion"
|
|
786
|
+
], [
|
|
787
|
+
"capture",
|
|
788
|
+
"quality",
|
|
789
|
+
"device"
|
|
790
|
+
]);
|
|
791
|
+
const image = readImage(record["image"], "image");
|
|
792
|
+
const distortion = readDistortion(record["distortion"], "distortion");
|
|
793
|
+
if (image.undistorted && distortion.model !== "none") reject("inconsistent-profile", "distortion.model", "A profile for an already undistorted image cannot also carry distortion coefficients.");
|
|
794
|
+
const capture = "capture" in record ? readCapture(record["capture"], "capture") : void 0;
|
|
795
|
+
const quality = "quality" in record ? readQuality(record["quality"], "quality") : void 0;
|
|
796
|
+
const device = "device" in record ? readDevice(record["device"], "device") : void 0;
|
|
797
|
+
return {
|
|
798
|
+
schema: CAMERA_INTRINSIC_PROFILE_SCHEMA,
|
|
799
|
+
version: 1,
|
|
800
|
+
profileId: requireIdentifier(record["profileId"], "profileId"),
|
|
801
|
+
cameraId: requireIdentifier(record["cameraId"], "cameraId"),
|
|
802
|
+
calibratedAt: requireUtcTimestamp(record["calibratedAt"], "calibratedAt"),
|
|
803
|
+
producer: requireText(record["producer"], "producer"),
|
|
804
|
+
cameraModel: requireLiteral(record["cameraModel"], "cameraModel", "pinhole", "invalid-value"),
|
|
805
|
+
image,
|
|
806
|
+
intrinsics: readIntrinsics(record["intrinsics"], "intrinsics", image),
|
|
807
|
+
distortion,
|
|
808
|
+
...capture === void 0 ? {} : { capture },
|
|
809
|
+
...quality === void 0 ? {} : { quality },
|
|
810
|
+
...device === void 0 ? {} : { device }
|
|
811
|
+
};
|
|
812
|
+
}
|
|
813
|
+
function toResult(read) {
|
|
814
|
+
try {
|
|
815
|
+
return {
|
|
816
|
+
ok: true,
|
|
817
|
+
profile: read()
|
|
818
|
+
};
|
|
819
|
+
} catch (error) {
|
|
820
|
+
if (error instanceof ProfileRejection) return {
|
|
821
|
+
ok: false,
|
|
822
|
+
error: error.detail
|
|
823
|
+
};
|
|
824
|
+
throw error;
|
|
825
|
+
}
|
|
826
|
+
}
|
|
827
|
+
/**
|
|
828
|
+
* Reads whichever profile format a document is written in.
|
|
829
|
+
*
|
|
830
|
+
* An operator holding a file does not know, and should not have to know, which of two schemas it
|
|
831
|
+
* uses; they know they calibrated this camera once and kept the result. Dispatching on the document
|
|
832
|
+
* itself means one entry point accepts both, and the profile that comes out records where it came
|
|
833
|
+
* from in `producer`, so nothing about the conversion is hidden.
|
|
834
|
+
*
|
|
835
|
+
* Only the declared schema decides. A document that says nothing recognizable is refused by the
|
|
836
|
+
* current parser, which names what it expected.
|
|
837
|
+
*/
|
|
838
|
+
function readCameraProfileDocument(input) {
|
|
839
|
+
if (isRecord(input) && input["schema"] === "twrmc/camera-calibration") return adoptLegacyCameraCalibration(input);
|
|
840
|
+
return parseCameraIntrinsicProfile(input);
|
|
841
|
+
}
|
|
842
|
+
/** Validates a parsed document and returns a normalized profile, or the reason it was refused. */
|
|
843
|
+
function parseCameraIntrinsicProfile(input) {
|
|
844
|
+
return toResult(() => readProfile(input));
|
|
845
|
+
}
|
|
846
|
+
/**
|
|
847
|
+
* Renders a profile as JSON with a fixed member order.
|
|
848
|
+
*
|
|
849
|
+
* Stable output means the same profile always produces the same bytes, so a file can be compared or
|
|
850
|
+
* hashed to tell whether two machines really hold the same calibration.
|
|
851
|
+
*/
|
|
852
|
+
function orderedCapture(capture) {
|
|
853
|
+
const members = [
|
|
854
|
+
["frameRate", capture.frameRate],
|
|
855
|
+
["facingMode", capture.facingMode],
|
|
856
|
+
["resizeMode", capture.resizeMode],
|
|
857
|
+
["zoom", capture.zoom],
|
|
858
|
+
["focusMode", capture.focusMode],
|
|
859
|
+
["focusDistance", capture.focusDistance]
|
|
860
|
+
];
|
|
861
|
+
return Object.fromEntries(members.filter((entry) => entry[1] !== void 0));
|
|
862
|
+
}
|
|
863
|
+
function serializeCameraIntrinsicProfile(profile) {
|
|
864
|
+
const ordered = {
|
|
865
|
+
schema: profile.schema,
|
|
866
|
+
version: profile.version,
|
|
867
|
+
profileId: profile.profileId,
|
|
868
|
+
cameraId: profile.cameraId,
|
|
869
|
+
calibratedAt: profile.calibratedAt,
|
|
870
|
+
producer: profile.producer,
|
|
871
|
+
cameraModel: profile.cameraModel,
|
|
872
|
+
image: {
|
|
873
|
+
width: profile.image.width,
|
|
874
|
+
height: profile.image.height,
|
|
875
|
+
undistorted: profile.image.undistorted
|
|
876
|
+
},
|
|
877
|
+
intrinsics: {
|
|
878
|
+
fx: profile.intrinsics.fx,
|
|
879
|
+
fy: profile.intrinsics.fy,
|
|
880
|
+
cx: profile.intrinsics.cx,
|
|
881
|
+
cy: profile.intrinsics.cy,
|
|
882
|
+
skew: profile.intrinsics.skew
|
|
883
|
+
},
|
|
884
|
+
distortion: {
|
|
885
|
+
model: profile.distortion.model,
|
|
886
|
+
coefficients: [...profile.distortion.coefficients]
|
|
887
|
+
},
|
|
888
|
+
...profile.capture === void 0 ? {} : { capture: orderedCapture(profile.capture) },
|
|
889
|
+
...profile.quality === void 0 ? {} : { quality: {
|
|
890
|
+
sampleCount: profile.quality.sampleCount,
|
|
891
|
+
reprojectionErrorPx: profile.quality.reprojectionErrorPx
|
|
892
|
+
} },
|
|
893
|
+
...profile.device === void 0 ? {} : { device: {
|
|
894
|
+
...profile.device.label === void 0 ? {} : { label: profile.device.label },
|
|
895
|
+
...profile.device.deviceId === void 0 ? {} : { deviceId: profile.device.deviceId }
|
|
896
|
+
} }
|
|
897
|
+
};
|
|
898
|
+
return `${JSON.stringify(ordered, null, 2)}\n`;
|
|
899
|
+
}
|
|
900
|
+
function readLegacyMatrixRow(matrix, offset, expected) {
|
|
901
|
+
expected.forEach((value, index) => {
|
|
902
|
+
const actual = requireFinite(matrix[offset + index], `intrinsicMatrix[${offset + index}]`);
|
|
903
|
+
if (Math.abs(actual - value) > AFFINE_ROW_TOLERANCE) reject("inconsistent-profile", `intrinsicMatrix[${offset + index}]`, `Expected ${value} in the intrinsic matrix; the value read as ${actual}.`);
|
|
904
|
+
});
|
|
905
|
+
}
|
|
906
|
+
/**
|
|
907
|
+
* Converts a `twrmc/camera-calibration` v1 document into this contract.
|
|
908
|
+
*
|
|
909
|
+
* The world pose the old format carried is deliberately dropped. It was the extrinsic of whichever
|
|
910
|
+
* calibration sample happened to be last, so treating it as a placement in a shared world frame puts
|
|
911
|
+
* a camera somewhere it has never been. Placement belongs to whoever solves it against a common
|
|
912
|
+
* reference, and a profile that simply lacks it is honest about what it knows.
|
|
913
|
+
*
|
|
914
|
+
* Quality is dropped for the same reason: the old format recorded none, and inventing a sample count
|
|
915
|
+
* or a reprojection error would turn "unknown" into a measurement.
|
|
916
|
+
*/
|
|
917
|
+
function adoptLegacyCameraCalibration(input) {
|
|
918
|
+
return toResult(() => {
|
|
919
|
+
assertNoForbiddenKeys(input, "", 0, /* @__PURE__ */ new WeakSet());
|
|
920
|
+
const record = requireRecord(input, "");
|
|
921
|
+
requireLiteral(record["schema"], "schema", LEGACY_CALIBRATION_SCHEMA, "unsupported-schema");
|
|
922
|
+
requireLiteral(record["version"], "version", 1, "unsupported-version");
|
|
923
|
+
requireExactKeys(record, "", [
|
|
924
|
+
"schema",
|
|
925
|
+
"version",
|
|
926
|
+
"calibrationId",
|
|
927
|
+
"cameraId",
|
|
928
|
+
"imageWidth",
|
|
929
|
+
"imageHeight",
|
|
930
|
+
"intrinsicMatrix",
|
|
931
|
+
"distortionCoefficients",
|
|
932
|
+
"calibratedAt"
|
|
933
|
+
], ["worldFromCameraMatrix", "worldUnit"]);
|
|
934
|
+
const matrix = record["intrinsicMatrix"];
|
|
935
|
+
if (!Array.isArray(matrix) || matrix.length !== 9) reject("invalid-value", "intrinsicMatrix", "Expected nine numbers in row-major order.");
|
|
936
|
+
readLegacyMatrixRow(matrix, 3, [0]);
|
|
937
|
+
readLegacyMatrixRow(matrix, 6, [
|
|
938
|
+
0,
|
|
939
|
+
0,
|
|
940
|
+
1
|
|
941
|
+
]);
|
|
942
|
+
const rawCoefficients = record["distortionCoefficients"];
|
|
943
|
+
if (!Array.isArray(rawCoefficients)) reject("invalid-type", "distortionCoefficients", "Expected an array.");
|
|
944
|
+
const model = rawCoefficients.length === 0 ? "none" : "brown-conrady";
|
|
945
|
+
return readProfile({
|
|
946
|
+
schema: CAMERA_INTRINSIC_PROFILE_SCHEMA,
|
|
947
|
+
version: 1,
|
|
948
|
+
profileId: record["calibrationId"],
|
|
949
|
+
cameraId: record["cameraId"],
|
|
950
|
+
calibratedAt: record["calibratedAt"],
|
|
951
|
+
producer: `${LEGACY_CALIBRATION_SCHEMA} v1`,
|
|
952
|
+
cameraModel: "pinhole",
|
|
953
|
+
image: {
|
|
954
|
+
width: record["imageWidth"],
|
|
955
|
+
height: record["imageHeight"],
|
|
956
|
+
undistorted: false
|
|
957
|
+
},
|
|
958
|
+
intrinsics: {
|
|
959
|
+
fx: matrix[0],
|
|
960
|
+
fy: matrix[4],
|
|
961
|
+
cx: matrix[2],
|
|
962
|
+
cy: matrix[5],
|
|
963
|
+
skew: matrix[1]
|
|
964
|
+
},
|
|
965
|
+
distortion: {
|
|
966
|
+
model,
|
|
967
|
+
coefficients: rawCoefficients
|
|
968
|
+
}
|
|
969
|
+
});
|
|
970
|
+
});
|
|
971
|
+
}
|
|
972
|
+
//#endregion
|
|
973
|
+
//#region src/calibration/registry.ts
|
|
974
|
+
/**
|
|
975
|
+
* The profiles this runtime knows about.
|
|
976
|
+
*
|
|
977
|
+
* Producer-agnostic by construction: a profile arrives as a document that
|
|
978
|
+
* either passes validation or does not, and nothing here can tell chessboard
|
|
979
|
+
* calibration from an operator pasting JSON. Naming a producing extension would
|
|
980
|
+
* undo the split that keeps this package free of runtime dependencies.
|
|
981
|
+
*
|
|
982
|
+
* Registration is keyed by `cameraId`, not by `profileId`: a camera has one
|
|
983
|
+
* calibration in force at a time, and a fresh solve replaces the previous one
|
|
984
|
+
* rather than accumulating beside it.
|
|
985
|
+
*/
|
|
986
|
+
var CameraProfileRegistry = class {
|
|
987
|
+
constructor() {
|
|
988
|
+
this.profiles = /* @__PURE__ */ new Map();
|
|
989
|
+
}
|
|
990
|
+
/**
|
|
991
|
+
* Validates a document and, only if it passes, stores it.
|
|
992
|
+
*
|
|
993
|
+
* Both the current contract and the `twrmc/camera-calibration` file an operator may still be
|
|
994
|
+
* carrying are accepted; the second is converted on the way in, dropping the world pose it
|
|
995
|
+
* carried rather than letting a stale extrinsic arrive as a placement.
|
|
996
|
+
*
|
|
997
|
+
* Nothing is written before the document has been checked. A half-registered
|
|
998
|
+
* profile would be indistinguishable from a good one at the point of use.
|
|
999
|
+
*/
|
|
1000
|
+
register(document) {
|
|
1001
|
+
const result = readCameraProfileDocument(document);
|
|
1002
|
+
if (!result.ok) return result;
|
|
1003
|
+
this.profiles.set(result.profile.cameraId, result.profile);
|
|
1004
|
+
return result;
|
|
1005
|
+
}
|
|
1006
|
+
forget(cameraId) {
|
|
1007
|
+
return this.profiles.delete(cameraId.trim());
|
|
1008
|
+
}
|
|
1009
|
+
clear() {
|
|
1010
|
+
this.profiles.clear();
|
|
1011
|
+
}
|
|
1012
|
+
get(cameraId) {
|
|
1013
|
+
return this.profiles.get(cameraId.trim());
|
|
1014
|
+
}
|
|
1015
|
+
has(cameraId) {
|
|
1016
|
+
return this.profiles.has(cameraId.trim());
|
|
1017
|
+
}
|
|
1018
|
+
cameraIds() {
|
|
1019
|
+
return [...this.profiles.keys()].sort();
|
|
1020
|
+
}
|
|
1021
|
+
/**
|
|
1022
|
+
* The profile for a camera, judged against how that camera is configured now.
|
|
1023
|
+
*
|
|
1024
|
+
* Absent when the camera has never been calibrated. Callers that need one say so themselves.
|
|
1025
|
+
*/
|
|
1026
|
+
assess(cameraId, conditions) {
|
|
1027
|
+
const profile = this.get(cameraId);
|
|
1028
|
+
if (!profile) return void 0;
|
|
1029
|
+
const compatibility = evaluateProfileCompatibility(profile, conditions);
|
|
1030
|
+
const adaptation = adaptProfileToConditions(profile, conditions);
|
|
1031
|
+
const usable = usableIntrinsics(compatibility, adaptation);
|
|
1032
|
+
return {
|
|
1033
|
+
profile,
|
|
1034
|
+
compatibility,
|
|
1035
|
+
adaptation,
|
|
1036
|
+
...usable === void 0 ? {} : { usable }
|
|
1037
|
+
};
|
|
1038
|
+
}
|
|
1039
|
+
};
|
|
1040
|
+
//#endregion
|
|
1041
|
+
//#region src/runtime-capability.ts
|
|
1042
|
+
var runtimeCapabilityKey = "kubohiroyaCameraSourceCapability";
|
|
1043
|
+
function createRuntimeCapability(host) {
|
|
1044
|
+
const capability = {
|
|
1045
|
+
version: 1,
|
|
1046
|
+
requireVersion(version) {
|
|
1047
|
+
if (version !== 1) throw new Error(`Unsupported Camera Source runtime capability version: ${version}; this build provides 1.`);
|
|
1048
|
+
return capability;
|
|
1049
|
+
},
|
|
1050
|
+
registerProfile: (document) => host.registerProfile(document),
|
|
1051
|
+
forgetProfile: (cameraId) => host.forgetProfile(cameraId),
|
|
1052
|
+
profileFor: (cameraId) => host.profileFor(cameraId),
|
|
1053
|
+
calibratedCameras: () => host.calibratedCameras(),
|
|
1054
|
+
assessProfile: (cameraId) => host.assessProfile(cameraId),
|
|
1055
|
+
intrinsicsFor: (cameraId) => host.intrinsicsFor(cameraId),
|
|
1056
|
+
conditionsFor: (cameraId) => host.conditionsFor(cameraId),
|
|
1057
|
+
conditionsGeneration: (cameraId) => host.conditionsGeneration(cameraId)
|
|
1058
|
+
};
|
|
1059
|
+
return Object.freeze(capability);
|
|
1060
|
+
}
|
|
1061
|
+
//#endregion
|
|
1062
|
+
//#region src/flip.ts
|
|
1063
|
+
var FLIPS = [
|
|
1064
|
+
"none",
|
|
1065
|
+
"horizontal",
|
|
1066
|
+
"vertical",
|
|
1067
|
+
"both"
|
|
1068
|
+
];
|
|
1069
|
+
function isFlip(value) {
|
|
1070
|
+
return typeof value === "string" && FLIPS.includes(value);
|
|
1071
|
+
}
|
|
1072
|
+
/** Reads a flip, accepting the boolean the older API used for left-right. */
|
|
1073
|
+
function toFlip(value, fallback = "none") {
|
|
1074
|
+
if (isFlip(value)) return value;
|
|
1075
|
+
if (value === true) return "horizontal";
|
|
1076
|
+
if (value === false) return "none";
|
|
1077
|
+
return fallback;
|
|
1078
|
+
}
|
|
1079
|
+
function flipsHorizontally(flip) {
|
|
1080
|
+
return flip === "horizontal" || flip === "both";
|
|
1081
|
+
}
|
|
1082
|
+
function flipsVertically(flip) {
|
|
1083
|
+
return flip === "vertical" || flip === "both";
|
|
1084
|
+
}
|
|
1085
|
+
//#endregion
|
|
1086
|
+
//#region src/runtime.ts
|
|
1087
|
+
/**
|
|
1088
|
+
* Where the extension instance puts itself on the VM runtime.
|
|
1089
|
+
*
|
|
1090
|
+
* Present as soon as the extension is registered. Absent means Camera Source is not loaded, which a
|
|
1091
|
+
* consumer has to handle whatever else it does.
|
|
1092
|
+
*/
|
|
1093
|
+
var cameraSourceRuntimeKey = "ext_kubohiroyacamerasource";
|
|
1094
|
+
//#endregion
|
|
162
1095
|
//#region src/video-preview.ts
|
|
163
1096
|
var videoLayer = "video";
|
|
164
1097
|
var haveCurrentData = 2;
|
|
@@ -252,13 +1185,13 @@
|
|
|
252
1185
|
function assertRenderer(renderer) {
|
|
253
1186
|
if (!renderer || !Array.isArray(renderer._allSkins) || !Number.isInteger(renderer._nextSkinId) || typeof renderer.createDrawable !== "function" || typeof renderer.destroyDrawable !== "function" || typeof renderer.destroySkin !== "function" || typeof renderer.getNativeSize !== "function") throw new Error("Camera preview requires a compatible TurboWarp renderer.");
|
|
254
1187
|
}
|
|
255
|
-
function createVideoPreview(renderer, video,
|
|
1188
|
+
function createVideoPreview(renderer, video, flip, requestRedraw) {
|
|
256
1189
|
assertRenderer(renderer);
|
|
257
1190
|
const VideoSkin = videoSkinClass(renderer);
|
|
258
1191
|
const skinId = renderer._nextSkinId++;
|
|
259
1192
|
let drawableId;
|
|
260
1193
|
let disposed = false;
|
|
261
|
-
let
|
|
1194
|
+
let previewFlip = flip;
|
|
262
1195
|
let lastLayout = "";
|
|
263
1196
|
const updateLayout = () => {
|
|
264
1197
|
if (drawableId === void 0 || video.videoWidth === 0 || video.videoHeight === 0) return;
|
|
@@ -268,11 +1201,11 @@
|
|
|
268
1201
|
video.videoHeight,
|
|
269
1202
|
stageWidth,
|
|
270
1203
|
stageHeight,
|
|
271
|
-
|
|
1204
|
+
previewFlip
|
|
272
1205
|
].join(":");
|
|
273
1206
|
if (layout === lastLayout) return;
|
|
274
1207
|
const scale = Math.max(stageWidth / video.videoWidth, stageHeight / video.videoHeight) * 100;
|
|
275
|
-
renderer.updateDrawableScale(drawableId, [
|
|
1208
|
+
renderer.updateDrawableScale(drawableId, [flipsHorizontally(previewFlip) ? -scale : scale, flipsVertically(previewFlip) ? -scale : scale]);
|
|
276
1209
|
lastLayout = layout;
|
|
277
1210
|
};
|
|
278
1211
|
const skin = new VideoSkin(skinId, renderer, video, (metricsChanged) => {
|
|
@@ -300,9 +1233,9 @@
|
|
|
300
1233
|
throw error;
|
|
301
1234
|
}
|
|
302
1235
|
return Object.freeze({
|
|
303
|
-
|
|
304
|
-
if (disposed ||
|
|
305
|
-
|
|
1236
|
+
setFlip: (nextFlip) => {
|
|
1237
|
+
if (disposed || previewFlip === nextFlip) return;
|
|
1238
|
+
previewFlip = nextFlip;
|
|
306
1239
|
updateLayout();
|
|
307
1240
|
requestRedraw();
|
|
308
1241
|
},
|
|
@@ -324,6 +1257,7 @@
|
|
|
324
1257
|
//#endregion
|
|
325
1258
|
//#region src/extension.ts
|
|
326
1259
|
var blockDefinitions = block_definitions_default.blocks;
|
|
1260
|
+
var menuDefinitions = block_definitions_default.menus;
|
|
327
1261
|
var defaultCameraId = "default";
|
|
328
1262
|
function mediaDevices() {
|
|
329
1263
|
const devices = globalThis.navigator?.mediaDevices;
|
|
@@ -354,23 +1288,69 @@
|
|
|
354
1288
|
video: options.video ?? true
|
|
355
1289
|
};
|
|
356
1290
|
}
|
|
1291
|
+
/**
|
|
1292
|
+
* The flip a `show preview` block asked for.
|
|
1293
|
+
*
|
|
1294
|
+
* The menu accepts reporters, so the value can arrive as any string a project computed. Anything
|
|
1295
|
+
* outside the vocabulary falls back to horizontal rather than silently drawing the preview
|
|
1296
|
+
* unflipped: a project that asked for a flip and got none would look like the camera was wrong.
|
|
1297
|
+
*/
|
|
1298
|
+
function requestedPreviewFlip(args) {
|
|
1299
|
+
return toFlip(args.PREVIEW_FLIP, "horizontal");
|
|
1300
|
+
}
|
|
1301
|
+
/** The preview flip a consumer asked for through the runtime API. */
|
|
1302
|
+
function previewFlipOf(options) {
|
|
1303
|
+
return toFlip(options.previewFlip);
|
|
1304
|
+
}
|
|
1305
|
+
function cameraFailure(error) {
|
|
1306
|
+
if (error instanceof Error) return {
|
|
1307
|
+
code: error.name || "Error",
|
|
1308
|
+
message: error.message
|
|
1309
|
+
};
|
|
1310
|
+
return {
|
|
1311
|
+
code: "Error",
|
|
1312
|
+
message: String(error)
|
|
1313
|
+
};
|
|
1314
|
+
}
|
|
357
1315
|
var CameraSourceExtension = class {
|
|
358
1316
|
constructor() {
|
|
359
1317
|
this.sessions = /* @__PURE__ */ new Map();
|
|
360
1318
|
this.blockLeases = /* @__PURE__ */ new Map();
|
|
361
1319
|
this.blockPreviewLeases = /* @__PURE__ */ new Map();
|
|
362
1320
|
this.blockPreviewRevisions = /* @__PURE__ */ new Map();
|
|
1321
|
+
this.cameraFailures = /* @__PURE__ */ new Map();
|
|
1322
|
+
this.profiles = new CameraProfileRegistry();
|
|
1323
|
+
this.generations = /* @__PURE__ */ new Map();
|
|
1324
|
+
this.lastConditions = /* @__PURE__ */ new Map();
|
|
1325
|
+
this.assessments = /* @__PURE__ */ new Map();
|
|
1326
|
+
this.calibrationEnabled = featureFlags.calibrationProfilesV1;
|
|
363
1327
|
this.devices = [];
|
|
364
1328
|
this.dispose = () => {
|
|
365
1329
|
this.stopAllCameras();
|
|
1330
|
+
const runtime = Scratch.vm.runtime;
|
|
1331
|
+
if (runtime["kubohiroyaCameraSourceCapability"] === this.capability) delete runtime[runtimeCapabilityKey];
|
|
366
1332
|
Scratch.vm.runtime.off?.("PROJECT_STOP_ALL", this.handleProjectBoundary);
|
|
367
1333
|
Scratch.vm.runtime.off?.("PROJECT_LOADED", this.handleProjectBoundary);
|
|
368
1334
|
Scratch.vm.runtime.off?.("RUNTIME_DISPOSED", this.dispose);
|
|
369
1335
|
};
|
|
370
1336
|
this.handleProjectBoundary = () => {
|
|
371
1337
|
this.stopAllCameras();
|
|
1338
|
+
this.profileError = void 0;
|
|
372
1339
|
};
|
|
373
|
-
Scratch.vm.runtime
|
|
1340
|
+
Scratch.vm.runtime[cameraSourceRuntimeKey] = this;
|
|
1341
|
+
this.capability = this.calibrationEnabled ? createRuntimeCapability({
|
|
1342
|
+
registerProfile: (document) => this.profiles.register(document),
|
|
1343
|
+
forgetProfile: (cameraId) => this.profiles.forget(cameraId),
|
|
1344
|
+
profileFor: (cameraId) => this.profiles.get(cameraId),
|
|
1345
|
+
calibratedCameras: () => this.profiles.cameraIds(),
|
|
1346
|
+
assessProfile: (cameraId) => {
|
|
1347
|
+
return this.assessmentOf(cameraId);
|
|
1348
|
+
},
|
|
1349
|
+
intrinsicsFor: (cameraId) => this.intrinsicsOf(cameraId),
|
|
1350
|
+
conditionsFor: (cameraId) => this.conditionsOf(cameraId),
|
|
1351
|
+
conditionsGeneration: (cameraId) => this.generationOf(cameraId)
|
|
1352
|
+
}) : void 0;
|
|
1353
|
+
if (this.capability) Scratch.vm.runtime[runtimeCapabilityKey] = this.capability;
|
|
374
1354
|
Scratch.vm.runtime.on?.("PROJECT_STOP_ALL", this.handleProjectBoundary);
|
|
375
1355
|
Scratch.vm.runtime.on?.("PROJECT_LOADED", this.handleProjectBoundary);
|
|
376
1356
|
Scratch.vm.runtime.on?.("RUNTIME_DISPOSED", this.dispose);
|
|
@@ -379,12 +1359,22 @@
|
|
|
379
1359
|
return {
|
|
380
1360
|
id: extensionConfig.id,
|
|
381
1361
|
name: Scratch.translate(block_definitions_default.extensionName),
|
|
382
|
-
blocks: blockDefinitions.map((block) => this.toScratchBlock(block))
|
|
1362
|
+
blocks: blockDefinitions.filter((block) => block.feature === void 0 || this.calibrationEnabled).map((block) => this.toScratchBlock(block)),
|
|
1363
|
+
menus: Object.fromEntries(Object.entries(menuDefinitions).map(([id, menu]) => [id, {
|
|
1364
|
+
acceptReporters: menu.acceptReporters,
|
|
1365
|
+
items: [...menu.items]
|
|
1366
|
+
}]))
|
|
383
1367
|
};
|
|
384
1368
|
}
|
|
385
1369
|
isCameraRunning(args = {}) {
|
|
386
1370
|
const session = this.sessions.get(normalizeId(args.CAMERA_ID));
|
|
387
|
-
return
|
|
1371
|
+
return session?.stream ? this.isStreamRunning(session.stream) : false;
|
|
1372
|
+
}
|
|
1373
|
+
cameraErrorCode(args = {}) {
|
|
1374
|
+
return this.cameraFailures.get(normalizeId(args.CAMERA_ID))?.code ?? "";
|
|
1375
|
+
}
|
|
1376
|
+
cameraError(args = {}) {
|
|
1377
|
+
return this.cameraFailures.get(normalizeId(args.CAMERA_ID))?.message ?? "";
|
|
388
1378
|
}
|
|
389
1379
|
cameraDeviceIdReporter(args = {}) {
|
|
390
1380
|
return this.sessions.get(normalizeId(args.CAMERA_ID))?.activeDeviceId ?? "";
|
|
@@ -424,14 +1414,15 @@
|
|
|
424
1414
|
session.leases.add(token);
|
|
425
1415
|
try {
|
|
426
1416
|
if (options.preview === true) {
|
|
427
|
-
session.previewLeases.set(token, options
|
|
1417
|
+
session.previewLeases.set(token, previewFlipOf(options));
|
|
428
1418
|
this.ensurePreview(session);
|
|
429
|
-
session.preview?.
|
|
1419
|
+
session.preview?.setFlip(this.previewFlip(session));
|
|
430
1420
|
}
|
|
431
1421
|
} catch (error) {
|
|
432
1422
|
session.leases.delete(token);
|
|
433
1423
|
session.previewLeases.delete(token);
|
|
434
|
-
|
|
1424
|
+
this.stopWhenUnused(session);
|
|
1425
|
+
this.cameraFailures.set(cameraId, cameraFailure(error));
|
|
435
1426
|
throw error;
|
|
436
1427
|
}
|
|
437
1428
|
let released = false;
|
|
@@ -445,21 +1436,21 @@
|
|
|
445
1436
|
if (session.previewLeases.size === 0) {
|
|
446
1437
|
session.preview?.dispose();
|
|
447
1438
|
session.preview = null;
|
|
448
|
-
} else session.preview?.
|
|
449
|
-
|
|
1439
|
+
} else session.preview?.setFlip(this.previewFlip(session));
|
|
1440
|
+
this.stopWhenUnused(session);
|
|
450
1441
|
}
|
|
451
1442
|
});
|
|
452
1443
|
}
|
|
453
1444
|
async showCameraPreview(args = {}) {
|
|
454
1445
|
const cameraId = normalizeId(args.CAMERA_ID);
|
|
455
|
-
const
|
|
456
|
-
if (this.blockPreviewLeases.get(cameraId)?.
|
|
1446
|
+
const flip = requestedPreviewFlip(args);
|
|
1447
|
+
if (this.blockPreviewLeases.get(cameraId)?.flip === flip) return;
|
|
457
1448
|
const revision = this.nextPreviewBlockRevision(cameraId);
|
|
458
1449
|
const lease = await this.acquireCamera({
|
|
459
1450
|
owner: "camera-source-preview-block",
|
|
460
1451
|
cameraId,
|
|
461
1452
|
preview: true,
|
|
462
|
-
|
|
1453
|
+
previewFlip: flip
|
|
463
1454
|
});
|
|
464
1455
|
if (this.blockPreviewRevisions.get(cameraId) !== revision) {
|
|
465
1456
|
await lease.release();
|
|
@@ -468,7 +1459,7 @@
|
|
|
468
1459
|
const current = this.blockPreviewLeases.get(cameraId);
|
|
469
1460
|
this.blockPreviewLeases.set(cameraId, {
|
|
470
1461
|
lease,
|
|
471
|
-
|
|
1462
|
+
flip
|
|
472
1463
|
});
|
|
473
1464
|
await current?.lease.release();
|
|
474
1465
|
}
|
|
@@ -500,6 +1491,163 @@
|
|
|
500
1491
|
this.blockLeases.clear();
|
|
501
1492
|
this.blockPreviewLeases.clear();
|
|
502
1493
|
}
|
|
1494
|
+
registerCameraProfile(args = {}) {
|
|
1495
|
+
const text = Scratch.Cast.toString(args.PROFILE_JSON ?? "");
|
|
1496
|
+
let document;
|
|
1497
|
+
try {
|
|
1498
|
+
document = JSON.parse(text);
|
|
1499
|
+
} catch {
|
|
1500
|
+
this.profileError = {
|
|
1501
|
+
code: "not-an-object",
|
|
1502
|
+
path: "",
|
|
1503
|
+
message: "The profile is not valid JSON."
|
|
1504
|
+
};
|
|
1505
|
+
return;
|
|
1506
|
+
}
|
|
1507
|
+
const result = this.profiles.register(document);
|
|
1508
|
+
this.profileError = result.ok ? void 0 : result.error;
|
|
1509
|
+
}
|
|
1510
|
+
forgetCameraProfile(args = {}) {
|
|
1511
|
+
this.profiles.forget(normalizeId(args.CAMERA_ID));
|
|
1512
|
+
}
|
|
1513
|
+
cameraProfileRegistered(args = {}) {
|
|
1514
|
+
return this.profiles.has(normalizeId(args.CAMERA_ID));
|
|
1515
|
+
}
|
|
1516
|
+
cameraProfileJson(args = {}) {
|
|
1517
|
+
const profile = this.profiles.get(normalizeId(args.CAMERA_ID));
|
|
1518
|
+
return profile ? serializeCameraIntrinsicProfile(profile) : "";
|
|
1519
|
+
}
|
|
1520
|
+
cameraProfileError() {
|
|
1521
|
+
return this.profileError?.code ?? "";
|
|
1522
|
+
}
|
|
1523
|
+
cameraProfileErrorDetail() {
|
|
1524
|
+
if (!this.profileError) return "";
|
|
1525
|
+
const { path, message } = this.profileError;
|
|
1526
|
+
return path ? `${path}: ${message}` : message;
|
|
1527
|
+
}
|
|
1528
|
+
cameraProfileCompatibility(args = {}) {
|
|
1529
|
+
const cameraId = normalizeId(args.CAMERA_ID);
|
|
1530
|
+
return this.assessmentOf(cameraId)?.compatibility.state ?? "";
|
|
1531
|
+
}
|
|
1532
|
+
cameraProfileCompatibilityDetail(args = {}) {
|
|
1533
|
+
const cameraId = normalizeId(args.CAMERA_ID);
|
|
1534
|
+
const assessment = this.assessmentOf(cameraId);
|
|
1535
|
+
if (assessment === void 0) return "";
|
|
1536
|
+
const findings = decisiveFindings(assessment.compatibility);
|
|
1537
|
+
if (findings.length === 0) return "The profile matches the camera as configured.";
|
|
1538
|
+
return findings.map((entry) => entry.detail).join(" ");
|
|
1539
|
+
}
|
|
1540
|
+
cameraProfileAdaptation(args = {}) {
|
|
1541
|
+
const cameraId = normalizeId(args.CAMERA_ID);
|
|
1542
|
+
return this.assessmentOf(cameraId)?.adaptation.state ?? "";
|
|
1543
|
+
}
|
|
1544
|
+
cameraProfileIntrinsicsJson(args = {}) {
|
|
1545
|
+
const cameraId = normalizeId(args.CAMERA_ID);
|
|
1546
|
+
const usable = this.intrinsicsOf(cameraId);
|
|
1547
|
+
return usable === void 0 ? "" : JSON.stringify(usable);
|
|
1548
|
+
}
|
|
1549
|
+
cameraConditionsJson(args = {}) {
|
|
1550
|
+
return JSON.stringify(this.conditionsOf(normalizeId(args.CAMERA_ID)));
|
|
1551
|
+
}
|
|
1552
|
+
cameraConditionsGeneration(args = {}) {
|
|
1553
|
+
return this.generationOf(normalizeId(args.CAMERA_ID));
|
|
1554
|
+
}
|
|
1555
|
+
/** What the track reports about itself right now. Read only. */
|
|
1556
|
+
intrinsicsOf(cameraId) {
|
|
1557
|
+
const id = normalizeId(cameraId);
|
|
1558
|
+
return this.assessmentOf(id)?.usable;
|
|
1559
|
+
}
|
|
1560
|
+
conditionsOf(cameraId) {
|
|
1561
|
+
const id = normalizeId(cameraId);
|
|
1562
|
+
const session = this.sessions.get(id);
|
|
1563
|
+
if (!session?.stream) return {
|
|
1564
|
+
width: 0,
|
|
1565
|
+
height: 0,
|
|
1566
|
+
deviceId: "",
|
|
1567
|
+
previewFlip: "none"
|
|
1568
|
+
};
|
|
1569
|
+
const track = session.stream.getVideoTracks()[0];
|
|
1570
|
+
let settings = {};
|
|
1571
|
+
try {
|
|
1572
|
+
settings = track?.getSettings() ?? {};
|
|
1573
|
+
} catch {
|
|
1574
|
+
settings = {};
|
|
1575
|
+
}
|
|
1576
|
+
const device = this.devices.find((entry) => entry.deviceId === session.activeDeviceId);
|
|
1577
|
+
return readCameraConditions({
|
|
1578
|
+
width: session.video?.videoWidth ?? 0,
|
|
1579
|
+
height: session.video?.videoHeight ?? 0,
|
|
1580
|
+
deviceId: session.activeDeviceId,
|
|
1581
|
+
previewFlip: this.previewFlip(session),
|
|
1582
|
+
...device?.label ? { label: device.label } : {}
|
|
1583
|
+
}, settings);
|
|
1584
|
+
}
|
|
1585
|
+
/**
|
|
1586
|
+
* A counter that moves when the geometry does.
|
|
1587
|
+
*
|
|
1588
|
+
* Derived by comparing the members that affect projection, so it advances on
|
|
1589
|
+
* a resolution change or a zoom and stays put for a frame rate change. A
|
|
1590
|
+
* consumer holding a placement solved from these conditions compares one
|
|
1591
|
+
* number rather than re-checking each of them.
|
|
1592
|
+
*/
|
|
1593
|
+
/**
|
|
1594
|
+
* The conditions that decide geometry, as one comparable string.
|
|
1595
|
+
*
|
|
1596
|
+
* The preview flip is not among them. It changes how the stage draws the frame and nothing about
|
|
1597
|
+
* how the lens projects, so folding it in would advance the generation and invalidate consumers'
|
|
1598
|
+
* work every time an operator turned the preview over.
|
|
1599
|
+
*/
|
|
1600
|
+
conditionsSignature(conditions) {
|
|
1601
|
+
return JSON.stringify([
|
|
1602
|
+
conditions.width,
|
|
1603
|
+
conditions.height,
|
|
1604
|
+
conditions.resizeMode ?? null,
|
|
1605
|
+
conditions.zoom ?? null,
|
|
1606
|
+
conditions.focusMode ?? null,
|
|
1607
|
+
conditions.focusDistance ?? null,
|
|
1608
|
+
conditions.deviceId
|
|
1609
|
+
]);
|
|
1610
|
+
}
|
|
1611
|
+
/**
|
|
1612
|
+
* The assessment for a camera, reusing the last one while nothing it depends on has changed.
|
|
1613
|
+
*
|
|
1614
|
+
* The conditions are read on every call, so this cannot answer with a stale view of the camera.
|
|
1615
|
+
* What is skipped is the derivation: judging compatibility builds a finding for every member it
|
|
1616
|
+
* compares, each with its own sentence, and these reporters are read from blocks that a project
|
|
1617
|
+
* can evaluate on every frame. Reusing the result while the inputs are identical keeps that off
|
|
1618
|
+
* the frame budget without putting a staleness window in its place.
|
|
1619
|
+
*/
|
|
1620
|
+
assessmentOf(cameraId) {
|
|
1621
|
+
const id = normalizeId(cameraId);
|
|
1622
|
+
const conditions = this.conditionsOf(id);
|
|
1623
|
+
const signature = this.conditionsSignature(conditions);
|
|
1624
|
+
const profile = this.profiles.get(id);
|
|
1625
|
+
const cached = this.assessments.get(id);
|
|
1626
|
+
if (cached && cached.signature === signature && cached.profile === profile) return cached.assessment;
|
|
1627
|
+
const assessment = this.profiles.assess(id, conditions);
|
|
1628
|
+
this.assessments.set(id, {
|
|
1629
|
+
signature,
|
|
1630
|
+
profile,
|
|
1631
|
+
assessment
|
|
1632
|
+
});
|
|
1633
|
+
return assessment;
|
|
1634
|
+
}
|
|
1635
|
+
generationOf(cameraId) {
|
|
1636
|
+
const id = normalizeId(cameraId);
|
|
1637
|
+
const conditions = this.conditionsOf(id);
|
|
1638
|
+
const signature = this.conditionsSignature(conditions);
|
|
1639
|
+
const previous = this.lastConditions.get(id);
|
|
1640
|
+
if (previous === void 0) {
|
|
1641
|
+
this.lastConditions.set(id, signature);
|
|
1642
|
+
this.generations.set(id, 0);
|
|
1643
|
+
return 0;
|
|
1644
|
+
}
|
|
1645
|
+
if (previous === signature) return this.generations.get(id) ?? 0;
|
|
1646
|
+
const next = (this.generations.get(id) ?? 0) + 1;
|
|
1647
|
+
this.lastConditions.set(id, signature);
|
|
1648
|
+
this.generations.set(id, next);
|
|
1649
|
+
return next;
|
|
1650
|
+
}
|
|
503
1651
|
session(cameraId) {
|
|
504
1652
|
const existing = this.sessions.get(cameraId);
|
|
505
1653
|
if (existing) return existing;
|
|
@@ -512,14 +1660,12 @@
|
|
|
512
1660
|
video: null,
|
|
513
1661
|
preview: null,
|
|
514
1662
|
startPromise: null,
|
|
515
|
-
mirrored: false,
|
|
516
1663
|
activeDeviceId: ""
|
|
517
1664
|
};
|
|
518
1665
|
this.sessions.set(cameraId, session);
|
|
519
1666
|
return session;
|
|
520
1667
|
}
|
|
521
1668
|
async start(session, options) {
|
|
522
|
-
session.mirrored = options.mirrored === true;
|
|
523
1669
|
session.startPromise = (async () => {
|
|
524
1670
|
const stream = await mediaDevices().getUserMedia(videoConstraints(options));
|
|
525
1671
|
let video = null;
|
|
@@ -533,7 +1679,9 @@
|
|
|
533
1679
|
if (!session.active) throw new Error("Camera acquisition was cancelled.");
|
|
534
1680
|
session.stream = stream;
|
|
535
1681
|
session.video = video;
|
|
1682
|
+
this.watchStreamEnd(session, stream);
|
|
536
1683
|
this.updateActiveDevice(session);
|
|
1684
|
+
this.cameraFailures.delete(session.cameraId);
|
|
537
1685
|
} catch (error) {
|
|
538
1686
|
stream.getTracks().forEach((track) => track.stop());
|
|
539
1687
|
if (video) video.srcObject = null;
|
|
@@ -544,6 +1692,7 @@
|
|
|
544
1692
|
await session.startPromise;
|
|
545
1693
|
} catch (error) {
|
|
546
1694
|
if (this.sessions.get(session.cameraId) === session) this.stopCameraSession(session.cameraId);
|
|
1695
|
+
this.cameraFailures.set(session.cameraId, cameraFailure(error));
|
|
547
1696
|
throw error;
|
|
548
1697
|
}
|
|
549
1698
|
}
|
|
@@ -552,6 +1701,16 @@
|
|
|
552
1701
|
this.blockPreviewRevisions.set(cameraId, revision);
|
|
553
1702
|
return revision;
|
|
554
1703
|
}
|
|
1704
|
+
isStreamRunning(stream) {
|
|
1705
|
+
return stream.active !== false && stream.getVideoTracks().some((track) => track.readyState !== "ended");
|
|
1706
|
+
}
|
|
1707
|
+
watchStreamEnd(session, stream) {
|
|
1708
|
+
const handleEnded = () => {
|
|
1709
|
+
if (this.sessions.get(session.cameraId) !== session || session.stream !== stream) return;
|
|
1710
|
+
if (!this.isStreamRunning(stream)) this.stopCameraSession(session.cameraId);
|
|
1711
|
+
};
|
|
1712
|
+
for (const track of stream.getVideoTracks()) track.addEventListener("ended", handleEnded, { once: true });
|
|
1713
|
+
}
|
|
555
1714
|
updateActiveDevice(session) {
|
|
556
1715
|
const settings = (session.stream?.getVideoTracks()[0] ?? null)?.getSettings();
|
|
557
1716
|
session.activeDeviceId = typeof settings?.deviceId === "string" ? settings.deviceId : "";
|
|
@@ -563,10 +1722,17 @@
|
|
|
563
1722
|
ensurePreview(session) {
|
|
564
1723
|
if (session.preview || !session.video) return;
|
|
565
1724
|
const runtime = Scratch.vm.runtime;
|
|
566
|
-
session.preview = createVideoPreview(runtime.renderer, session.video, this.
|
|
1725
|
+
session.preview = createVideoPreview(runtime.renderer, session.video, this.previewFlip(session), () => runtime.requestRedraw?.());
|
|
567
1726
|
}
|
|
568
|
-
|
|
569
|
-
|
|
1727
|
+
/**
|
|
1728
|
+
* How the preview is shown for a camera several consumers may be watching.
|
|
1729
|
+
*
|
|
1730
|
+
* Any consumer asking for a flipped preview flips it for everyone, which is
|
|
1731
|
+
* the same rule the previous boolean followed.
|
|
1732
|
+
*/
|
|
1733
|
+
previewFlip(session) {
|
|
1734
|
+
for (const flip of session.previewLeases.values()) if (flip !== "none") return flip;
|
|
1735
|
+
return "none";
|
|
570
1736
|
}
|
|
571
1737
|
getFrameSource(session) {
|
|
572
1738
|
if (!session.video || !session.stream) throw new Error("Shared camera is not running.");
|
|
@@ -575,10 +1741,14 @@
|
|
|
575
1741
|
element: session.video,
|
|
576
1742
|
width: session.video.videoWidth,
|
|
577
1743
|
height: session.video.videoHeight,
|
|
578
|
-
|
|
1744
|
+
previewFlip: this.previewFlip(session),
|
|
579
1745
|
deviceId: session.activeDeviceId
|
|
580
1746
|
});
|
|
581
1747
|
}
|
|
1748
|
+
stopWhenUnused(session) {
|
|
1749
|
+
if (this.sessions.get(session.cameraId) !== session) return;
|
|
1750
|
+
if (session.leases.size === 0) this.stopCameraSession(session.cameraId);
|
|
1751
|
+
}
|
|
582
1752
|
stopCameraSession(cameraId) {
|
|
583
1753
|
const session = this.sessions.get(cameraId);
|
|
584
1754
|
if (!session) return;
|
|
@@ -597,6 +1767,7 @@
|
|
|
597
1767
|
this.sessions.delete(cameraId);
|
|
598
1768
|
this.blockLeases.delete(cameraId);
|
|
599
1769
|
this.blockPreviewLeases.delete(cameraId);
|
|
1770
|
+
this.assessments.delete(cameraId);
|
|
600
1771
|
}
|
|
601
1772
|
toScratchBlock(block) {
|
|
602
1773
|
return {
|
|
@@ -605,7 +1776,8 @@
|
|
|
605
1776
|
text: Scratch.translate(block.text),
|
|
606
1777
|
arguments: Object.fromEntries(Object.entries(block.arguments).map(([name, argument]) => [name, {
|
|
607
1778
|
type: Scratch.ArgumentType[argument.type],
|
|
608
|
-
defaultValue: argument.defaultValue
|
|
1779
|
+
defaultValue: argument.defaultValue,
|
|
1780
|
+
...argument.menu === void 0 ? {} : { menu: argument.menu }
|
|
609
1781
|
}]))
|
|
610
1782
|
};
|
|
611
1783
|
}
|