++
++ 
++
++
+
++
++ 
+
+
++
++
++
++
++
++ Allocated {{ s.wantBytes }} of ~{{ s.budgetBytes }} bytes per 125 µs ({{
++ mbPerSec(s.wantBytes).toFixed(1)
++ }}
++ of {{ mbPerSec(s.budgetBytes).toFixed(1) }} MB/s), using {{ fmtMB(s.usedBytesPerSec) }}.
++ {{ free }} bytes free.
++ Full: to give a camera more, lower another first.
++ Over the budget by {{ -free }} bytes: a camera won't start.
++
++ scripts/jetson/11-uvcvideo-payload-cap.sh --install
++ port {{ c.port }} · {{ c.id }}
++ {{ c.problem }}
++ not streaming
++
++ {{ Math.round(100 * share(c)) }}% of its allocation{{ squeezed(c) ? ": squeezed" : "" }}
++
++
++
++ fits {{ frameFits(c, c.wantBytes)!.toFixed(1) }}x,
++
++ {{ ((1000 * c.recentMaxFrameBytes) / (c.wantBytes * 8000)).toFixed(1) }} ms on USB
++
++
++
++ A camera can't send more than its allocation, and never takes another camera's. When its frames don't fit, the
++ cameras we tested keep their frame rate and compress harder: smaller, lower-quality JPEGs, each taking longer to
++ cross USB. "Squeezed" (using 90% or more) means that's happening. "Fits" is how many times the largest recent
++ frame fits in one frame time; the ms is how long a frame takes to cross USB. Changes are saved for the next
++ boot, and the camera is reset to apply them (a second or two without frames).
++
++
++ Reset
++
++
++
++ Centre
++ {{ reading ? Math.round(reading.centre) : "…" }}
++
++
++ Sharpest so far
++ {{ reading ? Math.round(reading.best) : "" }}
++ {{ status }}
++
++ Each part of the image, against its own sharpest so far:
++
++
++
++ {{ pct }}%
++
++ Point the camera at something detailed that stays still: a tag or the calibration board, about as far away as
++ the tags you care about most. Press Reset, turn the lens slowly past the sharpest point, then back to it. When
++ the centre is at 100%, the corners should be close to 100% too; a corner well below means a tilted lens or a
++ soft corner. Then lock the lens (glue or silicone) and recalibrate. The numbers depend on the scene and light,
++ so only compare them without moving the camera.
++
++
++
+
+
+diff --git a/photon-client/src/components/common/pv-loading.vue b/photon-client/src/components/common/pv-loading.vue
+index e1d81c18..02ec511b 100644
+--- a/photon-client/src/components/common/pv-loading.vue
++++ b/photon-client/src/components/common/pv-loading.vue
+@@ -11,7 +11,7 @@
+
+
+
+-
++
+
+
+
+-
++
+
+
+
+-
++
+
+
+
+-
++
+
+
+
+-
++
+
+
+
+-
++
+
+
+
+-
++
+
+
+
+-
++
+
++// SpectrumJetson (photonvision-40): a reusable box-mask editor laid over any image or stream
++// (the slot). Boxes are fractions (0-1) of the slot's area, so it works at any display size and
++// any camera resolution. Shows the mask whenever it's on; with `editing`, drag on empty space to
++// draw a box, drag a box to move it, drag any of its 4 corners to resize (the opposite corner
++// stays put), click one to select it, and Delete/Backspace removes it. Emits the whole mask on each finished change (not while dragging).
++import { computed, onBeforeUnmount, onMounted, ref } from "vue";
++import { type DetectionMask, DetectionMaskMode, type MaskBox } from "@/types/PipelineTypes";
++
++const props = defineProps<{
++ modelValue?: DetectionMask;
++ editing?: boolean;
++}>();
++const emit = defineEmits<{
++ (e: "update:modelValue", value: DetectionMask): void;
++}>();
++
++const MIN_SIZE = 0.01; // boxes smaller than 1% of the image in either direction are dropped
++
++const root = ref(null);
++const selected = ref(-1);
++// While dragging, a working copy of the boxes; otherwise the model's.
++const working = ref(null);
++type Drag =
++ | { kind: "draw"; x0: number; y0: number }
++ | { kind: "move"; index: number; dx: number; dy: number }
++ | { kind: "resize"; index: number; ax: number; ay: number }; // (ax, ay): the fixed corner
++let drag: Drag | null = null;
++
++const mode = computed(() => props.modelValue?.mode ?? DetectionMaskMode.Off);
++const boxes = computed(() => working.value ?? props.modelValue?.boxes ?? []);
++const visible = computed(() => props.editing || (mode.value !== DetectionMaskMode.Off && boxes.value.length > 0));
++// While editing with the mask off, show boxes as ignore boxes so they can still be drawn.
++const onlyInside = computed(() => mode.value === DetectionMaskMode.OnlyInside);
++const maskId = `pv-mask-${Math.random().toString(36).slice(2)}`;
++
++const clamp01 = (v: number) => Math.min(1, Math.max(0, v));
++const point = (ev: PointerEvent) => {
++ const r = root.value!.getBoundingClientRect();
++ return { x: clamp01((ev.clientX - r.left) / r.width), y: clamp01((ev.clientY - r.top) / r.height) };
++};
++const commit = (next: MaskBox[]) => {
++ emit("update:modelValue", {
++ mode: mode.value,
++ boxes: next.map((b) => ({ x: +b.x.toFixed(4), y: +b.y.toFixed(4), w: +b.w.toFixed(4), h: +b.h.toFixed(4) }))
++ });
++};
++
++const onBackgroundDown = (ev: PointerEvent) => {
++ if (!props.editing) return;
++ const p = point(ev);
++ working.value = [...boxes.value, { x: p.x, y: p.y, w: 0, h: 0 }];
++ selected.value = working.value.length - 1;
++ drag = { kind: "draw", x0: p.x, y0: p.y };
++ (ev.target as Element).setPointerCapture(ev.pointerId);
++};
++const onBoxDown = (ev: PointerEvent, index: number) => {
++ if (!props.editing) return;
++ ev.stopPropagation();
++ const p = point(ev);
++ const b = boxes.value[index];
++ working.value = boxes.value.map((x) => ({ ...x }));
++ selected.value = index;
++ drag = { kind: "move", index, dx: p.x - b.x, dy: p.y - b.y };
++ (ev.target as Element).setPointerCapture(ev.pointerId);
++};
++// Corners: 0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left.
++const cornerX = (b: MaskBox, c: number) => (c === 1 || c === 2 ? b.x + b.w : b.x);
++const cornerY = (b: MaskBox, c: number) => (c >= 2 ? b.y + b.h : b.y);
++const onHandleDown = (ev: PointerEvent, index: number, corner: number) => {
++ if (!props.editing) return;
++ ev.stopPropagation();
++ working.value = boxes.value.map((x) => ({ ...x }));
++ selected.value = index;
++ const b = boxes.value[index];
++ const opposite = (corner + 2) % 4;
++ drag = { kind: "resize", index, ax: cornerX(b, opposite), ay: cornerY(b, opposite) };
++ (ev.target as Element).setPointerCapture(ev.pointerId);
++};
++const onMove = (ev: PointerEvent) => {
++ if (!drag || !working.value) return;
++ const p = point(ev);
++ const w = working.value;
++ if (drag.kind === "draw") {
++ const b = w[w.length - 1];
++ b.x = Math.min(drag.x0, p.x);
++ b.y = Math.min(drag.y0, p.y);
++ b.w = Math.abs(p.x - drag.x0);
++ b.h = Math.abs(p.y - drag.y0);
++ } else if (drag.kind === "move") {
++ const b = w[drag.index];
++ b.x = clamp01(Math.min(p.x - drag.dx, 1 - b.w));
++ b.y = clamp01(Math.min(p.y - drag.dy, 1 - b.h));
++ } else {
++ // The dragged corner follows the pointer; it may cross the fixed one (the box flips).
++ const b = w[drag.index];
++ b.x = Math.min(drag.ax, p.x);
++ b.y = Math.min(drag.ay, p.y);
++ b.w = Math.max(MIN_SIZE, Math.abs(p.x - drag.ax));
++ b.h = Math.max(MIN_SIZE, Math.abs(p.y - drag.ay));
++ }
++};
++const onUp = () => {
++ if (!drag || !working.value) return;
++ const next = working.value.filter((b) => b.w >= MIN_SIZE && b.h >= MIN_SIZE);
++ if (selected.value >= next.length) selected.value = -1;
++ drag = null;
++ working.value = null;
++ commit(next);
++};
++const onKey = (ev: KeyboardEvent) => {
++ if (!props.editing || selected.value < 0) return;
++ if (ev.key !== "Delete" && ev.key !== "Backspace") return;
++ const target = ev.target as HTMLElement | null;
++ if (target && ["INPUT", "TEXTAREA"].includes(target.tagName)) return;
++ ev.preventDefault();
++ commit(boxes.value.filter((_, i) => i !== selected.value));
++ selected.value = -1;
++};
++onMounted(() => window.addEventListener("keydown", onKey));
++onBeforeUnmount(() => window.removeEventListener("keydown", onKey));
++
++
++
++
++
++
++
+diff --git a/photon-client/src/components/common/pv-number-input.vue b/photon-client/src/components/common/pv-number-input.vue
+index babfedd8..fe5ad81c 100644
+--- a/photon-client/src/components/common/pv-number-input.vue
++++ b/photon-client/src/components/common/pv-number-input.vue
+@@ -27,7 +27,7 @@ const localValue = computed({
+
+
+
+-
++
+
+
+diff --git a/photon-client/src/components/common/pv-radio.vue b/photon-client/src/components/common/pv-radio.vue
+index f2fe1804..f62a6136 100644
+--- a/photon-client/src/components/common/pv-radio.vue
++++ b/photon-client/src/components/common/pv-radio.vue
+@@ -20,7 +20,7 @@ withDefaults(
+
+
+
+-
++
+
+
+diff --git a/photon-client/src/components/common/pv-range-slider.vue b/photon-client/src/components/common/pv-range-slider.vue
+index 08ec0de9..b2d6ce66 100644
+--- a/photon-client/src/components/common/pv-range-slider.vue
++++ b/photon-client/src/components/common/pv-range-slider.vue
+@@ -55,7 +55,7 @@ const checkNumberRange = (v: string): boolean => {
+
+
+
+-
++
+
+
+diff --git a/photon-client/src/components/common/pv-select.vue b/photon-client/src/components/common/pv-select.vue
+index f5700a78..32a443b8 100644
+--- a/photon-client/src/components/common/pv-select.vue
++++ b/photon-client/src/components/common/pv-select.vue
+@@ -43,7 +43,7 @@ const items = computed[]>(() => {
+
+
+
+-
++
+
+
+diff --git a/photon-client/src/components/common/pv-slider.vue b/photon-client/src/components/common/pv-slider.vue
+index 534f6dea..59d5deb2 100644
+--- a/photon-client/src/components/common/pv-slider.vue
++++ b/photon-client/src/components/common/pv-slider.vue
+@@ -43,7 +43,7 @@ const localValue = computed({
+
+
+
+-
++
+
+
+diff --git a/photon-client/src/components/common/pv-switch.vue b/photon-client/src/components/common/pv-switch.vue
+index 137f22b0..901299bf 100644
+--- a/photon-client/src/components/common/pv-switch.vue
++++ b/photon-client/src/components/common/pv-switch.vue
+@@ -9,7 +9,7 @@ withDefaults(
+
+
+
+-
++
+
+
+diff --git a/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue b/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue
+index 3aa06c7a..26712f9c 100644
+--- a/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue
++++ b/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue
+@@ -10,6 +10,7 @@ import { PipelineType } from "@/types/PipelineTypes";
+ import { useSettingsStore } from "@/stores/settings/GeneralSettingsStore";
+ import { useTheme } from "vuetify";
+ import PvDeleteModal from "@/components/common/pv-delete-modal.vue";
++import axios from "axios";
+
+ const theme = useTheme();
+
+@@ -66,7 +67,11 @@ const cancelCameraNameEdit = () => {
+
+ // Pipeline Name Edit
+ const pipelineNamesWrapper = computed(() => {
+- const pipelineNames = useCameraSettingsStore().pipelineNames.map((name, index) => ({ name: name, value: index }));
++ // SpectrumJetson (photonvision-47): the number too, since profiles and Switch all go by number.
++ const pipelineNames = useCameraSettingsStore().pipelineNames.map((name, index) => ({
++ name: `${index}: ${name}`,
++ value: index
++ }));
+
+ if (useCameraSettingsStore().isDriverMode) {
+ pipelineNames.push({ name: "Driver Mode", value: WebsocketPipelineType.DriverMode.valueOf() });
+@@ -112,6 +117,7 @@ const validNewPipelineTypes = computed(() => {
+ { name: "Reflective", value: WebsocketPipelineType.Reflective },
+ { name: "Colored Shape", value: WebsocketPipelineType.ColoredShape },
+ { name: "AprilTag", value: WebsocketPipelineType.AprilTag },
++ { name: "AprilTagCuda", value: WebsocketPipelineType.AprilTagCuda },
+ { name: "ArUco", value: WebsocketPipelineType.Aruco }
+ ];
+ if (useSettingsStore().general.supportedBackends.length > 0) {
+@@ -119,16 +125,104 @@ const validNewPipelineTypes = computed(() => {
+ }
+ return pipelineTypes;
+ });
++// SpectrumJetson (photonvision-46): start from a copy of any camera's pipeline, and create it on
++// every camera at once (for profiles like 0 = Event, 1 = Practice field).
++const newPipelineSource = ref("blank");
++const newPipelineOnAllCameras = ref(false);
++const newPipelineBusy = ref(false);
++const newPipelineSourceItems = computed(() => [
++ { name: "Blank (the defaults)", value: "blank" },
++ ...Object.entries(useCameraSettingsStore().cameras).flatMap(([id, camera]) =>
++ (camera.pipelineNicknames ?? []).map((pipeline, index) => ({
++ name: `Copy of ${camera.nickname} / ${index}: ${pipeline}`,
++ value: JSON.stringify([id, index])
++ }))
++ )
++]);
+ const showCreatePipelineDialog = () => {
+ newPipelineName.value = "";
+ newPipelineType.value = useCameraSettingsStore().currentWebsocketPipelineType;
++ newPipelineSource.value = "blank";
++ newPipelineOnAllCameras.value = false;
+ showPipelineCreationDialog.value = true;
+ };
+-const createNewPipeline = () => {
++interface CreatePipelineResult {
++ created: { camera: string; index: number }[];
++ skipped: { camera: string; reason: string }[];
++}
++const describeCreated = (name: string, result: CreatePipelineResult): string => {
++ const byIndex = new Map();
++ for (const c of result.created) byIndex.set(c.index, [...(byIndex.get(c.index) ?? []), c.camera]);
++ const parts = [...byIndex.entries()].map(([index, cameras]) => `as pipeline ${index} on ${cameras.join(", ")}`);
++ const created = parts.length ? `Created '${name}' ${parts.join("; ")}.` : `Created nothing.`;
++ const skipped = result.skipped.map((s) => `${s.camera}: ${s.reason}`).join("; ");
++ return skipped ? `${created} Skipped ${skipped}.` : created;
++};
++const createNewPipeline = async () => {
+ const type = newPipelineType.value;
+- if (type === WebsocketPipelineType.DriverMode || type === WebsocketPipelineType.Calib3d) return;
+- useCameraSettingsStore().createNewPipeline(newPipelineName.value, type);
+- showPipelineCreationDialog.value = false;
++ const blank = newPipelineSource.value === "blank";
++ if (blank && (type === WebsocketPipelineType.DriverMode || type === WebsocketPipelineType.Calib3d)) return;
++ const current = useStateStore().currentCameraUniqueName;
++ const [fromCamera, fromPipeline] = blank ? [undefined, undefined] : JSON.parse(newPipelineSource.value);
++ const name = newPipelineName.value;
++ newPipelineBusy.value = true;
++ try {
++ const response = await axios.post("/settings/createPipeline", {
++ name,
++ type: blank ? type : undefined,
++ fromCamera,
++ fromPipeline,
++ cameras: newPipelineOnAllCameras.value ? Object.keys(useCameraSettingsStore().cameras) : [current],
++ switchCamera: current
++ });
++ showPipelineCreationDialog.value = false;
++ useStateStore().showSnackbarMessage({
++ message: describeCreated(name, response.data),
++ color: response.data.skipped.length ? "warning" : "success",
++ timeout: 8000
++ });
++ } catch (e: any) {
++ const data = e?.response?.data;
++ useStateStore().showSnackbarMessage({
++ message: data?.skipped ? describeCreated(name, data) : `Couldn't create the pipeline: ${data || e}`,
++ color: "error",
++ timeout: 8000
++ });
++ } finally {
++ newPipelineBusy.value = false;
++ }
++};
++
++// SpectrumJetson (photonvision-46): every camera to the pipeline number shown here. Cameras without
++// that number stay where they are, as do cameras in driver mode or calibrating.
++const switchAllCameras = () => {
++ const store = useCameraSettingsStore();
++ const current = useStateStore().currentCameraUniqueName;
++ const index = store.currentCameraSettings.currentPipelineIndex;
++ const name = store.currentPipelineSettings.pipelineNickname;
++ const switched: string[] = [];
++ const skipped: string[] = [];
++ for (const [id, camera] of Object.entries(store.cameras)) {
++ if (id === current) continue;
++ if (camera.currentPipelineIndex === WebsocketPipelineType.DriverMode) {
++ skipped.push(`${camera.nickname} (driver mode)`);
++ } else if (
++ camera.currentPipelineIndex === WebsocketPipelineType.Calib3d ||
++ camera.currentPipelineIndex === WebsocketPipelineType.FocusCamera
++ ) {
++ skipped.push(`${camera.nickname} (calibrating or focusing)`);
++ } else if ((camera.pipelineNicknames?.length ?? 0) <= index) {
++ skipped.push(`${camera.nickname} (no pipeline ${index})`);
++ } else {
++ if (camera.currentPipelineIndex !== index) store.changeCurrentPipelineIndex(index, true, id);
++ const theirs = camera.pipelineNicknames[index];
++ switched.push(theirs === name ? camera.nickname : `${camera.nickname} (its ${index} is '${theirs}')`);
++ }
++ }
++ const message =
++ `Pipeline ${index}: ${switched.length ? `switched ${switched.join(", ")}` : "no other camera switched"}.` +
++ (skipped.length ? ` Not switched: ${skipped.join(", ")}.` : "");
++ useStateStore().showSnackbarMessage({ message, color: skipped.length ? "warning" : "success", timeout: 8000 });
+ };
+ const cancelPipelineCreation = () => {
+ showPipelineCreationDialog.value = false;
+@@ -138,6 +232,74 @@ const cancelPipelineCreation = () => {
+
+ // Pipeline Deletion
+ const showPipelineDeletionConfirmationDialog = ref(false);
++
++// SpectrumJetson (photonvision-25): copy settings from another camera or pipeline into this one, or into
++// the same pipeline number on every camera, instead of copying them by hand.
++const COPY_GROUPS = [
++ { value: "camera", name: "Camera: exposure, brightness, gain, white balance, stream resolution, low latency" },
++ { value: "apriltag", name: "AprilTag: decision margin, hamming, decimate, blur, threads, refinement, tag family" },
++ { value: "output", name: "3D and multi-tag: 3D, multi-tag, single-tag fallback, drawing, target count" },
++ { value: "resolution", name: "Resolution (only between cameras with the same video modes)" },
++ { value: "objectDetection", name: "Object detection: model, confidence, NMS" }
++];
++const showCopySettingsDialog = ref(false);
++const copyFromCamera = ref("");
++const copyFromPipeline = ref(0);
++const copyGroups = ref(["camera", "apriltag", "output"]);
++const copyToAllCameras = ref(false);
++const copyBusy = ref(false);
++const copyCameraItems = computed(() =>
++ Object.keys(useCameraSettingsStore().cameras).map((id) => ({
++ name: useCameraSettingsStore().cameras[id].nickname,
++ value: id
++ }))
++);
++const copyPipelineItems = computed(() =>
++ (useCameraSettingsStore().cameras[copyFromCamera.value]?.pipelineNicknames ?? []).map((name, index) => ({
++ name: `${index}: ${name}`,
++ value: index
++ }))
++);
++const openCopySettingsDialog = () => {
++ const current = useStateStore().currentCameraUniqueName;
++ const others = Object.keys(useCameraSettingsStore().cameras).filter((id) => id !== current);
++ copyFromCamera.value = others[0] ?? current;
++ copyFromPipeline.value = Math.max(0, useCameraSettingsStore().currentCameraSettings.currentPipelineIndex);
++ showCopySettingsDialog.value = true;
++};
++const copySettings = async () => {
++ copyBusy.value = true;
++ const toPipeline = useCameraSettingsStore().currentCameraSettings.currentPipelineIndex;
++ const targets = copyToAllCameras.value
++ ? Object.keys(useCameraSettingsStore().cameras).filter(
++ (id) =>
++ (useCameraSettingsStore().cameras[id].pipelineNicknames?.length ?? 0) > toPipeline &&
++ !(id === copyFromCamera.value && toPipeline === copyFromPipeline.value)
++ )
++ : [useStateStore().currentCameraUniqueName];
++ const done: string[] = [];
++ const failed: string[] = [];
++ for (const toCamera of targets) {
++ try {
++ await axios.post("/settings/copySettings", {
++ fromCamera: copyFromCamera.value,
++ fromPipeline: copyFromPipeline.value,
++ toCamera,
++ toPipeline,
++ groups: copyGroups.value
++ });
++ done.push(useCameraSettingsStore().cameras[toCamera].nickname);
++ } catch (e: any) {
++ failed.push(`${useCameraSettingsStore().cameras[toCamera].nickname}: ${e?.response?.data || "failed"}`);
++ }
++ }
++ copyBusy.value = false;
++ if (failed.length === 0) showCopySettingsDialog.value = false;
++ useStateStore().showSnackbarMessage({
++ message: failed.length ? `Copy failed for ${failed.join("; ")}` : `Copied settings into ${done.join(", ")}`,
++ color: failed.length ? "error" : "success"
++ });
++};
+ const confirmDeleteCurrentPipeline = () => {
+ useCameraSettingsStore().deleteCurrentPipeline();
+ showPipelineDeletionConfirmationDialog.value = false;
+@@ -150,6 +312,7 @@ const pipelineTypesWrapper = computed<{ name: string; value: number }[]>(() => {
+ { name: "Reflective", value: WebsocketPipelineType.Reflective },
+ { name: "Colored Shape", value: WebsocketPipelineType.ColoredShape },
+ { name: "AprilTag", value: WebsocketPipelineType.AprilTag },
++ { name: "AprilTagCuda", value: WebsocketPipelineType.AprilTagCuda },
+ { name: "ArUco", value: WebsocketPipelineType.Aruco }
+ ];
+ if (useSettingsStore().general.supportedBackends.length > 0) {
+@@ -210,6 +373,9 @@ useCameraSettingsStore().$subscribe((mutation, state) => {
+ case PipelineType.AprilTag:
+ pipelineType.value = WebsocketPipelineType.AprilTag;
+ break;
++ case PipelineType.AprilTagCuda:
++ pipelineType.value = WebsocketPipelineType.AprilTagCuda;
++ break;
+ case PipelineType.Aruco:
+ pipelineType.value = WebsocketPipelineType.Aruco;
+ break;
+@@ -318,6 +484,26 @@ const wrappedCameras = computed[]>(() =>
+
++
++
++
++
++
++
++
+
+
+ []>(() =>
+ />
+
+
++
++
++
++ Copy settings into {{ useCameraSettingsStore().currentCameraSettings.nickname }} /
++ {{ useCameraSettingsStore().currentPipelineSettings.pipelineNickname }}
++
++
++
++
++
++ Cancel
++
++
++ Copy
++
++
++
++
+
+
+ Create New Pipeline
+@@ -375,12 +608,30 @@ const wrappedCameras = computed[]>(() =>
+ :rules="[(v) => checkPipelineName(v)]"
+ />
+
+ []>(() =>
+
+ Create
+diff --git a/photon-client/src/components/dashboard/CamerasCard.vue b/photon-client/src/components/dashboard/CamerasCard.vue
+index 406aa107..4c30fe8a 100644
+--- a/photon-client/src/components/dashboard/CamerasCard.vue
++++ b/photon-client/src/components/dashboard/CamerasCard.vue
+@@ -1,13 +1,32 @@
+
++
++
++ {
+
+ return Math.sqrt(values.map((x) => Math.pow(angleModulus(x - mean), 2)).reduce((a, b) => a + b) / values.length);
+ };
++
++// SpectrumJetson: the camera's mount on the robot, from the same multi-tag samples. With the robot
++// level on the floor, the camera's field height, pitch and roll are its mount's (photonvision-17).
++const mean = (values: number[]): number => (values.length ? values.reduce((sum, v) => sum + v, 0) / values.length : 0);
++const plainStdDev = (values: number[]): number => {
++ if (values.length < 2) return 0;
++ const m = mean(values);
++ return Math.sqrt(values.reduce((sum, v) => sum + (v - m) * (v - m), 0) / values.length);
++};
++const mountHeights = computed(() => useStateStore().currentMultitagBuffer?.map((v) => v.bestTransform.z) || []);
++const mountPitches = computed(
++ () => useStateStore().currentMultitagBuffer?.map((v) => toDeg(v.bestTransform.angle_y)) || []
++);
++const mountRolls = computed(
++ () => useStateStore().currentMultitagBuffer?.map((v) => toDeg(v.bestTransform.angle_x)) || []
++);
+ const resetCurrentBuffer = () => {
+ // Need to clear the array in place
+ if (useStateStore().currentMultitagBuffer) useStateStore().currentMultitagBuffer!.length = 0;
+@@ -45,6 +61,7 @@ const resetCurrentBuffer = () => {
+ {
+ Confidence
+
+
+- Pitch θ°
+- Yaw θ°
++
++ Pitch θ° (+ up)
++
++
++ Yaw θ° (+ right)
++
+ Skew θ°
+ Area %
+
+@@ -69,6 +90,7 @@ const resetCurrentBuffer = () => {
+ {
+ {
+ {
+
++ Camera mount estimate from the same samples (robot level on the floor)
++
++
++
++
++
++ Height
++ Pitch θ°
++ Roll θ°
++
++
++
++
++
++ {{ mean(mountHeights).toFixed(3) }} m ± {{ plainStdDev(mountHeights).toFixed(3) }}
++
++
++ {{ mean(mountPitches).toFixed(2) }}° ± {{ plainStdDev(mountPitches).toFixed(2) }}
++
++
++ {{ mean(mountRolls).toFixed(2) }}° ± {{ plainStdDev(mountRolls).toFixed(2) }}
++
++
++
++
++
++
++ While the robot is level on the floor, the camera's height, pitch and roll on the field are its mount on the
++ robot, wherever the robot is. They use the same axes and signs as
++
+
+
+
+diff --git a/photon-client/src/components/dashboard/tabs/TuningGuide.vue b/photon-client/src/components/dashboard/tabs/TuningGuide.vue
+new file mode 100644
+index 00000000..8c55e5b5
+--- /dev/null
++++ b/photon-client/src/components/dashboard/tabs/TuningGuide.vue
+@@ -0,0 +1,109 @@
++
++
++
++
++
++
++ mdi-map-marker-path
++ Tuning guide: what to set, in order
++
++
++
++
++
++
++
++
+diff --git a/photon-client/src/components/fieldcal/CameraTuneCard.vue b/photon-client/src/components/fieldcal/CameraTuneCard.vue
+new file mode 100644
+index 00000000..cecf8bb9
+--- /dev/null
++++ b/photon-client/src/components/fieldcal/CameraTuneCard.vue
+@@ -0,0 +1,258 @@
++
++
++
++
++
++ Auto exposure is on for this pipeline: setting exposure here (or tuning it) turns it off.
++
++
++
++
++
++
++ mdi-lock
++
++ Setting
++ Now
++ Tuned
++
++
++
++
++
++
++ {{ LABEL[c.key] }}
++
++
++
++ {{ fmt(c.key, shown(c)) }}
++
++
++
++ {{
++ fmt(c.key, tune.recommended[c.key])
++ }}
++ keep
++
++ locked when tuned
++ ({{ tune.notes[c.key] }})
++
++
++
++
++
++
++
++
+diff --git a/photon-client/src/components/fieldcal/FieldCal3D.vue b/photon-client/src/components/fieldcal/FieldCal3D.vue
+new file mode 100644
+index 00000000..6d31f124
+--- /dev/null
++++ b/photon-client/src/components/fieldcal/FieldCal3D.vue
+@@ -0,0 +1,353 @@
++
++
++
++ (null);
++const excludedText = ref("");
++const excludedBusy = ref(false);
++const excludedTextValid = (text: string) => /^[\d,\s]*$/.test(text);
++const loadExcluded = oneAtATime(async (updateText: boolean = false) => {
++ try {
++ excluded.value = (await axios.get("/excludedTags", { timeout: POLL_TIMEOUT_MS })).data;
++ if (updateText && excluded.value) excludedText.value = excluded.value.saved.join(", ");
++ } catch {
++ excluded.value = null;
++ }
++});
++const saveExcluded = async () => {
++ excludedBusy.value = true;
++ try {
++ const saved = excludedText.value
++ .split(/[,\s]+/)
++ .filter((part) => part.length > 0)
++ .map((part) => parseInt(part, 10));
++ excluded.value = (await axios.post("/excludedTags", { saved })).data;
++ excludedText.value = excluded.value?.saved.join(", ") ?? excludedText.value;
++ useStateStore().showSnackbarMessage({ message: "Saved the tags to leave out of multi-tag", color: "success" });
++ } catch (e: any) {
++ useStateStore().showSnackbarMessage({
++ message: e?.response?.data || "Could not save the tags to leave out",
++ color: "error"
++ });
++ } finally {
++ excludedBusy.value = false;
++ }
++};
++const isExcluded = (id: number) => excluded.value?.active.includes(id) ?? false;
++let excludedTimer: ReturnType | undefined;
++onMounted(() => {
++ loadExcluded(true);
++ excludedTimer = setInterval(() => loadExcluded(false), 2000); // the robot's list can change
++});
++onBeforeUnmount(() => clearInterval(excludedTimer));
+
+ const currentFieldLayout = computed(() => useSettingsStore().currentFieldLayout);
+ const fieldWidth = computed(() => currentFieldLayout.value["field-dimensions"].width);
+@@ -25,6 +71,36 @@ const quaternionToEuler = (rot_quat: Quaternion): { x: number; y: number; z: num
+
+
+@@ -40,8 +116,12 @@ const quaternionToEuler = (rot_quat: Quaternion): { x: number; y: number; z: num
+
+
+
+-
+- {{ tag.ID }}
++
++ {{ tag.ID }}{{ isExcluded(tag.ID) ? " (left out)" : "" }}
+ {{ val.toFixed(2) }} m
+
+ {{ val.toFixed(2) }}°
+diff --git a/photon-client/src/components/settings/DeviceCard.vue b/photon-client/src/components/settings/DeviceCard.vue
+index ff1748c3..db66c633 100644
+--- a/photon-client/src/components/settings/DeviceCard.vue
++++ b/photon-client/src/components/settings/DeviceCard.vue
+@@ -192,7 +192,12 @@ const generalMetrics = computed(() => {
+ { header: "Image Version", value: useSettingsStore().general.imageVersion || "Unknown" },
+ { header: "Hardware Model", value: useSettingsStore().general.hardwareModel || "Unknown" },
+ { header: "Platform", value: useSettingsStore().general.hardwarePlatform || "Unknown" },
+- { header: "GPU Acceleration", value: useSettingsStore().general.gpuAcceleration || "None detected" }
++ // SpectrumJetson (photonvision-72): on a Jetson, what the CUDA detector and NVJPG do; upstream's
++ // field is the Raspberry Pi's camera path, so it said "None detected" there.
++ {
++ header: "GPU Acceleration",
++ value: useSettingsStore().general.gpuAcceleration || useSettingsStore().general.spectrumGpu || "None detected"
++ }
+ ];
+
+ if (!useSettingsStore().network.networkingDisabled) {
+@@ -202,8 +207,23 @@ const generalMetrics = computed(() => {
+ return stats;
+ });
+
+-// @ts-expect-error This uses Intl.DurationFormat which is newly implemented and not available in TS.
+-const durationFormatter = new Intl.DurationFormat("en", { style: "narrow" });
++// Intl.DurationFormat is new (Chrome 129+, Firefox 136+). Constructing it unconditionally threw
++// on older browsers and blanked the whole Device Control card (restart/import/export buttons),
++// so fall back to a simple "2h 39m 7s" formatter when it's missing.
++type DurationParts = { days: number; hours: number; minutes: number; seconds: number };
++const IntlDurationFormat = (
++ Intl as unknown as {
++ DurationFormat?: new (locale: string, options: object) => { format: (d: DurationParts) => string };
++ }
++).DurationFormat;
++const durationFormatter = IntlDurationFormat
++ ? new IntlDurationFormat("en", { style: "narrow" })
++ : {
++ format: ({ days, hours, minutes, seconds }: DurationParts) =>
++ [days ? `${days}d` : "", hours ? `${hours}h` : "", minutes ? `${minutes}m` : "", `${seconds}s`]
++ .filter(Boolean)
++ .join(" ")
++ };
+ const platformMetrics = computed(() => {
+ const metrics = useSettingsStore().metrics;
+ const stats = [
+@@ -260,6 +280,9 @@ const platformMetrics = computed(() => {
+ });
+
+ const cpuUsageData = ref<{ time: number; value: number }[]>([]);
++// SpectrumJetson: GPU usage (photonvision-19); the chart shows only where the GPU reports it
++const gpuUsageData = ref<{ time: number; value: number }[]>([]);
++const hasGpuUsage = computed(() => (useSettingsStore().metrics.gpuUtil ?? -1) >= 0);
+ const cpuMemoryUsageData = ref<{ time: number; value: number }[]>([]);
+ const cpuTempData = ref<{ time: number; value: number }[]>([]);
+ const networkUsageData = ref<{ time: number; value: number }[]>([]);
+@@ -269,6 +292,10 @@ watch(metricsHistorySnapshot, () => {
+ time: entry.time,
+ value: entry.metrics.cpuUtil ?? 0
+ }));
++ gpuUsageData.value = metricsHistorySnapshot.value.map((entry) => ({
++ time: entry.time,
++ value: Math.max(entry.metrics.gpuUtil ?? 0, 0)
++ }));
+ cpuMemoryUsageData.value = metricsHistorySnapshot.value.map((entry) => ({
+ time: entry.time,
+ value: entry.metrics.ramUtil === -1 ? -1 : ((entry.metrics.ramUtil ?? 0) / (entry.metrics.ramMem ?? -1.0)) * 100
+@@ -438,6 +465,17 @@ watch(metricsHistorySnapshot, () => {
+ Loading...
+
+
++
++
++
++
++
+
+
Settings to copy:
++Orientation, names and each camera's exposure limits are never copied.
++++ Each camera gets it as its next pipeline number, so cameras with the same number of pipelines ++ get the same number. Only this camera switches to it. ++
+ +
++
++
+diff --git a/photon-client/src/components/dashboard/tabs/AprilTagTab.vue b/photon-client/src/components/dashboard/tabs/AprilTagTab.vue
+index f653bc66..6a28e4af 100644
+--- a/photon-client/src/components/dashboard/tabs/AprilTagTab.vue
++++ b/photon-client/src/components/dashboard/tabs/AprilTagTab.vue
+@@ -63,7 +63,7 @@ const interactiveCols = computed(() =>
+ v-model="currentPipelineSettings.decisionMargin"
+ :slider-cols="interactiveCols"
+ label="Decision Margin Cutoff"
+- tooltip="Tags with a 'margin' (decoding quality score) less than this wil be rejected. Increase this to reduce the number of false positive detections"
++ tooltip="Recommended: 15 at 5 ms exposure. Tags with a 'margin' (decoding quality score) below this are rejected. Set it a little below what real tags score at your longest distance; raise it if false tags appear"
+ :min="0"
+ :max="250"
+ @update:modelValue="
+diff --git a/photon-client/src/components/dashboard/tabs/InputTab.vue b/photon-client/src/components/dashboard/tabs/InputTab.vue
+index 203ea5c2..836dd5ed 100644
+--- a/photon-client/src/components/dashboard/tabs/InputTab.vue
++++ b/photon-client/src/components/dashboard/tabs/InputTab.vue
+@@ -1,4 +1,6 @@
+
++
++
++ ++ The CUDA detector runs at full resolution with fixed parameters; decimate, blur, threads and refine edges do not ++ apply. ++
++
++
++
++
++ Box
++ Left
++ Top
++ Width
++ Height
++
++
++
++
++ {{ i + 1 }}
++ {{ pct(b.x) }}
++ {{ pct(b.y) }}
++ {{ pct(b.w) }}
++ {{ pct(b.h) }}
++
++
++
++
++
++
++ Remove all boxes
++
++
++
+diff --git a/photon-client/src/components/dashboard/tabs/OutputTab.vue b/photon-client/src/components/dashboard/tabs/OutputTab.vue
+index 0ffd7794..18114767 100644
+--- a/photon-client/src/components/dashboard/tabs/OutputTab.vue
++++ b/photon-client/src/components/dashboard/tabs/OutputTab.vue
+@@ -21,6 +21,7 @@ const theme = useTheme();
+ const isTagPipeline = computed(
+ () =>
+ useCameraSettingsStore().currentPipelineType === PipelineType.AprilTag ||
++ useCameraSettingsStore().currentPipelineType === PipelineType.AprilTagCuda ||
+ useCameraSettingsStore().currentPipelineType === PipelineType.Aruco
+ );
+
+@@ -81,6 +82,7 @@ const interactiveCols = computed(() =>
+ ++ {{ ++ isObjectDetection ++ ? "A detection whose centre is in an ignored area is dropped." ++ : "Ignored areas are removed on the GPU before tags are searched for, so they cost nothing. A tag that crosses the edge of an ignored area is lost: keep the boxes clear of anywhere a tag can be." ++ }} ++
++robotToCamera in robot code:
++ negative pitch means tilted up. Yaw and the X/Y offsets also need the robot's pose. Robot code gets these
++ numbers, and the camera's field X, Y and yaw, from /photonvision/<camera>/mount on
++ NetworkTables.
++ -
++
- ++ Resolution: 1280x800 at 120 FPS, MJPEG, the resolution the camera is calibrated at. YUYV only manages ++ about 5 fps at this size. ++ ++
- ++ Auto Exposure: off. Auto exposure picks long exposures, which look great with the robot standing ++ still and blur as soon as it moves or turns. So does an image tuned by eye while standing still. ++ ++
-
++ Exposure: as short as tags still decode. Start at 5 ms (50).
++
-
++
- ++ Blur grows with exposure. Spinning at 3 rad/s smears a tag about 11 px in 5 ms and 44 px in 20 ms. ++ Driving at 4 m/s moves the camera 2 cm in 5 ms. ++ ++
- Go shorter (3 ms) if tags blur while driving; longer only if far tags drop out. ++
- ++ Under event lights, run the flicker check. If frames pulse in brightness, use 8.3 ms (83), which matches ++ the lights' 120 Hz flicker. ++ ++
++ - ++ Brightness: 100, to make up for the short exposure. These cameras report no gain control, so ++ brightness is what's left. If tag edges wash out, the decision margin drops: back off. ++ ++
- ++ Contrast, gamma, sharpness: leave them at the camera's defaults unless you're testing them. Sharpness ++ is the one worth trying lower: the camera's sharpening can put halos on tag edges. ++ ++
- ++ Decision margin cutoff (AprilTag tab): 15 at 5 ms. Tags scoring below it are dropped. Set it a little ++ below what real tags score at your longest distance, and raise it if false tags appear. ++ ++
- ++ Leave the rest: Low Latency Mode off (full frame rate), Stream Resolution smallest (it only affects ++ this view, and bigger costs CPU), white balance doesn't matter on a mono camera. ++ ++
- ++ 3D and multi-tag on (Output tab), once this resolution is calibrated. The robot's pose code needs ++ both. ++ ++
- ++ Check it on the field: drive and spin past tags and watch that they don't drop out. Retune at every ++ venue; lighting differs. Keep an Event and a Practice pipeline at the same numbers on every camera, and use ++ the pipeline menu's Copy settings from… to set the other cameras. ++ ++
-
++
- Resolution: the one the model and calibration expect. The model sees a 640x640 letterbox. ++
- ++ Auto Exposure: off. Exposure: short, about 5–10 ms. Moving game pieces blur like tags do, and blurred ++ pieces score lower. ++ ++
- ++ Colour cameras: Auto White Balance off with a fixed temperature, so a piece's colour doesn't drift ++ between frames. ++ ++
- ++ Frame rate: Object Detection is capped at 30 fps on this Jetson by default, so it doesn't take GPU ++ time from the AprilTag cameras. ++ ++
- ++ Confidence (Object Detection tab): start at the model's default, then lower it until real pieces are ++ found at your longest distance without false ones. ++ ++
++ Calibrating? The calibration uses its own settings. A long exposure (about 15 ms) is fine there because the ++ board is held still. Don't copy it into these settings. ++
++
++ {{ name }}
++ pipeline {{ pipelineIndex }}
++ no recent frames
++
++ sees {{ seen.map((s) => `${s.id} (${s.margin})`).join(", ") }}
++
++ sees no tags: turn the robot
++
++
++
++ Tune {{ name }}
++
++ {{ phase }}
++ Stop
++
++ Apply recommended
++ {{ tune.outcome }}
++
++
++ Measured on tags {{ tune.baselineTags.join(", ") }}: margin {{ Math.round(tune.baseline.margin) }}, jitter
++ {{ tune.baseline.jitterPx.toFixed(2) }} px at the start.
++
++
++ {{
++ tried(c.key)
++ .map((r) => `${r.value}: ${Math.round(100 * r.found)}%/${Math.round(r.margin)}`)
++ .join(" ")
++ }}
++
++
++ Tried: value: tags found / decision margin. Changes here save to pipeline {{ pipelineIndex }}, like the Camera
++ page's Input tab.
++
++
++
++
++
++
+diff --git a/photon-client/src/components/fieldcal/FieldCalMap.vue b/photon-client/src/components/fieldcal/FieldCalMap.vue
+new file mode 100644
+index 00000000..b70eea25
+--- /dev/null
++++ b/photon-client/src/components/fieldcal/FieldCalMap.vue
+@@ -0,0 +1,211 @@
++
++
++
++
++
++
++
+diff --git a/photon-client/src/components/settings/ApriltagControlCard.vue b/photon-client/src/components/settings/ApriltagControlCard.vue
+index 600f2a1b..7c7e99e3 100644
+--- a/photon-client/src/components/settings/ApriltagControlCard.vue
++++ b/photon-client/src/components/settings/ApriltagControlCard.vue
+@@ -2,8 +2,54 @@
+ import { useSettingsStore } from "@/stores/settings/GeneralSettingsStore";
+ import type { FieldTag, Quaternion } from "@/types/PhotonTrackingTypes";
+ import { toDeg } from "@/lib/MathUtils";
+-import { computed } from "vue";
++import { computed, onBeforeUnmount, onMounted, ref } from "vue";
++import axios from "axios";
++import { oneAtATime, POLL_TIMEOUT_MS } from "@/lib/Poll";
++import { useStateStore } from "@/stores/StateStore";
++import { useTheme } from "vuetify";
+ const { Euler, Quaternion: ThreeQuat } = await import("three");
++const theme = useTheme();
++
++// SpectrumJetson (photonvision-22): tags left out of multi-tag on every camera. List the bad ones.
++type ExcludedTags = { saved: number[]; robot: number[]; active: number[] };
++const excluded = ref
++ Blue wall
++ Red wall
++ Top
++
++
++
++ Like Onshape: right-drag to turn, middle-drag or Ctrl + right-drag to move, scroll to zoom.
++ {{
++ modelNote ||
++ (game === "2026cad"
++ ? "The field is FIRST's official CAD, each element placed by its tags."
++ : "Field elements are simplified.")
++ }}
++
++ Field width: {{ fieldWidth.toFixed(2) }} meters
+Field length: {{ fieldLength.toFixed(2) }} meters
+ ++
++
++
+
+ ++ Tags left out of multi-tag (every camera). List the bad tags, e.g. one mounted wrong at an event. ++ They're still reported as targets. ++
++
++
++ Save
++
++
++ Robot code adds: {{ excluded.robot.join(", ") }}
++++ Left out now: {{ excluded ? (excluded.active.length ? excluded.active.join(", ") : "none") : "unknown" }} ++
++
++ GPU Usage
++ {{ Math.round(gpuUsageData.at(-1)?.value ?? 0) }}%
++
++
+ CPU Memory Usage
+diff --git a/photon-client/src/components/settings/GlobalSettingsCard.vue b/photon-client/src/components/settings/GlobalSettingsCard.vue
+index fa922893..6f9a10f9 100644
+--- a/photon-client/src/components/settings/GlobalSettingsCard.vue
++++ b/photon-client/src/components/settings/GlobalSettingsCard.vue
+@@ -1,6 +1,7 @@
+
++
++
++
++