From 27cb69c094dedb7b89dbaadf883f61a7340089f2 Mon Sep 17 00:00:00 2001
From: Christopher Mahoney <christopher.mahoney2000@gmail.com>
Date: Sat, 21 Sep 2024 16:08:00 -0400
Subject: [PATCH 1/7] Support selecting Object Detection models (#1359)

This PR is for part 1 of #1354. It focuses on adding a model selection
interface for models that exist in `photonvision_config/models/`. Upon
completion we can ship more than 1 model and users could upload their
own through `ssh` without deleting the shipped model. This PR also adds
the abstractions need to support more DNN backends (say OpenCV, or RPI
AI Kit)

Up next is adding a CRUD interface for managing models through the UI.
---
 .../dashboard/CameraAndPipelineSelectCard.vue |   4 +-
 .../dashboard/tabs/ObjectDetectionTab.vue     |  27 +-
 .../stores/settings/GeneralSettingsStore.ts   |   6 +-
 photon-client/src/types/PipelineTypes.ts      |   4 +-
 photon-client/src/types/SettingTypes.ts       |   3 +-
 .../NeuralNetworkModelManager.java            | 297 +++++++++++++++---
 .../configuration/PhotonConfiguration.java    |   5 +-
 .../org/photonvision/jni/RknnDetectorJNI.java |  96 ------
 .../photonvision/jni/RknnObjectDetector.java  | 147 +++++++++
 .../vision/objects/Letterbox.java             | 105 +++++++
 .../photonvision/vision/objects/Model.java    |  24 ++
 .../vision/objects/NullModel.java             |  67 ++++
 .../vision/objects/ObjectDetector.java        |  60 ++++
 .../vision/objects/RknnModel.java             |  91 ++++++
 .../vision/pipe/impl/ObjectDetectionPipe.java |  75 +++++
 .../vision/pipe/impl/RknnDetectionPipe.java   | 153 ---------
 .../pipeline/ObjectDetectionPipeline.java     |  36 ++-
 .../ObjectDetectionPipelineSettings.java      |   6 +
 .../src/main/java/org/photonvision/Main.java  |   9 +-
 ...v5.txt => note-640-640-yolov5s-labels.txt} |   0
 20 files changed, 895 insertions(+), 320 deletions(-)
 create mode 100644 photon-core/src/main/java/org/photonvision/jni/RknnObjectDetector.java
 create mode 100644 photon-core/src/main/java/org/photonvision/vision/objects/Letterbox.java
 create mode 100644 photon-core/src/main/java/org/photonvision/vision/objects/Model.java
 create mode 100644 photon-core/src/main/java/org/photonvision/vision/objects/NullModel.java
 create mode 100644 photon-core/src/main/java/org/photonvision/vision/objects/ObjectDetector.java
 create mode 100644 photon-core/src/main/java/org/photonvision/vision/objects/RknnModel.java
 create mode 100644 photon-core/src/main/java/org/photonvision/vision/pipe/impl/ObjectDetectionPipe.java
 delete mode 100644 photon-core/src/main/java/org/photonvision/vision/pipe/impl/RknnDetectionPipe.java
 rename photon-server/src/main/resources/models/{labels_v5.txt => note-640-640-yolov5s-labels.txt} (100%)

diff --git a/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue b/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue
index 38505dee0f..8f5f3b33e3 100644
--- a/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue
+++ b/photon-client/src/components/dashboard/CameraAndPipelineSelectCard.vue
@@ -132,7 +132,7 @@ const validNewPipelineTypes = computed(() => {
     { name: "AprilTag", value: WebsocketPipelineType.AprilTag },
     { name: "Aruco", value: WebsocketPipelineType.Aruco }
   ];
-  if (useSettingsStore().general.rknnSupported) {
+  if (useSettingsStore().general.supportedBackends.length > 0) {
     pipelineTypes.push({ name: "Object Detection", value: WebsocketPipelineType.ObjectDetection });
   }
   return pipelineTypes;
@@ -170,7 +170,7 @@ const pipelineTypesWrapper = computed<{ name: string; value: number }[]>(() => {
     { name: "AprilTag", value: WebsocketPipelineType.AprilTag },
     { name: "Aruco", value: WebsocketPipelineType.Aruco }
   ];
-  if (useSettingsStore().general.rknnSupported) {
+  if (useSettingsStore().general.supportedBackends.length > 0) {
     pipelineTypes.push({ name: "Object Detection", value: WebsocketPipelineType.ObjectDetection });
   }
 
diff --git a/photon-client/src/components/dashboard/tabs/ObjectDetectionTab.vue b/photon-client/src/components/dashboard/tabs/ObjectDetectionTab.vue
index 25de890ac0..5128f1db44 100644
--- a/photon-client/src/components/dashboard/tabs/ObjectDetectionTab.vue
+++ b/photon-client/src/components/dashboard/tabs/ObjectDetectionTab.vue
@@ -1,14 +1,15 @@
 <script setup lang="ts">
 import { useCameraSettingsStore } from "@/stores/settings/CameraSettingsStore";
-import { type ActivePipelineSettings, PipelineType } from "@/types/PipelineTypes";
+import { type ObjectDetectionPipelineSettings, PipelineType } from "@/types/PipelineTypes";
 import PvSlider from "@/components/common/pv-slider.vue";
 import { computed, getCurrentInstance } from "vue";
 import { useStateStore } from "@/stores/StateStore";
+import { useSettingsStore } from "@/stores/settings/GeneralSettingsStore";
 
 // TODO fix pipeline typing in order to fix this, the store settings call should be able to infer that only valid pipeline type settings are exposed based on pre-checks for the entire config section
 // Defer reference to store access method
-const currentPipelineSettings = computed<ActivePipelineSettings>(
-  () => useCameraSettingsStore().currentPipelineSettings
+const currentPipelineSettings = computed<ObjectDetectionPipelineSettings>(
+  () => useCameraSettingsStore().currentPipelineSettings as ObjectDetectionPipelineSettings
 );
 
 // TODO fix pv-range-slider so that store access doesn't need to be deferred
@@ -27,10 +28,30 @@ const interactiveCols = computed(() =>
     ? 9
     : 8
 );
+
+// Filters out models that are not supported by the current backend, and returns a flattened list.
+const supportedModels = computed(() => {
+  const { availableModels, supportedBackends } = useSettingsStore().general;
+  return supportedBackends.flatMap((backend) => availableModels[backend] || []);
+});
+
+const selectedModel = computed({
+  get: () => supportedModels.value.indexOf(currentPipelineSettings.value.model),
+  set: (v) => {
+    useCameraSettingsStore().changeCurrentPipelineSetting({ model: supportedModels.value[v] }, false);
+  }
+});
 </script>
 
 <template>
   <div v-if="currentPipelineSettings.pipelineType === PipelineType.ObjectDetection">
+    <pv-select
+      v-model="selectedModel"
+      label="Model"
+      tooltip="The model used to detect objects in the camera feed"
+      :select-cols="interactiveCols"
+      :items="supportedModels"
+    />
     <pv-slider
       v-model="currentPipelineSettings.confidence"
       class="pt-2"
diff --git a/photon-client/src/stores/settings/GeneralSettingsStore.ts b/photon-client/src/stores/settings/GeneralSettingsStore.ts
index ce52df1539..4ea4f06ac2 100644
--- a/photon-client/src/stores/settings/GeneralSettingsStore.ts
+++ b/photon-client/src/stores/settings/GeneralSettingsStore.ts
@@ -28,7 +28,8 @@ export const useSettingsStore = defineStore("settings", {
       hardwareModel: undefined,
       hardwarePlatform: undefined,
       mrCalWorking: true,
-      rknnSupported: false
+      availableModels: {},
+      supportedBackends: []
     },
     network: {
       ntServerAddress: "",
@@ -105,7 +106,8 @@ export const useSettingsStore = defineStore("settings", {
         hardwarePlatform: data.general.hardwarePlatform || undefined,
         gpuAcceleration: data.general.gpuAcceleration || undefined,
         mrCalWorking: data.general.mrCalWorking,
-        rknnSupported: data.general.rknnSupported
+        availableModels: data.general.availableModels || undefined,
+        supportedBackends: data.general.supportedBackends || []
       };
       this.lighting = data.lighting;
       this.network = data.networkSettings;
diff --git a/photon-client/src/types/PipelineTypes.ts b/photon-client/src/types/PipelineTypes.ts
index 4aa0d3c92d..7223f3ffcb 100644
--- a/photon-client/src/types/PipelineTypes.ts
+++ b/photon-client/src/types/PipelineTypes.ts
@@ -289,6 +289,7 @@ export interface ObjectDetectionPipelineSettings extends PipelineSettings {
   confidence: number;
   nms: number;
   box_thresh: number;
+  model: string;
 }
 export type ConfigurableObjectDetectionPipelineSettings = Partial<
   Omit<ObjectDetectionPipelineSettings, "pipelineType">
@@ -304,7 +305,8 @@ export const DefaultObjectDetectionPipelineSettings: ObjectDetectionPipelineSett
   cameraExposureRaw: 6,
   confidence: 0.9,
   nms: 0.45,
-  box_thresh: 0.25
+  box_thresh: 0.25,
+  model: ""
 };
 
 export type ActivePipelineSettings =
diff --git a/photon-client/src/types/SettingTypes.ts b/photon-client/src/types/SettingTypes.ts
index 1216e7801a..89fbc5c24b 100644
--- a/photon-client/src/types/SettingTypes.ts
+++ b/photon-client/src/types/SettingTypes.ts
@@ -7,7 +7,8 @@ export interface GeneralSettings {
   hardwareModel?: string;
   hardwarePlatform?: string;
   mrCalWorking: boolean;
-  rknnSupported: boolean;
+  availableModels: Record<string, string[]>;
+  supportedBackends: string[];
 }
 
 export interface MetricData {
diff --git a/photon-core/src/main/java/org/photonvision/common/configuration/NeuralNetworkModelManager.java b/photon-core/src/main/java/org/photonvision/common/configuration/NeuralNetworkModelManager.java
index 75a1ded750..f6ba9a18f8 100644
--- a/photon-core/src/main/java/org/photonvision/common/configuration/NeuralNetworkModelManager.java
+++ b/photon-core/src/main/java/org/photonvision/common/configuration/NeuralNetworkModelManager.java
@@ -18,24 +18,63 @@
 package org.photonvision.common.configuration;
 
 import java.io.File;
-import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
+import java.net.URISyntaxException;
 import java.nio.file.Files;
-import java.nio.file.Paths;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import org.photonvision.common.hardware.Platform;
 import org.photonvision.common.logging.LogGroup;
 import org.photonvision.common.logging.Logger;
-import org.photonvision.rknn.RknnJNI;
+import org.photonvision.vision.objects.Model;
+import org.photonvision.vision.objects.RknnModel;
 
+/**
+ * Manages the loading of neural network models.
+ *
+ * <p>Models are loaded from the filesystem at the <code>modelsFolder</code> location. PhotonVision
+ * also supports shipping pre-trained models as resources in the JAR. If the model has already been
+ * extracted to the filesystem, it will not be extracted again.
+ *
+ * <p>Each model must have a corresponding <code>labels</code> file. The labels file format is
+ * simply a list of string names per label, one label per line. The labels file must have the same
+ * name as the model file, but with the suffix <code>-labels.txt</code> instead of <code>.rknn
+ * </code>.
+ */
 public class NeuralNetworkModelManager {
+    /** Singleton instance of the NeuralNetworkModelManager */
     private static NeuralNetworkModelManager INSTANCE;
-    private static final Logger logger = new Logger(NeuralNetworkModelManager.class, LogGroup.Config);
 
-    private final String MODEL_NAME = "note-640-640-yolov5s.rknn";
-    private final RknnJNI.ModelVersion modelVersion = RknnJNI.ModelVersion.YOLO_V5;
-    private File defaultModelFile;
-    private List<String> labels;
+    /**
+     * Private constructor to prevent instantiation
+     *
+     * @return The NeuralNetworkModelManager instance
+     */
+    private NeuralNetworkModelManager() {
+        ArrayList<NeuralNetworkBackend> backends = new ArrayList<>();
+
+        if (Platform.isRK3588()) {
+            backends.add(NeuralNetworkBackend.RKNN);
+        }
+
+        supportedBackends = backends;
+    }
 
+    /**
+     * Returns the singleton instance of the NeuralNetworkModelManager
+     *
+     * @return The singleton instance
+     */
     public static NeuralNetworkModelManager getInstance() {
         if (INSTANCE == null) {
             INSTANCE = new NeuralNetworkModelManager();
@@ -43,62 +82,226 @@ public static NeuralNetworkModelManager getInstance() {
         return INSTANCE;
     }
 
+    /** Logger for the NeuralNetworkModelManager */
+    private static final Logger logger = new Logger(NeuralNetworkModelManager.class, LogGroup.Config);
+
+    public enum NeuralNetworkBackend {
+        RKNN(".rknn");
+
+        private String format;
+
+        private NeuralNetworkBackend(String format) {
+            this.format = format;
+        }
+    }
+
+    private final List<NeuralNetworkBackend> supportedBackends;
+
     /**
-     * Perform initial setup and extract default model from JAR to the filesystem
+     * Retrieves the list of supported backends.
      *
-     * @param modelsFolder Where models live
+     * @return the list
      */
-    public void initialize(File modelsFolder) {
-        var modelResourcePath = "/models/" + MODEL_NAME;
-        this.defaultModelFile = new File(modelsFolder, MODEL_NAME);
-        extractResource(modelResourcePath, defaultModelFile);
+    public List<String> getSupportedBackends() {
+        return supportedBackends.stream().map(Enum::toString).toList();
+    }
 
-        File labelsFile = new File(modelsFolder, "labels_v5.txt");
-        var labelResourcePath = "/models/" + labelsFile.getName();
-        extractResource(labelResourcePath, labelsFile);
+    /**
+     * Stores model information, such as the model file, labels, and version.
+     *
+     * <p>The first model in the list is the default model.
+     */
+    private Map<NeuralNetworkBackend, ArrayList<Model>> models;
 
-        try {
-            labels = Files.readAllLines(Paths.get(labelsFile.getPath()));
-        } catch (IOException e) {
-            logger.error("Error reading labels.txt", e);
+    /**
+     * Retrieves the deep neural network models available, in a format that can be used by the
+     * frontend.
+     *
+     * @return A map containing the available models, where the key is the backend and the value is a
+     *     list of model names.
+     */
+    public HashMap<String, ArrayList<String>> getModels() {
+        HashMap<String, ArrayList<String>> modelMap = new HashMap<>();
+        if (models == null) {
+            return modelMap;
         }
+
+        models.forEach(
+                (backend, backendModels) -> {
+                    ArrayList<String> modelNames = new ArrayList<>();
+                    backendModels.forEach(model -> modelNames.add(model.getName()));
+                    modelMap.put(backend.toString(), modelNames);
+                });
+
+        return modelMap;
     }
 
-    private void extractResource(String resourcePath, File outputFile) {
-        try (var in = NeuralNetworkModelManager.class.getResourceAsStream(resourcePath)) {
-            if (in == null) {
-                logger.error("Failed to find jar resource at " + resourcePath);
-                return;
-            }
+    /**
+     * Retrieves the model with the specified name, assuming it is available under a supported
+     * backend.
+     *
+     * <p>If this method returns `Optional.of(..)` then the model should be safe to load.
+     *
+     * @param modelName the name of the model to retrieve
+     * @return an Optional containing the model if found, or an empty Optional if not found
+     */
+    public Optional<Model> getModel(String modelName) {
+        if (models == null) {
+            return Optional.empty();
+        }
 
-            if (!outputFile.exists()) {
-                try (FileOutputStream fos = new FileOutputStream(outputFile)) {
-                    int read = -1;
-                    byte[] buffer = new byte[1024];
-                    while ((read = in.read(buffer)) != -1) {
-                        fos.write(buffer, 0, read);
-                    }
-                } catch (IOException e) {
-                    logger.error("Error extracting resource to " + outputFile.toPath().toString(), e);
+        // Check if the model exists in any supported backend
+        for (NeuralNetworkBackend backend : supportedBackends) {
+            if (models.containsKey(backend)) {
+                Optional<Model> model =
+                        models.get(backend).stream().filter(m -> m.getName().equals(modelName)).findFirst();
+                if (model.isPresent()) {
+                    return model;
                 }
-            } else {
-                logger.info(
-                        "File " + outputFile.toPath().toString() + " already exists. Skipping extraction.");
             }
-        } catch (IOException e) {
-            logger.error("Error finding jar resource " + resourcePath, e);
         }
+
+        return Optional.empty();
     }
 
-    public File getDefaultRknnModel() {
-        return defaultModelFile;
+    /** The default model when no model is specified. */
+    public Optional<Model> getDefaultModel() {
+        if (models == null) {
+            return Optional.empty();
+        }
+
+        if (supportedBackends.isEmpty()) {
+            return Optional.empty();
+        }
+
+        return models.get(supportedBackends.get(0)).stream().findFirst();
+    }
+
+    private void loadModel(File model) {
+        if (models == null) {
+            models = new HashMap<>();
+        }
+
+        // Get the model extension and check if it is supported
+        String modelExtension = model.getName().substring(model.getName().lastIndexOf('.'));
+        if (modelExtension.equals(".txt")) {
+            return;
+        }
+
+        Optional<NeuralNetworkBackend> backend =
+                Arrays.stream(NeuralNetworkBackend.values())
+                        .filter(b -> b.format.equals(modelExtension))
+                        .findFirst();
+
+        if (!backend.isPresent()) {
+            logger.warn("Model " + model.getName() + " has an unknown extension.");
+            return;
+        }
+
+        String labels = model.getAbsolutePath().replace(backend.get().format, "-labels.txt");
+        if (!models.containsKey(backend.get())) {
+            models.put(backend.get(), new ArrayList<>());
+        }
+
+        try {
+            switch (backend.get()) {
+                case RKNN:
+                    models.get(backend.get()).add(new RknnModel(model, labels));
+                    logger.info(
+                            "Loaded model " + model.getName() + " for backend " + backend.get().toString());
+                    break;
+                default:
+                    break;
+            }
+        } catch (IllegalArgumentException e) {
+            logger.error("Failed to load model " + model.getName(), e);
+        } catch (IOException e) {
+            logger.error("Failed to read labels for model " + model.getName(), e);
+        }
     }
 
-    public List<String> getLabels() {
-        return labels;
+    /**
+     * Discovers DNN models from the specified folder.
+     *
+     * @param modelsFolder The folder where the models are stored
+     */
+    public void discoverModels(File modelsFolder) {
+        logger.info("Supported backends: " + supportedBackends);
+
+        if (!modelsFolder.exists()) {
+            logger.error("Models folder " + modelsFolder.getAbsolutePath() + " does not exist.");
+            return;
+        }
+
+        if (models == null) {
+            models = new HashMap<>();
+        }
+
+        try {
+            Files.walk(modelsFolder.toPath())
+                    .filter(Files::isRegularFile)
+                    .forEach(path -> loadModel(path.toFile()));
+        } catch (IOException e) {
+            logger.error("Failed to discover models at " + modelsFolder.getAbsolutePath(), e);
+        }
+
+        // After loading all of the models, sort them by name to ensure a consistent ordering
+        models.forEach(
+                (backend, backendModels) ->
+                        backendModels.sort((a, b) -> a.getName().compareTo(b.getName())));
+
+        // Log
+        StringBuilder sb = new StringBuilder();
+        sb.append("Discovered models: ");
+        models.forEach(
+                (backend, backendModels) -> {
+                    sb.append(backend).append(" [");
+                    backendModels.forEach(model -> sb.append(model.getName()).append(", "));
+                    sb.append("] ");
+                });
     }
 
-    public RknnJNI.ModelVersion getModelVersion() {
-        return modelVersion;
+    /**
+     * Extracts models from the JAR and copies them to disk.
+     *
+     * @param modelsDirectory the directory on disk to save models
+     */
+    public void extractModels(File modelsDirectory) {
+        if (!modelsDirectory.exists() && !modelsDirectory.mkdirs()) {
+            throw new RuntimeException("Failed to create directory: " + modelsDirectory);
+        }
+
+        String resource = "models";
+
+        try {
+            String jarPath =
+                    getClass().getProtectionDomain().getCodeSource().getLocation().toURI().getPath();
+            try (JarFile jarFile = new JarFile(jarPath)) {
+                Enumeration<JarEntry> entries = jarFile.entries();
+                while (entries.hasMoreElements()) {
+                    JarEntry entry = entries.nextElement();
+                    if (!entry.getName().startsWith(resource + "/") || entry.isDirectory()) {
+                        continue;
+                    }
+                    Path outputPath =
+                            modelsDirectory.toPath().resolve(entry.getName().substring(resource.length() + 1));
+
+                    if (Files.exists(outputPath)) {
+                        logger.info("Skipping extraction of DNN resource: " + entry.getName());
+                        continue;
+                    }
+
+                    Files.createDirectories(outputPath.getParent());
+                    try (InputStream inputStream = jarFile.getInputStream(entry)) {
+                        Files.copy(inputStream, outputPath, StandardCopyOption.REPLACE_EXISTING);
+                        logger.info("Extracted DNN resource: " + entry.getName());
+                    } catch (IOException e) {
+                        logger.error("Failed to extract DNN resource: " + entry.getName(), e);
+                    }
+                }
+            }
+        } catch (IOException | URISyntaxException e) {
+            logger.error("Error extracting models", e);
+        }
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/common/configuration/PhotonConfiguration.java b/photon-core/src/main/java/org/photonvision/common/configuration/PhotonConfiguration.java
index 246d263b26..614c00135c 100644
--- a/photon-core/src/main/java/org/photonvision/common/configuration/PhotonConfiguration.java
+++ b/photon-core/src/main/java/org/photonvision/common/configuration/PhotonConfiguration.java
@@ -28,7 +28,6 @@
 import org.photonvision.common.networking.NetworkManager;
 import org.photonvision.common.networking.NetworkUtils;
 import org.photonvision.common.util.SerializationUtils;
-import org.photonvision.jni.RknnDetectorJNI;
 import org.photonvision.mrcal.MrCalJNILoader;
 import org.photonvision.raspi.LibCameraJNILoader;
 import org.photonvision.vision.calibration.UICameraCalibrationCoefficients;
@@ -139,7 +138,9 @@ public Map<String, Object> toHashMap() {
                         ? "Zerocopy Libcamera Working"
                         : ""); // TODO add support for other types of GPU accel
         generalSubmap.put("mrCalWorking", MrCalJNILoader.getInstance().isLoaded());
-        generalSubmap.put("rknnSupported", RknnDetectorJNI.getInstance().isLoaded());
+        generalSubmap.put("availableModels", NeuralNetworkModelManager.getInstance().getModels());
+        generalSubmap.put(
+                "supportedBackends", NeuralNetworkModelManager.getInstance().getSupportedBackends());
         generalSubmap.put("hardwareModel", hardwareConfig.deviceName);
         generalSubmap.put("hardwarePlatform", Platform.getPlatformName());
         settingsSubmap.put("general", generalSubmap);
diff --git a/photon-core/src/main/java/org/photonvision/jni/RknnDetectorJNI.java b/photon-core/src/main/java/org/photonvision/jni/RknnDetectorJNI.java
index c282ec7a79..6ad21fd9cd 100644
--- a/photon-core/src/main/java/org/photonvision/jni/RknnDetectorJNI.java
+++ b/photon-core/src/main/java/org/photonvision/jni/RknnDetectorJNI.java
@@ -18,20 +18,10 @@
 package org.photonvision.jni;
 
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.stream.Collectors;
-import org.opencv.core.Mat;
-import org.photonvision.common.logging.LogGroup;
-import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.TestUtils;
-import org.photonvision.rknn.RknnJNI;
-import org.photonvision.rknn.RknnJNI.RknnResult;
-import org.photonvision.vision.pipe.impl.NeuralNetworkPipeResult;
 
 public class RknnDetectorJNI extends PhotonJNICommon {
-    private static final Logger logger = new Logger(RknnDetectorJNI.class, LogGroup.General);
     private boolean isLoaded;
     private static RknnDetectorJNI instance = null;
 
@@ -60,90 +50,4 @@ public boolean isLoaded() {
     public void setLoaded(boolean state) {
         isLoaded = state;
     }
-
-    public static class RknnObjectDetector {
-        long objPointer = -1;
-        private List<String> labels;
-        private final Object lock = new Object();
-        private static final CopyOnWriteArrayList<RknnObjectDetector> detectors =
-                new CopyOnWriteArrayList<>();
-
-        static volatile boolean hook = false;
-
-        public RknnObjectDetector(String modelPath, List<String> labels, RknnJNI.ModelVersion version) {
-            synchronized (lock) {
-                objPointer = RknnJNI.create(modelPath, labels.size(), version.ordinal(), -1);
-                detectors.add(this);
-                logger.debug(
-                        "Created detector "
-                                + objPointer
-                                + " from path "
-                                + modelPath
-                                + "! Detectors: "
-                                + Arrays.toString(detectors.toArray()));
-            }
-            this.labels = labels;
-
-            // the kernel should probably alredy deal with this for us, but I'm gunna be paranoid anyways.
-            if (!hook) {
-                Runtime.getRuntime()
-                        .addShutdownHook(
-                                new Thread(
-                                        () -> {
-                                            System.err.println("Shutdown hook rknn");
-                                            for (var d : detectors) {
-                                                d.release();
-                                            }
-                                        }));
-                hook = true;
-            }
-        }
-
-        public List<String> getClasses() {
-            return labels;
-        }
-
-        /**
-         * Detect forwards using this model
-         *
-         * @param in The image to process
-         * @param nmsThresh Non-maximum supression threshold. Probably should not change
-         * @param boxThresh Minimum confidence for a box to be added. Basically just confidence
-         *     threshold
-         */
-        public List<NeuralNetworkPipeResult> detect(Mat in, double nmsThresh, double boxThresh) {
-            RknnResult[] ret;
-            synchronized (lock) {
-                // We can technically be asked to detect and the lock might be acquired _after_ release has
-                // been called. This would mean objPointer would be invalid which would call everything to
-                // explode.
-                if (objPointer > 0) {
-                    ret = RknnJNI.detect(objPointer, in.getNativeObjAddr(), nmsThresh, boxThresh);
-                } else {
-                    logger.warn("Detect called after destroy -- giving up");
-                    return List.of();
-                }
-            }
-            if (ret == null) {
-                return List.of();
-            }
-            return List.of(ret).stream()
-                    .map(it -> new NeuralNetworkPipeResult(it.rect, it.class_id, it.conf))
-                    .collect(Collectors.toList());
-        }
-
-        public void release() {
-            synchronized (lock) {
-                if (objPointer > 0) {
-                    RknnJNI.destroy(objPointer);
-                    detectors.remove(this);
-                    System.out.println(
-                            "Killed " + objPointer + "! Detectors: " + Arrays.toString(detectors.toArray()));
-                    objPointer = -1;
-                } else {
-                    logger.error("RKNN Detector has already been destroyed!");
-                }
-            }
-        }
-    }
 }
diff --git a/photon-core/src/main/java/org/photonvision/jni/RknnObjectDetector.java b/photon-core/src/main/java/org/photonvision/jni/RknnObjectDetector.java
new file mode 100644
index 0000000000..34d09eb04a
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/jni/RknnObjectDetector.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.jni;
+
+import java.awt.Color;
+import java.lang.ref.Cleaner;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
+import org.photonvision.common.util.ColorHelper;
+import org.photonvision.rknn.RknnJNI;
+import org.photonvision.vision.objects.Letterbox;
+import org.photonvision.vision.objects.ObjectDetector;
+import org.photonvision.vision.objects.RknnModel;
+import org.photonvision.vision.pipe.impl.NeuralNetworkPipeResult;
+
+/** Manages an object detector using the rknn backend. */
+public class RknnObjectDetector implements ObjectDetector {
+    private static final Logger logger = new Logger(RknnDetectorJNI.class, LogGroup.General);
+
+    /** Cleaner instance to release the detector when it goes out of scope */
+    private final Cleaner cleaner = Cleaner.create();
+
+    /** Atomic boolean to ensure that the native object can only be released once. */
+    private AtomicBoolean released = new AtomicBoolean(false);
+
+    /** Pointer to the native object */
+    private final long objPointer;
+
+    private final RknnModel model;
+
+    private final Size inputSize;
+
+    /** Returns the model in use by this detector. */
+    @Override
+    public RknnModel getModel() {
+        return model;
+    }
+
+    /**
+     * Creates a new RknnObjectDetector from the given model.
+     *
+     * @param model The model to create the detector from.
+     * @param inputSize The required image dimensions for the model. Images will be {@link
+     *     Letterbox}ed to this shape.
+     */
+    public RknnObjectDetector(RknnModel model, Size inputSize) {
+        this.model = model;
+        this.inputSize = inputSize;
+
+        // Create the detector
+        objPointer =
+                RknnJNI.create(model.modelFile.getPath(), model.labels.size(), model.version.ordinal(), -1);
+        if (objPointer <= 0) {
+            throw new RuntimeException(
+                    "Failed to create detector from path " + model.modelFile.getPath());
+        }
+
+        logger.debug("Created detector for model " + model.modelFile.getName());
+
+        // Register the cleaner to release the detector when it goes out of scope
+        cleaner.register(this, this::release);
+    }
+
+    /**
+     * Returns the classes that the detector can detect
+     *
+     * @return The classes
+     */
+    @Override
+    public List<String> getClasses() {
+        return model.labels;
+    }
+
+    /**
+     * Detects objects in the given input image using the RknnDetector.
+     *
+     * @param in The input image to perform object detection on.
+     * @param nmsThresh The threshold value for non-maximum suppression.
+     * @param boxThresh The threshold value for bounding box detection.
+     * @return A list of NeuralNetworkPipeResult objects representing the detected objects. Returns an
+     *     empty list if the detector is not initialized or if no objects are detected.
+     */
+    @Override
+    public List<NeuralNetworkPipeResult> detect(Mat in, double nmsThresh, double boxThresh) {
+        if (objPointer <= 0) {
+            // Report error and make sure to include the model name
+            logger.error("Detector is not initialized! Model: " + model.modelFile.getName());
+            return List.of();
+        }
+
+        // Resize the frame to the input size of the model
+        Mat letterboxed = new Mat();
+        Letterbox scale =
+                Letterbox.letterbox(in, letterboxed, this.inputSize, ColorHelper.colorToScalar(Color.GRAY));
+        if (!letterboxed.size().equals(this.inputSize)) {
+            throw new RuntimeException("Letterboxed frame is not the right size!");
+        }
+
+        // Detect objects in the letterboxed frame
+        var results = RknnJNI.detect(objPointer, letterboxed.getNativeObjAddr(), nmsThresh, boxThresh);
+        if (results == null) {
+            return List.of();
+        }
+        letterboxed.release();
+
+        return scale.resizeDetections(
+                List.of(results).stream()
+                        .map(it -> new NeuralNetworkPipeResult(it.rect, it.class_id, it.conf))
+                        .toList());
+    }
+
+    /** Thread-safe method to release the detector. */
+    @Override
+    public void release() {
+        // Checks if the atomic is 'false', and if so, sets it to 'true'
+        if (released.compareAndSet(false, true)) {
+            if (objPointer <= 0) {
+                logger.error(
+                        "Detector is not initialized, and so it can't be released! Model: "
+                                + model.modelFile.getName());
+                return;
+            }
+
+            RknnJNI.destroy(objPointer);
+            logger.debug("Released detector for model " + model.modelFile.getName());
+        }
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/objects/Letterbox.java b/photon-core/src/main/java/org/photonvision/vision/objects/Letterbox.java
new file mode 100644
index 0000000000..bbbae5269e
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/objects/Letterbox.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.objects;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.opencv.core.Core;
+import org.opencv.core.Mat;
+import org.opencv.core.Rect2d;
+import org.opencv.core.Scalar;
+import org.opencv.core.Size;
+import org.opencv.imgproc.Imgproc;
+import org.photonvision.vision.pipe.impl.NeuralNetworkPipeResult;
+
+public class Letterbox {
+    double dx;
+    double dy;
+    double scale;
+
+    public Letterbox(double dx, double dy, double scale) {
+        this.dx = dx;
+        this.dy = dy;
+        this.scale = scale;
+    }
+
+    /**
+     * Resize the frame to the new shape and "letterbox" it.
+     *
+     * <p>Letterboxing is the process of resizing an image to a new shape while maintaining the aspect
+     * ratio of the original image. The new image is padded with a color to fill the remaining space.
+     *
+     * @param frame
+     * @param letterboxed
+     * @param newShape
+     * @param color
+     * @return
+     */
+    public static Letterbox letterbox(Mat frame, Mat letterboxed, Size newShape, Scalar color) {
+        // from https://github.com/ultralytics/yolov5/issues/8427#issuecomment-1172469631
+        var frameSize = frame.size();
+        var r = Math.min(newShape.height / frameSize.height, newShape.width / frameSize.width);
+
+        var newUnpad = new Size(Math.round(frameSize.width * r), Math.round(frameSize.height * r));
+
+        if (!(frameSize.equals(newUnpad))) {
+            Imgproc.resize(frame, letterboxed, newUnpad, Imgproc.INTER_LINEAR);
+        } else {
+            frame.copyTo(letterboxed);
+        }
+
+        var dw = newShape.width - newUnpad.width;
+        var dh = newShape.height - newUnpad.height;
+
+        dw /= 2;
+        dh /= 2;
+
+        int top = (int) (Math.round(dh - 0.1f));
+        int bottom = (int) (Math.round(dh + 0.1f));
+        int left = (int) (Math.round(dw - 0.1f));
+        int right = (int) (Math.round(dw + 0.1f));
+        Core.copyMakeBorder(
+                letterboxed, letterboxed, top, bottom, left, right, Core.BORDER_CONSTANT, color);
+
+        return new Letterbox(dw, dh, r);
+    }
+
+    /**
+     * Resizes the detections to the original frame size.
+     *
+     * @param unscaled The detections to resize
+     * @return The resized detections
+     */
+    public List<NeuralNetworkPipeResult> resizeDetections(List<NeuralNetworkPipeResult> unscaled) {
+        var ret = new ArrayList<NeuralNetworkPipeResult>();
+
+        for (var t : unscaled) {
+            var scale = 1.0 / this.scale;
+            var boundingBox = t.bbox;
+            double x = (boundingBox.x - this.dx) * scale;
+            double y = (boundingBox.y - this.dy) * scale;
+            double width = boundingBox.width * scale;
+            double height = boundingBox.height * scale;
+
+            ret.add(
+                    new NeuralNetworkPipeResult(new Rect2d(x, y, width, height), t.classIdx, t.confidence));
+        }
+
+        return ret;
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/objects/Model.java b/photon-core/src/main/java/org/photonvision/vision/objects/Model.java
new file mode 100644
index 0000000000..a634898fd4
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/objects/Model.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.objects;
+
+public interface Model {
+    public ObjectDetector load();
+
+    public String getName();
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/objects/NullModel.java b/photon-core/src/main/java/org/photonvision/vision/objects/NullModel.java
new file mode 100644
index 0000000000..e3ecf42ef6
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/objects/NullModel.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.objects;
+
+import java.util.List;
+import org.opencv.core.Mat;
+import org.photonvision.vision.pipe.impl.NeuralNetworkPipeResult;
+
+/**
+ * A 'null' implementation of the {@link Model} and {@link ObjectDetector} interfaces. This is used
+ * when no model is available to load.
+ */
+public class NullModel implements Model, ObjectDetector {
+    // Singleton instance
+    public static final NullModel INSTANCE = new NullModel();
+
+    private NullModel() {}
+
+    public static NullModel getInstance() {
+        return INSTANCE;
+    }
+
+    @Override
+    public ObjectDetector load() {
+        return this;
+    }
+
+    @Override
+    public String getName() {
+        return "NullModel";
+    }
+
+    @Override
+    public void release() {
+        // Do nothing
+    }
+
+    @Override
+    public Model getModel() {
+        return this;
+    }
+
+    @Override
+    public List<String> getClasses() {
+        return List.of();
+    }
+
+    @Override
+    public List<NeuralNetworkPipeResult> detect(Mat in, double nmsThresh, double boxThresh) {
+        return List.of();
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/objects/ObjectDetector.java b/photon-core/src/main/java/org/photonvision/vision/objects/ObjectDetector.java
new file mode 100644
index 0000000000..1dacb00e77
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/objects/ObjectDetector.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.objects;
+
+import java.util.List;
+import org.opencv.core.Mat;
+import org.photonvision.common.configuration.NeuralNetworkModelManager;
+import org.photonvision.vision.opencv.Releasable;
+import org.photonvision.vision.pipe.impl.NeuralNetworkPipeResult;
+
+/**
+ * ObjectDetector lifecycle:
+ *
+ * <ol>
+ *   <li>{@link Model}s are discovered by {@link NeuralNetworkModelManager}
+ *   <li>{@link Model} is selected as a parameter of {@link
+ *       org.photonvision.vision.pipe.impl.ObjectDetectionPipe ObjectDetectionPipe}
+ *   <li>{@link Model#load()} is called to create a ObjectDetector instance
+ *   <li>{@link ObjectDetector#detect(Mat, double, double)} is called to perform object detection
+ *   <li>{@link ObjectDetector#release()} is called to release resources
+ * </ol>
+ */
+public interface ObjectDetector extends Releasable {
+    /** Returns the model that created this ObjectDetector. */
+    public Model getModel();
+
+    /**
+     * Returns the classes that the detector can detect
+     *
+     * @return The classes
+     */
+    public List<String> getClasses();
+
+    /**
+     * Detects objects in the given input image. Preprocessing and postprocessing steps should be
+     * embedded into this call.
+     *
+     * @param in The input image to perform object detection on.
+     * @param nmsThresh The threshold value for non-maximum suppression.
+     * @param boxThresh The threshold value for bounding box detection.
+     * @return A list of NeuralNetworkPipeResult objects representing the detected objects. Returns an
+     *     empty list if the detector is not initialized or if no objects are detected.
+     */
+    public List<NeuralNetworkPipeResult> detect(Mat in, double nmsThresh, double boxThresh);
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/objects/RknnModel.java b/photon-core/src/main/java/org/photonvision/vision/objects/RknnModel.java
new file mode 100644
index 0000000000..921b507948
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/objects/RknnModel.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.objects;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+import org.opencv.core.Size;
+import org.photonvision.jni.RknnObjectDetector;
+import org.photonvision.rknn.RknnJNI;
+
+public class RknnModel implements Model {
+    public final File modelFile;
+    public final RknnJNI.ModelVersion version;
+    public final List<String> labels;
+    public final Size inputSize;
+
+    /**
+     * Determines the model version based on the model's filename.
+     *
+     * <p>"yolov5" -> "YOLO_V5"
+     *
+     * <p>"yolov8" -> "YOLO_V8"
+     *
+     * @param modelName The model's filename
+     * @return The model version
+     */
+    private static RknnJNI.ModelVersion getModelVersion(String modelName)
+            throws IllegalArgumentException {
+        if (modelName.contains("yolov5")) {
+            return RknnJNI.ModelVersion.YOLO_V5;
+        } else if (modelName.contains("yolov8")) {
+            return RknnJNI.ModelVersion.YOLO_V8;
+        } else {
+            throw new IllegalArgumentException("Unknown model version for model " + modelName);
+        }
+    }
+
+    /**
+     * rknn model constructor.
+     *
+     * @param modelFile path to model on disk. Format: `name-width-height-model.rknn`
+     * @param labels path to labels file on disk
+     * @throws IllegalArgumentException
+     */
+    public RknnModel(File modelFile, String labels) throws IllegalArgumentException, IOException {
+        this.modelFile = modelFile;
+
+        String[] parts = modelFile.getName().split("-");
+        if (parts.length != 4) {
+            throw new IllegalArgumentException("Invalid model file name: " + modelFile);
+        }
+
+        this.version = getModelVersion(parts[3]);
+
+        int width = Integer.parseInt(parts[1]);
+        int height = Integer.parseInt(parts[2]);
+        this.inputSize = new Size(width, height);
+
+        try {
+            this.labels = Files.readAllLines(Paths.get(labels));
+        } catch (IOException e) {
+            throw new IllegalArgumentException("Failed to read labels file " + labels, e);
+        }
+    }
+
+    public String getName() {
+        return modelFile.getName();
+    }
+
+    public ObjectDetector load() {
+        return new RknnObjectDetector(this, inputSize);
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/ObjectDetectionPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/ObjectDetectionPipe.java
new file mode 100644
index 0000000000..fad36a5b8d
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/ObjectDetectionPipe.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.pipe.impl;
+
+import java.util.List;
+import java.util.Optional;
+import org.opencv.core.Mat;
+import org.photonvision.common.configuration.NeuralNetworkModelManager;
+import org.photonvision.vision.objects.Model;
+import org.photonvision.vision.objects.NullModel;
+import org.photonvision.vision.objects.ObjectDetector;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.opencv.Releasable;
+import org.photonvision.vision.pipe.CVPipe;
+
+public class ObjectDetectionPipe
+        extends CVPipe<
+                CVMat, List<NeuralNetworkPipeResult>, ObjectDetectionPipe.ObjectDetectionPipeParams>
+        implements Releasable {
+    private ObjectDetector detector;
+
+    public ObjectDetectionPipe() {
+        Optional<Model> defaultModel = NeuralNetworkModelManager.getInstance().getDefaultModel();
+        detector = defaultModel.map(Model::load).orElse(NullModel.getInstance());
+    }
+
+    @Override
+    protected List<NeuralNetworkPipeResult> process(CVMat in) {
+        // Check if the model has changed
+        if (detector.getModel() != params.model) {
+            detector.release();
+            detector = params.model.load();
+        }
+
+        Mat frame = in.getMat();
+        if (frame.empty()) {
+            return List.of();
+        }
+
+        return detector.detect(in.getMat(), params.nms, params.confidence);
+    }
+
+    public static class ObjectDetectionPipeParams {
+        public double confidence;
+        public double nms;
+        public int max_detections;
+        public Model model;
+
+        public ObjectDetectionPipeParams() {}
+    }
+
+    public List<String> getClassNames() {
+        return detector.getClasses();
+    }
+
+    @Override
+    public void release() {
+        detector.release();
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/RknnDetectionPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/RknnDetectionPipe.java
deleted file mode 100644
index 9ce2f348f4..0000000000
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/RknnDetectionPipe.java
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * Copyright (C) Photon Vision.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package org.photonvision.vision.pipe.impl;
-
-import java.awt.Color;
-import java.util.ArrayList;
-import java.util.List;
-import org.opencv.core.Core;
-import org.opencv.core.Mat;
-import org.opencv.core.Rect2d;
-import org.opencv.core.Scalar;
-import org.opencv.core.Size;
-import org.opencv.imgproc.Imgproc;
-import org.photonvision.common.configuration.NeuralNetworkModelManager;
-import org.photonvision.common.util.ColorHelper;
-import org.photonvision.jni.RknnDetectorJNI.RknnObjectDetector;
-import org.photonvision.vision.opencv.CVMat;
-import org.photonvision.vision.opencv.Releasable;
-import org.photonvision.vision.pipe.CVPipe;
-
-public class RknnDetectionPipe
-        extends CVPipe<CVMat, List<NeuralNetworkPipeResult>, RknnDetectionPipe.RknnDetectionPipeParams>
-        implements Releasable {
-    private RknnObjectDetector detector;
-
-    public RknnDetectionPipe() {
-        // For now this is hard-coded to defaults. Should be refactored into set pipe
-        // params, though.
-        // And ideally a little wrapper helper for only changing native stuff on content
-        // change created.
-        this.detector =
-                new RknnObjectDetector(
-                        NeuralNetworkModelManager.getInstance().getDefaultRknnModel().getAbsolutePath(),
-                        NeuralNetworkModelManager.getInstance().getLabels(),
-                        NeuralNetworkModelManager.getInstance().getModelVersion());
-    }
-
-    private static class Letterbox {
-        double dx;
-        double dy;
-        double scale;
-
-        public Letterbox(double dx, double dy, double scale) {
-            this.dx = dx;
-            this.dy = dy;
-            this.scale = scale;
-        }
-    }
-
-    @Override
-    protected List<NeuralNetworkPipeResult> process(CVMat in) {
-        var frame = in.getMat();
-
-        // Make sure we don't get a weird empty frame
-        if (frame.empty()) {
-            return List.of();
-        }
-
-        // letterbox
-        var letterboxed = new Mat();
-        var scale =
-                letterbox(frame, letterboxed, new Size(640, 640), ColorHelper.colorToScalar(Color.GRAY));
-
-        if (letterboxed.width() != 640 || letterboxed.height() != 640) {
-            // huh whack give up lol
-            throw new RuntimeException("RGA bugged but still wrong size");
-        }
-        var ret = detector.detect(letterboxed, params.nms, params.confidence);
-        letterboxed.release();
-
-        return resizeDetections(ret, scale);
-    }
-
-    private List<NeuralNetworkPipeResult> resizeDetections(
-            List<NeuralNetworkPipeResult> unscaled, Letterbox letterbox) {
-        var ret = new ArrayList<NeuralNetworkPipeResult>();
-
-        for (var t : unscaled) {
-            var scale = 1.0 / letterbox.scale;
-            var boundingBox = t.bbox;
-            double x = (boundingBox.x - letterbox.dx) * scale;
-            double y = (boundingBox.y - letterbox.dy) * scale;
-            double width = boundingBox.width * scale;
-            double height = boundingBox.height * scale;
-
-            ret.add(
-                    new NeuralNetworkPipeResult(new Rect2d(x, y, width, height), t.classIdx, t.confidence));
-        }
-
-        return ret;
-    }
-
-    private static Letterbox letterbox(Mat frame, Mat letterboxed, Size newShape, Scalar color) {
-        // from https://github.com/ultralytics/yolov5/issues/8427#issuecomment-1172469631
-        var frameSize = frame.size();
-        var r = Math.min(newShape.height / frameSize.height, newShape.width / frameSize.width);
-
-        var newUnpad = new Size(Math.round(frameSize.width * r), Math.round(frameSize.height * r));
-
-        if (!(frameSize.equals(newUnpad))) {
-            Imgproc.resize(frame, letterboxed, newUnpad, Imgproc.INTER_LINEAR);
-        } else {
-            frame.copyTo(letterboxed);
-        }
-
-        var dw = newShape.width - newUnpad.width;
-        var dh = newShape.height - newUnpad.height;
-
-        dw /= 2;
-        dh /= 2;
-
-        int top = (int) (Math.round(dh - 0.1f));
-        int bottom = (int) (Math.round(dh + 0.1f));
-        int left = (int) (Math.round(dw - 0.1f));
-        int right = (int) (Math.round(dw + 0.1f));
-        Core.copyMakeBorder(
-                letterboxed, letterboxed, top, bottom, left, right, Core.BORDER_CONSTANT, color);
-
-        return new Letterbox(dw, dh, r);
-    }
-
-    public static class RknnDetectionPipeParams {
-        public double confidence;
-        public double nms;
-        public int max_detections;
-
-        public RknnDetectionPipeParams() {}
-    }
-
-    public List<String> getClassNames() {
-        return detector.getClasses();
-    }
-
-    @Override
-    public void release() {
-        detector.release();
-    }
-}
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipeline.java
index 4919c91512..684fdd0247 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipeline.java
@@ -18,13 +18,17 @@
 package org.photonvision.vision.pipeline;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.Collectors;
+import org.photonvision.common.configuration.NeuralNetworkModelManager;
 import org.photonvision.vision.frame.Frame;
 import org.photonvision.vision.frame.FrameThresholdType;
+import org.photonvision.vision.objects.Model;
+import org.photonvision.vision.objects.NullModel;
 import org.photonvision.vision.opencv.DualOffsetValues;
 import org.photonvision.vision.pipe.CVPipe.CVPipeResult;
 import org.photonvision.vision.pipe.impl.*;
-import org.photonvision.vision.pipe.impl.RknnDetectionPipe.RknnDetectionPipeParams;
+import org.photonvision.vision.pipe.impl.ObjectDetectionPipe.ObjectDetectionPipeParams;
 import org.photonvision.vision.pipeline.result.CVPipelineResult;
 import org.photonvision.vision.target.PotentialTarget;
 import org.photonvision.vision.target.TargetOrientation;
@@ -33,7 +37,7 @@
 public class ObjectDetectionPipeline
         extends CVPipeline<CVPipelineResult, ObjectDetectionPipelineSettings> {
     private final CalculateFPSPipe calculateFPSPipe = new CalculateFPSPipe();
-    private final RknnDetectionPipe rknnPipe = new RknnDetectionPipe();
+    private final ObjectDetectionPipe objectDetectorPipe = new ObjectDetectionPipe();
     private final SortContoursPipe sortContoursPipe = new SortContoursPipe();
     private final Collect2dTargetsPipe collect2dTargetsPipe = new Collect2dTargetsPipe();
     private final FilterObjectDetectionsPipe filterContoursPipe = new FilterObjectDetectionsPipe();
@@ -52,11 +56,25 @@ public ObjectDetectionPipeline(ObjectDetectionPipelineSettings settings) {
 
     @Override
     protected void setPipeParamsImpl() {
-        // this needs to be based off of the current backend selected!!
-        var params = new RknnDetectionPipeParams();
+        var params = new ObjectDetectionPipeParams();
         params.confidence = settings.confidence;
         params.nms = settings.nms;
-        rknnPipe.setParams(params);
+        Optional<Model> selectedModel =
+                NeuralNetworkModelManager.getInstance().getModel(settings.model);
+
+        // If the desired model couldn't be found, log an error and try to use the default model
+        if (selectedModel.isEmpty()) {
+            selectedModel = NeuralNetworkModelManager.getInstance().getDefaultModel();
+        }
+
+        // If the model remains empty, use the NullModel
+        if (selectedModel.isEmpty()) {
+            selectedModel = Optional.of(NullModel.getInstance());
+        }
+
+        params.model = selectedModel.get();
+
+        objectDetectorPipe.setParams(params);
 
         DualOffsetValues dualOffsetValues =
                 new DualOffsetValues(
@@ -97,11 +115,11 @@ protected CVPipelineResult process(Frame frame, ObjectDetectionPipelineSettings
 
         // ***************** change based on backend ***********************
 
-        CVPipeResult<List<NeuralNetworkPipeResult>> rknnResult = rknnPipe.run(frame.colorImage);
+        CVPipeResult<List<NeuralNetworkPipeResult>> rknnResult =
+                objectDetectorPipe.run(frame.colorImage);
         sumPipeNanosElapsed += rknnResult.nanosElapsed;
-        List<NeuralNetworkPipeResult> targetList;
 
-        var names = rknnPipe.getClassNames();
+        var names = objectDetectorPipe.getClassNames();
 
         frame.colorImage.getMat().copyTo(frame.processedImage.getMat());
 
@@ -130,7 +148,7 @@ protected CVPipelineResult process(Frame frame, ObjectDetectionPipelineSettings
 
     @Override
     public void release() {
-        rknnPipe.release();
+        objectDetectorPipe.release();
         super.release();
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipelineSettings.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipelineSettings.java
index 118e73b329..ba1fcaf646 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipelineSettings.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipelineSettings.java
@@ -17,9 +17,13 @@
 
 package org.photonvision.vision.pipeline;
 
+import org.photonvision.common.configuration.NeuralNetworkModelManager;
+import org.photonvision.vision.objects.Model;
+
 public class ObjectDetectionPipelineSettings extends AdvancedPipelineSettings {
     public double confidence;
     public double nms; // non maximal suppression
+    public String model;
 
     public ObjectDetectionPipelineSettings() {
         super();
@@ -30,5 +34,7 @@ public ObjectDetectionPipelineSettings() {
         ledMode = false;
         confidence = .9;
         nms = .45;
+        model =
+                NeuralNetworkModelManager.getInstance().getDefaultModel().map(Model::getName).orElse("");
     }
 }
diff --git a/photon-server/src/main/java/org/photonvision/Main.java b/photon-server/src/main/java/org/photonvision/Main.java
index 9dd5e7ad70..4330cefc00 100644
--- a/photon-server/src/main/java/org/photonvision/Main.java
+++ b/photon-server/src/main/java/org/photonvision/Main.java
@@ -423,6 +423,11 @@ public static void main(String[] args) {
         ConfigManager.getInstance().load(); // init config manager
         ConfigManager.getInstance().requestSave();
 
+        logger.info("Loading ML models...");
+        var modelManager = NeuralNetworkModelManager.getInstance();
+        modelManager.extractModels(ConfigManager.getInstance().getModelsDirectory());
+        modelManager.discoverModels(ConfigManager.getInstance().getModelsDirectory());
+
         logger.debug("Loading HardwareManager...");
         // Force load the hardware manager
         HardwareManager.getInstance();
@@ -434,10 +439,6 @@ public static void main(String[] args) {
         NetworkTablesManager.getInstance()
                 .setConfig(ConfigManager.getInstance().getConfig().getNetworkConfig());
 
-        logger.info("Loading ML models");
-        NeuralNetworkModelManager.getInstance()
-                .initialize(ConfigManager.getInstance().getModelsDirectory());
-
         if (isSmoketest) {
             logger.info("PhotonVision base functionality loaded -- smoketest complete");
             System.exit(0);
diff --git a/photon-server/src/main/resources/models/labels_v5.txt b/photon-server/src/main/resources/models/note-640-640-yolov5s-labels.txt
similarity index 100%
rename from photon-server/src/main/resources/models/labels_v5.txt
rename to photon-server/src/main/resources/models/note-640-640-yolov5s-labels.txt

From 360298cc24c1a3615ede9292dfa35bf9824a9c47 Mon Sep 17 00:00:00 2001
From: Stephen Just <stephenjust@gmail.com>
Date: Sat, 21 Sep 2024 13:11:58 -0700
Subject: [PATCH 2/7] Fix error being printed to console on Chrome when
 navigating UI (#1429)

Chrome prints an error to the console when you have `<img src="null" />`

The path `//:0` can be used for an empty image and Chrome will not raise
an error.
---
 photon-client/src/components/app/photon-camera-stream.vue | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/photon-client/src/components/app/photon-camera-stream.vue b/photon-client/src/components/app/photon-camera-stream.vue
index 710fd81b2a..2fa78fb9f9 100644
--- a/photon-client/src/components/app/photon-camera-stream.vue
+++ b/photon-client/src/components/app/photon-camera-stream.vue
@@ -57,7 +57,7 @@ const handleFullscreenRequest = () => {
 const mjpgStream: any = ref(null);
 onBeforeUnmount(() => {
   if (!mjpgStream.value) return;
-  mjpgStream.value["src"] = null;
+  mjpgStream.value["src"] = "//:0";
 });
 </script>
 

From f33218c49cf23ce25ee94aa9d7da72447f2c6651 Mon Sep 17 00:00:00 2001
From: Matt <matthew.morley.ca@gmail.com>
Date: Sun, 22 Sep 2024 22:27:13 -0400
Subject: [PATCH 3/7] Add message UUID and type names to hash and message
 defintion (#1409)

---
 .github/workflows/lint-format.yml             |   2 +-
 README.md                                     |   2 +-
 .../networktables/NTDataPublisher.java        |  14 +--
 .../generated/MultiTargetPNPResultSerde.py    |   4 +-
 .../generated/PhotonPipelineMetadataSerde.py  |   2 +-
 .../generated/PhotonPipelineResultSerde.py    |   8 +-
 .../generated/PhotonTrackedTargetSerde.py     |   6 +-
 .../photonlibpy/generated/PnpResultSerde.py   |   4 +-
 .../generated/TargetCornerSerde.py            |   2 +-
 photon-lib/py/photonlibpy/packet.py           |  16 +--
 photon-lib/py/photonlibpy/photonCamera.py     |  12 +-
 .../java/org/photonvision/PhotonCamera.java   |   2 +-
 .../simulation/PhotonCameraSim.java           |   8 +-
 photon-serde/README.md                        |  58 ++++++++++
 photon-serde/generate_messages.py             | 107 +++++++++++++++---
 photon-serde/messages.yaml                    |   1 +
 photon-serde/templates/Message.java.jinja     |  39 +++++--
 photon-serde/templates/ThingSerde.py.jinja    |   1 -
 .../struct/MultiTargetPNPResultSerde.java     |  28 ++++-
 .../struct/PhotonPipelineMetadataSerde.java   |  27 ++++-
 .../struct/PhotonPipelineResultSerde.java     |  28 ++++-
 .../struct/PhotonTrackedTargetSerde.java      |  33 ++++--
 .../photonvision/struct/PnpResultSerde.java   |  32 ++++--
 .../struct/TargetCornerSerde.java             |  27 ++++-
 .../photon/serde/MultiTargetPNPResultSerde.h  |   5 +-
 .../serde/PhotonPipelineMetadataSerde.h       |   2 +-
 .../photon/serde/PhotonPipelineResultSerde.h  |   9 +-
 .../photon/serde/PhotonTrackedTargetSerde.h   |   7 +-
 .../include/photon/serde/PnpResultSerde.h     |   2 +-
 .../include/photon/serde/TargetCornerSerde.h  |   2 +-
 .../common/dataflow/structures/Packet.java    |  93 +++++++--------
 .../dataflow/structures/PacketSerde.java      |  29 ++++-
 .../common/networktables/NTTopicSet.java      |  11 +-
 .../common/networktables/PacketPublisher.java |  43 ++++++-
 .../targeting/PhotonTrackedTarget.java        |  24 +++-
 .../proto/PhotonTrackedTargetProto.java       |   4 +-
 .../proto/MultiTargetPNPResultProto.cpp       |   2 +
 .../src/test/native/cpp/PacketTest.cpp        |   1 +
 .../aimandrange/robot.py                      |   2 -
 .../aimandrange/tests/pyfrc_test.py           |   2 -
 .../aimattarget/tests/pyfrc_test.py           |   2 -
 .../poseest/tests/pyfrc_test.py               |   2 -
 scripts/catnt.py                              |  90 +++++++++++++++
 43 files changed, 605 insertions(+), 190 deletions(-)
 create mode 100644 scripts/catnt.py

diff --git a/.github/workflows/lint-format.yml b/.github/workflows/lint-format.yml
index fb97eb77af..09f86fc6c6 100644
--- a/.github/workflows/lint-format.yml
+++ b/.github/workflows/lint-format.yml
@@ -37,7 +37,7 @@ jobs:
         with:
           python-version: 3.11
       - name: Install wpiformat
-        run: pip3 install wpiformat==2024.37
+        run: pip3 install wpiformat==2024.41
       - name: Run
         run: wpiformat
       - name: Check output
diff --git a/README.md b/README.md
index 4fcf69c59e..c559bb963c 100644
--- a/README.md
+++ b/README.md
@@ -37,7 +37,7 @@ Note that these are case sensitive!
     * arm64
     * x86-64
     * x86
-- `-PtgtIp`: Specifies where `./gradlew deploy` should try to copy the fat JAR to
+- `-PtgtIP`: Specifies where `./gradlew deploy` should try to copy the fat JAR to
 - `-Pprofile`: enables JVM profiling
 
 ## Out-of-Source Dependencies
diff --git a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java
index 11aa38852b..be51316126 100644
--- a/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java
+++ b/photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java
@@ -17,6 +17,7 @@
 
 package org.photonvision.common.dataflow.networktables;
 
+import edu.wpi.first.math.geometry.Transform3d;
 import edu.wpi.first.networktables.NetworkTable;
 import edu.wpi.first.networktables.NetworkTableEvent;
 import edu.wpi.first.util.WPIUtilJNI;
@@ -159,16 +160,7 @@ public void accept(CVPipelineResult result) {
             ts.targetSkewEntry.set(bestTarget.getSkew());
 
             var pose = bestTarget.getBestCameraToTarget3d();
-            ts.targetPoseEntry.set(
-                    new double[] {
-                        pose.getTranslation().getX(),
-                        pose.getTranslation().getY(),
-                        pose.getTranslation().getZ(),
-                        pose.getRotation().getQuaternion().getW(),
-                        pose.getRotation().getQuaternion().getX(),
-                        pose.getRotation().getQuaternion().getY(),
-                        pose.getRotation().getQuaternion().getZ()
-                    });
+            ts.targetPoseEntry.set(pose);
 
             var targetOffsetPoint = bestTarget.getTargetOffsetPoint();
             ts.bestTargetPosX.set(targetOffsetPoint.x);
@@ -178,7 +170,7 @@ public void accept(CVPipelineResult result) {
             ts.targetYawEntry.set(0);
             ts.targetAreaEntry.set(0);
             ts.targetSkewEntry.set(0);
-            ts.targetPoseEntry.set(new double[] {0, 0, 0});
+            ts.targetPoseEntry.set(new Transform3d());
             ts.bestTargetPosX.set(0);
             ts.bestTargetPosY.set(0);
         }
diff --git a/photon-lib/py/photonlibpy/generated/MultiTargetPNPResultSerde.py b/photon-lib/py/photonlibpy/generated/MultiTargetPNPResultSerde.py
index a40d07fe44..a1bf4c4090 100644
--- a/photon-lib/py/photonlibpy/generated/MultiTargetPNPResultSerde.py
+++ b/photon-lib/py/photonlibpy/generated/MultiTargetPNPResultSerde.py
@@ -25,8 +25,8 @@
 
 class MultiTargetPNPResultSerde:
     # Message definition md5sum. See photon_packet.adoc for details
-    MESSAGE_VERSION = "ffc1cb847deb6e796a583a5b1885496b"
-    MESSAGE_FORMAT = "PnpResult estimatedPose;int16[?] fiducialIDsUsed;"
+    MESSAGE_VERSION = "541096947e9f3ca2d3f425ff7b04aa7b"
+    MESSAGE_FORMAT = "PnpResult:ae4d655c0a3104d88df4f5db144c1e86 estimatedPose;int16 fiducialIDsUsed[?];"
 
     @staticmethod
     def unpack(packet: "Packet") -> "MultiTargetPNPResult":
diff --git a/photon-lib/py/photonlibpy/generated/PhotonPipelineMetadataSerde.py b/photon-lib/py/photonlibpy/generated/PhotonPipelineMetadataSerde.py
index b5ce2d8a9c..f0e8731f33 100644
--- a/photon-lib/py/photonlibpy/generated/PhotonPipelineMetadataSerde.py
+++ b/photon-lib/py/photonlibpy/generated/PhotonPipelineMetadataSerde.py
@@ -25,7 +25,7 @@
 
 class PhotonPipelineMetadataSerde:
     # Message definition md5sum. See photon_packet.adoc for details
-    MESSAGE_VERSION = "2a7039527bda14d13028a1b9282d40a2"
+    MESSAGE_VERSION = "626e70461cbdb274fb43ead09c255f4e"
     MESSAGE_FORMAT = (
         "int64 sequenceID;int64 captureTimestampMicros;int64 publishTimestampMicros;"
     )
diff --git a/photon-lib/py/photonlibpy/generated/PhotonPipelineResultSerde.py b/photon-lib/py/photonlibpy/generated/PhotonPipelineResultSerde.py
index f638b3bb17..fa32c9bdd2 100644
--- a/photon-lib/py/photonlibpy/generated/PhotonPipelineResultSerde.py
+++ b/photon-lib/py/photonlibpy/generated/PhotonPipelineResultSerde.py
@@ -25,8 +25,8 @@
 
 class PhotonPipelineResultSerde:
     # Message definition md5sum. See photon_packet.adoc for details
-    MESSAGE_VERSION = "cb3e1605048ba49325888eb797399fe2"
-    MESSAGE_FORMAT = "PhotonPipelineMetadata metadata;PhotonTrackedTarget[?] targets;MultiTargetPNPResult? multiTagResult;"
+    MESSAGE_VERSION = "5eeaa293d0c69aea90eaddea786a2b3b"
+    MESSAGE_FORMAT = "PhotonPipelineMetadata:626e70461cbdb274fb43ead09c255f4e metadata;PhotonTrackedTarget:cc6dbb5c5c1e0fa808108019b20863f1 targets[?];optional MultiTargetPNPResult:541096947e9f3ca2d3f425ff7b04aa7b multitagResult;"
 
     @staticmethod
     def unpack(packet: "Packet") -> "PhotonPipelineResult":
@@ -38,8 +38,8 @@ def unpack(packet: "Packet") -> "PhotonPipelineResult":
         # targets is a custom VLA!
         ret.targets = packet.decodeList(PhotonTrackedTarget.photonStruct)
 
-        # multiTagResult is optional! it better not be a VLA too
-        ret.multiTagResult = packet.decodeOptional(MultiTargetPNPResult.photonStruct)
+        # multitagResult is optional! it better not be a VLA too
+        ret.multitagResult = packet.decodeOptional(MultiTargetPNPResult.photonStruct)
 
         return ret
 
diff --git a/photon-lib/py/photonlibpy/generated/PhotonTrackedTargetSerde.py b/photon-lib/py/photonlibpy/generated/PhotonTrackedTargetSerde.py
index c728295c6b..4765fa5e37 100644
--- a/photon-lib/py/photonlibpy/generated/PhotonTrackedTargetSerde.py
+++ b/photon-lib/py/photonlibpy/generated/PhotonTrackedTargetSerde.py
@@ -25,8 +25,8 @@
 
 class PhotonTrackedTargetSerde:
     # Message definition md5sum. See photon_packet.adoc for details
-    MESSAGE_VERSION = "8fdada56b9162f2e32bd24f0055d7b60"
-    MESSAGE_FORMAT = "float64 yaw;float64 pitch;float64 area;float64 skew;int32 fiducialId;int32 objDetectId;float32 objDetectConf;Transform3d bestCameraToTarget;Transform3d altCameraToTarget;float64 poseAmbiguity;TargetCorner[?] minAreaRectCorners;TargetCorner[?] detectedCorners;"
+    MESSAGE_VERSION = "cc6dbb5c5c1e0fa808108019b20863f1"
+    MESSAGE_FORMAT = "float64 yaw;float64 pitch;float64 area;float64 skew;int32 fiducialId;int32 objDetectId;float32 objDetectConf;Transform3d bestCameraToTarget;Transform3d altCameraToTarget;float64 poseAmbiguity;TargetCorner:16f6ac0dedc8eaccb951f4895d9e18b6 minAreaRectCorners[?];TargetCorner:16f6ac0dedc8eaccb951f4895d9e18b6 detectedCorners[?];"
 
     @staticmethod
     def unpack(packet: "Packet") -> "PhotonTrackedTarget":
@@ -53,10 +53,8 @@ def unpack(packet: "Packet") -> "PhotonTrackedTarget":
         # objDetectConf is of intrinsic type float32
         ret.objDetectConf = packet.decodeFloat()
 
-        # field is shimmed!
         ret.bestCameraToTarget = packet.decodeTransform()
 
-        # field is shimmed!
         ret.altCameraToTarget = packet.decodeTransform()
 
         # poseAmbiguity is of intrinsic type float64
diff --git a/photon-lib/py/photonlibpy/generated/PnpResultSerde.py b/photon-lib/py/photonlibpy/generated/PnpResultSerde.py
index aaeb74c86c..e4c1f261ea 100644
--- a/photon-lib/py/photonlibpy/generated/PnpResultSerde.py
+++ b/photon-lib/py/photonlibpy/generated/PnpResultSerde.py
@@ -25,17 +25,15 @@
 
 class PnpResultSerde:
     # Message definition md5sum. See photon_packet.adoc for details
-    MESSAGE_VERSION = "0d1f2546b00f24718e30f38d206d4491"
+    MESSAGE_VERSION = "ae4d655c0a3104d88df4f5db144c1e86"
     MESSAGE_FORMAT = "Transform3d best;Transform3d alt;float64 bestReprojErr;float64 altReprojErr;float64 ambiguity;"
 
     @staticmethod
     def unpack(packet: "Packet") -> "PnpResult":
         ret = PnpResult()
 
-        # field is shimmed!
         ret.best = packet.decodeTransform()
 
-        # field is shimmed!
         ret.alt = packet.decodeTransform()
 
         # bestReprojErr is of intrinsic type float64
diff --git a/photon-lib/py/photonlibpy/generated/TargetCornerSerde.py b/photon-lib/py/photonlibpy/generated/TargetCornerSerde.py
index beccc9e2db..f55207f9be 100644
--- a/photon-lib/py/photonlibpy/generated/TargetCornerSerde.py
+++ b/photon-lib/py/photonlibpy/generated/TargetCornerSerde.py
@@ -25,7 +25,7 @@
 
 class TargetCornerSerde:
     # Message definition md5sum. See photon_packet.adoc for details
-    MESSAGE_VERSION = "22b1ff7551d10215af6fb3672fe4eda8"
+    MESSAGE_VERSION = "16f6ac0dedc8eaccb951f4895d9e18b6"
     MESSAGE_FORMAT = "float64 x;float64 y;"
 
     @staticmethod
diff --git a/photon-lib/py/photonlibpy/packet.py b/photon-lib/py/photonlibpy/packet.py
index 53c3f84c5b..a4e375d431 100644
--- a/photon-lib/py/photonlibpy/packet.py
+++ b/photon-lib/py/photonlibpy/packet.py
@@ -85,7 +85,9 @@ def _decodeGeneric(self, unpackFormat, numBytes):
         for _ in range(numBytes):
             intList.append(self._getNextByteAsInt())
 
-        # Interpret the bytes as a floating point number
+        # Interpret the bytes as the requested type.
+        # Note due to NT's byte order assumptions,
+        # we have to flip the order of intList
         value = struct.unpack(unpackFormat, bytes(intList))[0]
 
         return value
@@ -96,7 +98,7 @@ def decode8(self) -> int:
         *
         * @return A decoded byte from the packet.
         """
-        return self._decodeGeneric(">b", 1)
+        return self._decodeGeneric("<b", 1)
 
     def decode16(self) -> int:
         """
@@ -104,7 +106,7 @@ def decode16(self) -> int:
         *
         * @return A decoded short from the packet.
         """
-        return self._decodeGeneric(">h", 2)
+        return self._decodeGeneric("<h", 2)
 
     def decodeInt(self) -> int:
         """
@@ -112,7 +114,7 @@ def decodeInt(self) -> int:
         *
         * @return A decoded int from the packet.
         """
-        return self._decodeGeneric(">l", 4)
+        return self._decodeGeneric("<l", 4)
 
     def decodeFloat(self) -> float:
         """
@@ -120,7 +122,7 @@ def decodeFloat(self) -> float:
         *
         * @return A decoded float from the packet.
         """
-        return self._decodeGeneric(">f", 4)
+        return self._decodeGeneric("<f", 4)
 
     def decodeLong(self) -> int:
         """
@@ -128,7 +130,7 @@ def decodeLong(self) -> int:
         *
         * @return A decoded int64 from the packet.
         """
-        return self._decodeGeneric(">q", 8)
+        return self._decodeGeneric("<q", 8)
 
     def decodeDouble(self) -> float:
         """
@@ -136,7 +138,7 @@ def decodeDouble(self) -> float:
         *
         * @return A decoded double from the packet.
         """
-        return self._decodeGeneric(">d", 8)
+        return self._decodeGeneric("<d", 8)
 
     def decodeBoolean(self) -> bool:
         """
diff --git a/photon-lib/py/photonlibpy/photonCamera.py b/photon-lib/py/photonlibpy/photonCamera.py
index 32f337b20d..b5bb659e88 100644
--- a/photon-lib/py/photonlibpy/photonCamera.py
+++ b/photon-lib/py/photonlibpy/photonCamera.py
@@ -225,7 +225,15 @@ def _versionCheck(self) -> None:
             )
 
         versionString = self.versionEntry.get(defaultValue="")
-        if len(versionString) > 0 and versionString != PHOTONVISION_VERSION:
+        localUUID = PhotonPipelineResult.photonStruct.MESSAGE_VERSION
+        remoteUUID = self._rawBytesEntry.getTopic().getProperty("message_uuid")
+
+        if remoteUUID is None or len(remoteUUID) == 0:
+            wpilib.reportWarning(
+                f"PhotonVision coprocessor at path {self._path} has not reported a message interface UUID - is your coprocessor's camera started?",
+                True,
+            )
+        elif localUUID != remoteUUID:
             # Verified version mismatch
 
             bfw = """
@@ -250,6 +258,6 @@ def _versionCheck(self) -> None:
 
             wpilib.reportWarning(bfw)
 
-            errText = f"Photon version {PHOTONLIB_VERSION} does not match coprocessor version {versionString}. Please install photonlibpy version {versionString}, or update your coprocessor to {PHOTONLIB_VERSION}."
+            errText = f"Photonlibpy version {PHOTONLIB_VERSION} (With message UUID {localUUID}) does not match coprocessor version {versionString} (with message UUID {remoteUUID}). Please install photonlibpy version {versionString}, or update your coprocessor to {PHOTONLIB_VERSION}."
             wpilib.reportError(errText, True)
             raise Exception(errText)
diff --git a/photon-lib/src/main/java/org/photonvision/PhotonCamera.java b/photon-lib/src/main/java/org/photonvision/PhotonCamera.java
index 1130d20a0a..633cf5fcbb 100644
--- a/photon-lib/src/main/java/org/photonvision/PhotonCamera.java
+++ b/photon-lib/src/main/java/org/photonvision/PhotonCamera.java
@@ -422,7 +422,7 @@ else if (!isConnected()) {
             DriverStation.reportWarning(
                     "PhotonVision coprocessor at path "
                             + path
-                            + " has note reported a message interface UUID - is your coprocessor's camera started?",
+                            + " has not reported a message interface UUID - is your coprocessor's camera started?",
                     true);
         } else if (!local_uuid.equals(remote_uuid)) {
             // Error on a verified version mismatch
diff --git a/photon-lib/src/main/java/org/photonvision/simulation/PhotonCameraSim.java b/photon-lib/src/main/java/org/photonvision/simulation/PhotonCameraSim.java
index f5ab57e5c1..7579218595 100644
--- a/photon-lib/src/main/java/org/photonvision/simulation/PhotonCameraSim.java
+++ b/photon-lib/src/main/java/org/photonvision/simulation/PhotonCameraSim.java
@@ -32,6 +32,7 @@
 import edu.wpi.first.math.MathUtil;
 import edu.wpi.first.math.Pair;
 import edu.wpi.first.math.geometry.Pose3d;
+import edu.wpi.first.math.geometry.Transform3d;
 import edu.wpi.first.util.PixelFormat;
 import edu.wpi.first.util.WPIUtilJNI;
 import edu.wpi.first.wpilibj.RobotController;
@@ -588,7 +589,7 @@ public void submitProcessedFrame(PhotonPipelineResult result, long receiveTimest
             ts.targetPitchEntry.set(0.0, receiveTimestamp);
             ts.targetYawEntry.set(0.0, receiveTimestamp);
             ts.targetAreaEntry.set(0.0, receiveTimestamp);
-            ts.targetPoseEntry.set(new double[] {0.0, 0.0, 0.0}, receiveTimestamp);
+            ts.targetPoseEntry.set(new Transform3d(), receiveTimestamp);
             ts.targetSkewEntry.set(0.0, receiveTimestamp);
         } else {
             var bestTarget = result.getBestTarget();
@@ -599,10 +600,7 @@ public void submitProcessedFrame(PhotonPipelineResult result, long receiveTimest
             ts.targetSkewEntry.set(bestTarget.getSkew(), receiveTimestamp);
 
             var transform = bestTarget.getBestCameraToTarget();
-            double[] poseData = {
-                transform.getX(), transform.getY(), transform.getRotation().toRotation2d().getDegrees()
-            };
-            ts.targetPoseEntry.set(poseData, receiveTimestamp);
+            ts.targetPoseEntry.set(transform, receiveTimestamp);
         }
 
         ts.cameraIntrinsicsPublisher.set(prop.getIntrinsics().getData(), receiveTimestamp);
diff --git a/photon-serde/README.md b/photon-serde/README.md
index 71ec72a52a..3e57626e91 100644
--- a/photon-serde/README.md
+++ b/photon-serde/README.md
@@ -22,3 +22,61 @@ The code for a single type is split across 3 files. Let's look at PnpResult:
 - Protobuf: slow on embedded platforms (at least quickbuf is)
 - Wpi's struct: no VLAs/optionals
 - Rosmsg: I'm not using ros, but I'm stealing their message hash idea
+
+## Deviations from WPI's Struct Schema Typestrings
+
+- Enum types are disallowed
+- Bitfields and bit packing are disallowed
+- Only variable length arrays are supported (no fixed-length arrays)
+- Arrays must be no more than 127 elements long
+- Members can be either VLAs or optional, but not both
+- A top-level NT topic type shall be a single type (eg TargetCorner), and cannot an array of types (eg TargetCorner[] or TargetCorner[?])
+- `float` and `double` types will be replaced with float32/float64 when generating message schema strings. This means that `float32 x;` and `float x;` will result in the same message hash.
+
+For example, this is a valid PhotonStruct schema. Note the WPILib `Transform3d`, the Photon-defined `TargetCorner`, optional prefix, and VLA suffix.
+
+```
+float64 poseAmbiguity;
+optional Transform3d altCameraToTarget;
+TargetCorner:16f6ac0dedc8eaccb951f4895d9e18b6 minAreaRectCorners[?];
+```
+
+## Dynamic Decoding
+
+Dynamic decoding is facilitated by publishing schemas to the `.schema` table in NT, and by encoding the `message_uuid` as a property on a `photonstruct` publisher. Schema names in the .schema table shall be formatted as `photonstruct:{Type Name}:{Message UUID}`. For example, here I've published Photon results to `/photonvision/WPI2024/rawBytes`. This topic has the typestring `photonstruct:PhotonPipelineResult:ed36092eb95e9fc254ebac897e2a74df`, with properties `{message_uuid': 'ed36092eb95e9fc254ebac897e2a74df'}`. It shall be legal to have published multiple versions of the same message, as long as their UUIDs are unique (which they'd better be).
+
+| Topic Name | Type | Type String |
+|------|------|-------|
+| /.schema/photonstruct:PhotonPipelineResult:ed36092eb95e9fc254ebac897e2a74df   | kRaw |  photonstructschema |
+| /.schema/photonstruct:PhotonTrackedTarget:4387ab389a8a78b7beb4492f145831b4    | kRaw |  photonstructschema |
+| /.schema/photonstruct:TargetCorner:16f6ac0dedc8eaccb951f4895d9e18b6           | kRaw |  photonstructschema |
+| /.schema/photonstruct:MultiTargetPNPResult:af2056aaab740eeb889a926071cae6ee   | kRaw |  photonstructschema |
+| /.schema/photonstruct:PnpResult:ae4d655c0a3104d88df4f5db144c1e86              | kRaw |  photonstructschema |
+| /.schema/photonstruct:PhotonPipelineMetadata:626e70461cbdb274fb43ead09c255f4e | kRaw |  photonstructschema |
+| /.schema/proto:geometry3d.proto                                               | kRaw  |  proto:FileDescriptorProto |
+| /.schema/proto:photon.proto    | kRaw | proto:FileDescriptorProto |
+
+The struct definition for PhotonPipelineResult we retrieved from the struct schema database shown above (via the command `python.exe scripts/catnt.py --echo /.schema/photonstruct:PhotonPipelineResult:ed36092eb95e9fc254ebac897e2a74df`) is:
+
+```
+PhotonPipelineMetadata:626e70461cbdb274fb43ead09c255f4e metadata;
+PhotonTrackedTarget:4387ab389a8a78b7beb4492f145831b4[?] targets;
+MultiTargetPNPResult:af2056aaab740eeb889a926071cae6ee? multitagResult;
+```
+
+If we were decoding this, we'd go retrieve the struct definitions for all our nested types. For example, `PhotonTrackedTarget:4387ab389a8a78b7beb4492f145831b4` is defined by it's .schema table entry be the following. This type also demonstrates a mix of WPILib struct types (such as Transform3d), intrinsic types (such as float64), and Photon struct types (such as TargetCorner).
+
+```
+float64 yaw;
+float64 pitch;
+float64 area;
+float64 skew;
+int32 fiducialId;
+int32 objDetectId;
+float32 objDetectConf;
+Transform3d bestCameraToTarget;
+Transform3d altCameraToTarget;
+float64 poseAmbiguity;
+TargetCorner:16f6ac0dedc8eaccb951f4895d9e18b6[?] minAreaRectCorners;
+TargetCorner:16f6ac0dedc8eaccb951f4895d9e18b6[?] detectedCorners;
+```
diff --git a/photon-serde/generate_messages.py b/photon-serde/generate_messages.py
index fe2b16277d..2b4922dc0a 100644
--- a/photon-serde/generate_messages.py
+++ b/photon-serde/generate_messages.py
@@ -47,6 +47,11 @@ class MessageType(TypedDict):
     cpp_include: str
     # python shim types
     python_decode_shim: str
+    # Java import name
+    java_import: str
+    # Remember our message hash. Recalculated by us. All intrinsic types are unhashed so this is fine to live here
+    message_hash: str
+    schema_str: str
 
 
 def yaml_to_dict(path: str):
@@ -118,7 +123,7 @@ def get_field_by_name(message: MessageType, field_name: str):
     return next(f for f in message["fields"] if f["name"] == field_name)
 
 
-def get_message_hash(message_db: List[MessageType], message: MessageType):
+def get_message_hash(message_db: List[MessageType], message: MessageType) -> str:
     """
     Calculate a unique message hash via MD5 sum. This is a very similar approach to rosmsg, documented:
     http://wiki.ros.org/ROS/Technical%20Overview#Message_serialization_and_msg_MD5_sums
@@ -136,15 +141,15 @@ def get_message_hash(message_db: List[MessageType], message: MessageType):
 
     for field in fields_to_hash:
         sub_message = get_message_by_name(message_db, field["type"])
-        subhash = get_message_hash(message_db, sub_message)
+        get_message_hash(message_db, sub_message)
 
-        # change the type to be our new md5sum
-        field["type"] = subhash.hexdigest()
+    schema = get_struct_schema_str(message, message_db)
+    message_hash = hashlib.md5(schema.encode("ascii")).hexdigest()
+
+    # and remember the hash
+    message["message_hash"] = message_hash
+    message["schema_str"] = schema
 
-    # base case: message is all intrinsic types
-    # Hash a comments-stripped version for message integrity checking
-    cleaned_yaml = yaml.dump(modified_message, default_flow_style=False).strip()
-    message_hash = hashlib.md5(cleaned_yaml.encode("ascii"))
     return message_hash
 
 
@@ -171,23 +176,65 @@ def get_includes(db, message: MessageType) -> str:
     return sorted(set(includes))
 
 
-def parse_yaml():
-    Path(__file__).resolve().parent
+def parse_yaml() -> List[MessageType]:
     config = yaml_to_dict("messages.yaml")
 
     return config
 
 
-def get_struct_schema_str(message: MessageType):
+INTRINSIC_TYPE_ALIASES = {
+    "float": "float32",
+    "double": "float64",
+}
+
+
+def get_fully_defined_field_name(field: SerdeField, message_db: List[MessageType]):
+    """
+    Get the fully-defined, globally unique type name for a field. Returns something like
+    Transform3d:b290703ff9e54f9ec2c733b90d7fc30b for user-defined types, or just
+    something like int64 for built-in types. Also normalizes float/double to float32/float64
+
+    Args:
+        field: The field we want the name of
+        message_db: All other loaded messages
+    """
+
+    typestr = field["type"]
+    if not is_intrinsic_type(field["type"]):
+        msg = get_message_by_name(message_db, field["type"])
+        is_shimmed = get_shimmed_filter(message_db)(field["type"])
+        if not is_shimmed:
+            typestr = field["type"] + ":" + msg["message_hash"]
+    else:
+        # handle replacing float/doubles
+        typestr = field["type"]
+        typestr = INTRINSIC_TYPE_ALIASES.get(typestr, typestr)
+
+    return typestr
+
+
+def get_struct_schema_str(message: MessageType, message_db: List[MessageType]):
     ret = ""
 
     for field in message["fields"]:
-        typestr = field["type"]
+        if (
+            "optional" in field
+            and field["optional"] == True
+            and "vla" in field
+            and field["vla"] == True
+        ):
+            raise Exception(f"Field {field} must be optional OR vla!")
+
+        typestr = get_fully_defined_field_name(field, message_db)
+
+        array_modifier = ""
+
         if "optional" in field and field["optional"] == True:
-            typestr += "?"
+            typestr = "optional " + typestr
         if "vla" in field and field["vla"] == True:
-            typestr += "[?]"
-        ret += f"{typestr} {field['name']};"
+            array_modifier = "[?]"
+
+        ret += f"{typestr} {field['name']}{array_modifier};"
 
     return ret
 
@@ -195,6 +242,9 @@ def get_struct_schema_str(message: MessageType):
 def generate_photon_messages(cpp_java_root, py_root, template_root):
     messages = parse_yaml()
 
+    for message in messages:
+        message["message_hash"] = get_message_hash(messages, message)
+
     env = Environment(
         loader=FileSystemLoader(str(template_root)),
         # autoescape=False,
@@ -267,14 +317,37 @@ def generate_photon_messages(cpp_java_root, py_root, template_root):
                 messages, name
             )
 
+            nested_photon_types = set(
+                [
+                    field["type"]
+                    for field in message["fields"]
+                    if (
+                        not is_intrinsic_type(field["type"])
+                        and not get_shimmed_filter(messages)(field["type"])
+                    )
+                ]
+            )
+            nested_wpilib_types = set(
+                [
+                    field["type"]
+                    for field in message["fields"]
+                    if (
+                        not is_intrinsic_type(field["type"])
+                        and get_shimmed_filter(messages)(field["type"])
+                    )
+                ]
+            )
+
             output_file = output_folder / output_name
             output_file.write_text(
                 template.render(
                     message,
                     type_map=extended_data_types,
-                    message_fmt=get_struct_schema_str(message),
-                    message_hash=message_hash.hexdigest(),
+                    message_fmt=get_struct_schema_str(message, messages),
+                    message_hash=message_hash,
                     cpp_includes=get_includes(messages, message),
+                    nested_photon_types=nested_photon_types,
+                    nested_wpilib_types=nested_wpilib_types,
                 ),
                 encoding="utf-8",
             )
diff --git a/photon-serde/messages.yaml b/photon-serde/messages.yaml
index 2eac0b4100..d7121c36cf 100644
--- a/photon-serde/messages.yaml
+++ b/photon-serde/messages.yaml
@@ -15,6 +15,7 @@
   cpp_type: frc::Transform3d
   cpp_include: "<frc/geometry/Transform3d.h>"
   python_decode_shim: packet.decodeTransform
+  java_import: edu.wpi.first.math.geometry.Transform3d
   # shim since we expect fields to at least exist
   fields: []
 
diff --git a/photon-serde/templates/Message.java.jinja b/photon-serde/templates/Message.java.jinja
index bf47b4eaf3..a7975295d5 100644
--- a/photon-serde/templates/Message.java.jinja
+++ b/photon-serde/templates/Message.java.jinja
@@ -26,17 +26,24 @@ import org.photonvision.utils.PacketUtils;
 // Assume that the base class lives here and we can import it
 import org.photonvision.targeting.*;
 
+// WPILib imports (if any)
+import edu.wpi.first.util.struct.Struct;
+{% for type in nested_wpilib_types -%}
+import {{ get_message_by_name(type).java_import }};
+{%- if not loop.last %},{% endif -%}
+{%- endfor%}
 
 /**
  * Auto-generated serialization/deserialization helper for {{name}}
  */
 public class {{ name }}Serde implements PacketSerde<{{name}}> {
-    // Message definition md5sum. See photon_packet.adoc for details
-    public static final String MESSAGE_VERSION = "{{ message_hash }}";
-    public static final String MESSAGE_FORMAT = "{{ message_fmt }}";
 
-    public final String getTypeString() { return MESSAGE_FORMAT; }
-    public final String getInterfaceUUID() { return MESSAGE_VERSION; }
+    @Override
+    public final String getInterfaceUUID() { return "{{ message_hash }}"; }
+    @Override
+    public final String getSchema() { return "{{ message_fmt }}"; }
+    @Override
+    public final String getTypeName() { return "{{ name }}"; }
 
     @Override
     public int getMaxByteSize() {
@@ -48,7 +55,6 @@ public class {{ name }}Serde implements PacketSerde<{{name}}> {
     public void pack(Packet packet, {{ name }} value) {
 {%- for field in fields -%}
     {%- if field.type | is_shimmed %}
-        // field is shimmed!
         {{ get_message_by_name(field.type).java_encode_shim }}(packet, value.{{ field.name }});
     {%- elif field.optional == True %}
         // {{ field.name }} is optional! it better not be a VLA too
@@ -76,7 +82,6 @@ public class {{ name }}Serde implements PacketSerde<{{name}}> {
         var ret = new {{ name }}();
 {% for field in fields -%}
     {%- if field.type | is_shimmed %}
-        // field is shimmed!
         ret.{{ field.name }} = {{ get_message_by_name(field.type).java_decode_shim }}(packet);
     {%- elif field.optional == True %}
         // {{ field.name }} is optional! it better not be a VLA too
@@ -100,4 +105,24 @@ public class {{ name }}Serde implements PacketSerde<{{name}}> {
 
         return ret;
     }
+
+    @Override
+    public PacketSerde<?>[] getNestedPhotonMessages() {
+        return new PacketSerde<?>[] {
+            {% for type in nested_photon_types -%}
+            {{ type }}.photonStruct
+            {%- if not loop.last %},{% endif -%}
+            {%- endfor%}
+        };
+    }
+
+    @Override
+    public Struct<?>[] getNestedWpilibMessages() {
+        return new Struct<?>[] {
+            {% for type in nested_wpilib_types -%}
+            {{ type }}.struct
+            {%- if not loop.last %},{% endif -%}
+            {%- endfor%}
+        };
+    }
 }
diff --git a/photon-serde/templates/ThingSerde.py.jinja b/photon-serde/templates/ThingSerde.py.jinja
index 3282cb51e8..335adc038c 100644
--- a/photon-serde/templates/ThingSerde.py.jinja
+++ b/photon-serde/templates/ThingSerde.py.jinja
@@ -33,7 +33,6 @@ class {{ name }}Serde:
         ret = {{ name }}()
 {% for field in fields -%}
 {%- if field.type | is_shimmed %}
-        # field is shimmed!
         ret.{{ field.name }} = {{ get_message_by_name(field.type).python_decode_shim }}()
 {%- elif field.optional == True %}
         # {{ field.name }} is optional! it better not be a VLA too
diff --git a/photon-targeting/src/generated/main/java/org/photonvision/struct/MultiTargetPNPResultSerde.java b/photon-targeting/src/generated/main/java/org/photonvision/struct/MultiTargetPNPResultSerde.java
index 961f465a43..1be3cf633d 100644
--- a/photon-targeting/src/generated/main/java/org/photonvision/struct/MultiTargetPNPResultSerde.java
+++ b/photon-targeting/src/generated/main/java/org/photonvision/struct/MultiTargetPNPResultSerde.java
@@ -26,17 +26,20 @@
 // Assume that the base class lives here and we can import it
 import org.photonvision.targeting.*;
 
+// WPILib imports (if any)
+import edu.wpi.first.util.struct.Struct;
+
 
 /**
  * Auto-generated serialization/deserialization helper for MultiTargetPNPResult
  */
 public class MultiTargetPNPResultSerde implements PacketSerde<MultiTargetPNPResult> {
-    // Message definition md5sum. See photon_packet.adoc for details
-    public static final String MESSAGE_VERSION = "ffc1cb847deb6e796a583a5b1885496b";
-    public static final String MESSAGE_FORMAT = "PnpResult estimatedPose;int16[?] fiducialIDsUsed;";
-
-    public final String getTypeString() { return MESSAGE_FORMAT; }
-    public final String getInterfaceUUID() { return MESSAGE_VERSION; }
+    @Override
+    public final String getInterfaceUUID() { return "541096947e9f3ca2d3f425ff7b04aa7b"; }
+    @Override
+    public final String getSchema() { return "PnpResult:ae4d655c0a3104d88df4f5db144c1e86 estimatedPose;int16 fiducialIDsUsed[?];"; }
+    @Override
+    public final String getTypeName() { return "MultiTargetPNPResult"; }
 
     @Override
     public int getMaxByteSize() {
@@ -65,4 +68,17 @@ public MultiTargetPNPResult unpack(Packet packet) {
 
         return ret;
     }
+
+    @Override
+    public PacketSerde<?>[] getNestedPhotonMessages() {
+        return new PacketSerde<?>[] {
+            PnpResult.photonStruct
+        };
+    }
+
+    @Override
+    public Struct<?>[] getNestedWpilibMessages() {
+        return new Struct<?>[] {
+        };
+    }
 }
diff --git a/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonPipelineMetadataSerde.java b/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonPipelineMetadataSerde.java
index 1ba176d809..fb87bea148 100644
--- a/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonPipelineMetadataSerde.java
+++ b/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonPipelineMetadataSerde.java
@@ -26,17 +26,20 @@
 // Assume that the base class lives here and we can import it
 import org.photonvision.targeting.*;
 
+// WPILib imports (if any)
+import edu.wpi.first.util.struct.Struct;
+
 
 /**
  * Auto-generated serialization/deserialization helper for PhotonPipelineMetadata
  */
 public class PhotonPipelineMetadataSerde implements PacketSerde<PhotonPipelineMetadata> {
-    // Message definition md5sum. See photon_packet.adoc for details
-    public static final String MESSAGE_VERSION = "2a7039527bda14d13028a1b9282d40a2";
-    public static final String MESSAGE_FORMAT = "int64 sequenceID;int64 captureTimestampMicros;int64 publishTimestampMicros;";
-
-    public final String getTypeString() { return MESSAGE_FORMAT; }
-    public final String getInterfaceUUID() { return MESSAGE_VERSION; }
+    @Override
+    public final String getInterfaceUUID() { return "626e70461cbdb274fb43ead09c255f4e"; }
+    @Override
+    public final String getSchema() { return "int64 sequenceID;int64 captureTimestampMicros;int64 publishTimestampMicros;"; }
+    @Override
+    public final String getTypeName() { return "PhotonPipelineMetadata"; }
 
     @Override
     public int getMaxByteSize() {
@@ -71,4 +74,16 @@ public PhotonPipelineMetadata unpack(Packet packet) {
 
         return ret;
     }
+
+    @Override
+    public PacketSerde<?>[] getNestedPhotonMessages() {
+        return new PacketSerde<?>[] {
+        };
+    }
+
+    @Override
+    public Struct<?>[] getNestedWpilibMessages() {
+        return new Struct<?>[] {
+        };
+    }
 }
diff --git a/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonPipelineResultSerde.java b/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonPipelineResultSerde.java
index 21e54ad470..edd17aba43 100644
--- a/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonPipelineResultSerde.java
+++ b/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonPipelineResultSerde.java
@@ -26,17 +26,20 @@
 // Assume that the base class lives here and we can import it
 import org.photonvision.targeting.*;
 
+// WPILib imports (if any)
+import edu.wpi.first.util.struct.Struct;
+
 
 /**
  * Auto-generated serialization/deserialization helper for PhotonPipelineResult
  */
 public class PhotonPipelineResultSerde implements PacketSerde<PhotonPipelineResult> {
-    // Message definition md5sum. See photon_packet.adoc for details
-    public static final String MESSAGE_VERSION = "cb3e1605048ba49325888eb797399fe2";
-    public static final String MESSAGE_FORMAT = "PhotonPipelineMetadata metadata;PhotonTrackedTarget[?] targets;MultiTargetPNPResult? multitagResult;";
-
-    public final String getTypeString() { return MESSAGE_FORMAT; }
-    public final String getInterfaceUUID() { return MESSAGE_VERSION; }
+    @Override
+    public final String getInterfaceUUID() { return "5eeaa293d0c69aea90eaddea786a2b3b"; }
+    @Override
+    public final String getSchema() { return "PhotonPipelineMetadata:626e70461cbdb274fb43ead09c255f4e metadata;PhotonTrackedTarget:cc6dbb5c5c1e0fa808108019b20863f1 targets[?];optional MultiTargetPNPResult:541096947e9f3ca2d3f425ff7b04aa7b multitagResult;"; }
+    @Override
+    public final String getTypeName() { return "PhotonPipelineResult"; }
 
     @Override
     public int getMaxByteSize() {
@@ -71,4 +74,17 @@ public PhotonPipelineResult unpack(Packet packet) {
 
         return ret;
     }
+
+    @Override
+    public PacketSerde<?>[] getNestedPhotonMessages() {
+        return new PacketSerde<?>[] {
+            PhotonPipelineMetadata.photonStruct,MultiTargetPNPResult.photonStruct,PhotonTrackedTarget.photonStruct
+        };
+    }
+
+    @Override
+    public Struct<?>[] getNestedWpilibMessages() {
+        return new Struct<?>[] {
+        };
+    }
 }
diff --git a/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonTrackedTargetSerde.java b/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonTrackedTargetSerde.java
index d07482017a..0c2beef2c3 100644
--- a/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonTrackedTargetSerde.java
+++ b/photon-targeting/src/generated/main/java/org/photonvision/struct/PhotonTrackedTargetSerde.java
@@ -26,17 +26,20 @@
 // Assume that the base class lives here and we can import it
 import org.photonvision.targeting.*;
 
+// WPILib imports (if any)
+import edu.wpi.first.util.struct.Struct;
+import edu.wpi.first.math.geometry.Transform3d;
 
 /**
  * Auto-generated serialization/deserialization helper for PhotonTrackedTarget
  */
 public class PhotonTrackedTargetSerde implements PacketSerde<PhotonTrackedTarget> {
-    // Message definition md5sum. See photon_packet.adoc for details
-    public static final String MESSAGE_VERSION = "8fdada56b9162f2e32bd24f0055d7b60";
-    public static final String MESSAGE_FORMAT = "float64 yaw;float64 pitch;float64 area;float64 skew;int32 fiducialId;int32 objDetectId;float32 objDetectConf;Transform3d bestCameraToTarget;Transform3d altCameraToTarget;float64 poseAmbiguity;TargetCorner[?] minAreaRectCorners;TargetCorner[?] detectedCorners;";
-
-    public final String getTypeString() { return MESSAGE_FORMAT; }
-    public final String getInterfaceUUID() { return MESSAGE_VERSION; }
+    @Override
+    public final String getInterfaceUUID() { return "cc6dbb5c5c1e0fa808108019b20863f1"; }
+    @Override
+    public final String getSchema() { return "float64 yaw;float64 pitch;float64 area;float64 skew;int32 fiducialId;int32 objDetectId;float32 objDetectConf;Transform3d bestCameraToTarget;Transform3d altCameraToTarget;float64 poseAmbiguity;TargetCorner:16f6ac0dedc8eaccb951f4895d9e18b6 minAreaRectCorners[?];TargetCorner:16f6ac0dedc8eaccb951f4895d9e18b6 detectedCorners[?];"; }
+    @Override
+    public final String getTypeName() { return "PhotonTrackedTarget"; }
 
     @Override
     public int getMaxByteSize() {
@@ -67,10 +70,8 @@ public void pack(Packet packet, PhotonTrackedTarget value) {
         // field objDetectConf is of intrinsic type float32
         packet.encode((float) value.objDetectConf);
 
-        // field is shimmed!
         PacketUtils.packTransform3d(packet, value.bestCameraToTarget);
 
-        // field is shimmed!
         PacketUtils.packTransform3d(packet, value.altCameraToTarget);
 
         // field poseAmbiguity is of intrinsic type float64
@@ -108,10 +109,8 @@ public PhotonTrackedTarget unpack(Packet packet) {
         // objDetectConf is of intrinsic type float32
         ret.objDetectConf = packet.decodeFloat();
 
-        // field is shimmed!
         ret.bestCameraToTarget = PacketUtils.unpackTransform3d(packet);
 
-        // field is shimmed!
         ret.altCameraToTarget = PacketUtils.unpackTransform3d(packet);
 
         // poseAmbiguity is of intrinsic type float64
@@ -125,4 +124,18 @@ public PhotonTrackedTarget unpack(Packet packet) {
 
         return ret;
     }
+
+    @Override
+    public PacketSerde<?>[] getNestedPhotonMessages() {
+        return new PacketSerde<?>[] {
+            TargetCorner.photonStruct
+        };
+    }
+
+    @Override
+    public Struct<?>[] getNestedWpilibMessages() {
+        return new Struct<?>[] {
+            Transform3d.struct
+        };
+    }
 }
diff --git a/photon-targeting/src/generated/main/java/org/photonvision/struct/PnpResultSerde.java b/photon-targeting/src/generated/main/java/org/photonvision/struct/PnpResultSerde.java
index a0c90f0f3a..b9c7e695b3 100644
--- a/photon-targeting/src/generated/main/java/org/photonvision/struct/PnpResultSerde.java
+++ b/photon-targeting/src/generated/main/java/org/photonvision/struct/PnpResultSerde.java
@@ -26,17 +26,20 @@
 // Assume that the base class lives here and we can import it
 import org.photonvision.targeting.*;
 
+// WPILib imports (if any)
+import edu.wpi.first.util.struct.Struct;
+import edu.wpi.first.math.geometry.Transform3d;
 
 /**
  * Auto-generated serialization/deserialization helper for PnpResult
  */
 public class PnpResultSerde implements PacketSerde<PnpResult> {
-    // Message definition md5sum. See photon_packet.adoc for details
-    public static final String MESSAGE_VERSION = "0d1f2546b00f24718e30f38d206d4491";
-    public static final String MESSAGE_FORMAT = "Transform3d best;Transform3d alt;float64 bestReprojErr;float64 altReprojErr;float64 ambiguity;";
-
-    public final String getTypeString() { return MESSAGE_FORMAT; }
-    public final String getInterfaceUUID() { return MESSAGE_VERSION; }
+    @Override
+    public final String getInterfaceUUID() { return "ae4d655c0a3104d88df4f5db144c1e86"; }
+    @Override
+    public final String getSchema() { return "Transform3d best;Transform3d alt;float64 bestReprojErr;float64 altReprojErr;float64 ambiguity;"; }
+    @Override
+    public final String getTypeName() { return "PnpResult"; }
 
     @Override
     public int getMaxByteSize() {
@@ -46,10 +49,8 @@ public int getMaxByteSize() {
 
     @Override
     public void pack(Packet packet, PnpResult value) {
-        // field is shimmed!
         PacketUtils.packTransform3d(packet, value.best);
 
-        // field is shimmed!
         PacketUtils.packTransform3d(packet, value.alt);
 
         // field bestReprojErr is of intrinsic type float64
@@ -66,10 +67,8 @@ public void pack(Packet packet, PnpResult value) {
     public PnpResult unpack(Packet packet) {
         var ret = new PnpResult();
 
-        // field is shimmed!
         ret.best = PacketUtils.unpackTransform3d(packet);
 
-        // field is shimmed!
         ret.alt = PacketUtils.unpackTransform3d(packet);
 
         // bestReprojErr is of intrinsic type float64
@@ -83,4 +82,17 @@ public PnpResult unpack(Packet packet) {
 
         return ret;
     }
+
+    @Override
+    public PacketSerde<?>[] getNestedPhotonMessages() {
+        return new PacketSerde<?>[] {
+        };
+    }
+
+    @Override
+    public Struct<?>[] getNestedWpilibMessages() {
+        return new Struct<?>[] {
+            Transform3d.struct
+        };
+    }
 }
diff --git a/photon-targeting/src/generated/main/java/org/photonvision/struct/TargetCornerSerde.java b/photon-targeting/src/generated/main/java/org/photonvision/struct/TargetCornerSerde.java
index 8c5d2a637d..64f190bf76 100644
--- a/photon-targeting/src/generated/main/java/org/photonvision/struct/TargetCornerSerde.java
+++ b/photon-targeting/src/generated/main/java/org/photonvision/struct/TargetCornerSerde.java
@@ -26,17 +26,20 @@
 // Assume that the base class lives here and we can import it
 import org.photonvision.targeting.*;
 
+// WPILib imports (if any)
+import edu.wpi.first.util.struct.Struct;
+
 
 /**
  * Auto-generated serialization/deserialization helper for TargetCorner
  */
 public class TargetCornerSerde implements PacketSerde<TargetCorner> {
-    // Message definition md5sum. See photon_packet.adoc for details
-    public static final String MESSAGE_VERSION = "22b1ff7551d10215af6fb3672fe4eda8";
-    public static final String MESSAGE_FORMAT = "float64 x;float64 y;";
-
-    public final String getTypeString() { return MESSAGE_FORMAT; }
-    public final String getInterfaceUUID() { return MESSAGE_VERSION; }
+    @Override
+    public final String getInterfaceUUID() { return "16f6ac0dedc8eaccb951f4895d9e18b6"; }
+    @Override
+    public final String getSchema() { return "float64 x;float64 y;"; }
+    @Override
+    public final String getTypeName() { return "TargetCorner"; }
 
     @Override
     public int getMaxByteSize() {
@@ -65,4 +68,16 @@ public TargetCorner unpack(Packet packet) {
 
         return ret;
     }
+
+    @Override
+    public PacketSerde<?>[] getNestedPhotonMessages() {
+        return new PacketSerde<?>[] {
+        };
+    }
+
+    @Override
+    public Struct<?>[] getNestedWpilibMessages() {
+        return new Struct<?>[] {
+        };
+    }
 }
diff --git a/photon-targeting/src/generated/main/native/include/photon/serde/MultiTargetPNPResultSerde.h b/photon-targeting/src/generated/main/native/include/photon/serde/MultiTargetPNPResultSerde.h
index 7a75354baf..2fc1a5f0c7 100644
--- a/photon-targeting/src/generated/main/native/include/photon/serde/MultiTargetPNPResultSerde.h
+++ b/photon-targeting/src/generated/main/native/include/photon/serde/MultiTargetPNPResultSerde.h
@@ -36,11 +36,12 @@ namespace photon {
 template <>
 struct WPILIB_DLLEXPORT SerdeType<MultiTargetPNPResult> {
   static constexpr std::string_view GetSchemaHash() {
-    return "ffc1cb847deb6e796a583a5b1885496b";
+    return "541096947e9f3ca2d3f425ff7b04aa7b";
   }
 
   static constexpr std::string_view GetSchema() {
-    return "PnpResult estimatedPose;int16[?] fiducialIDsUsed;";
+    return "PnpResult:ae4d655c0a3104d88df4f5db144c1e86 estimatedPose;int16 "
+           "fiducialIDsUsed[?];";
   }
 
   static photon::MultiTargetPNPResult Unpack(photon::Packet& packet);
diff --git a/photon-targeting/src/generated/main/native/include/photon/serde/PhotonPipelineMetadataSerde.h b/photon-targeting/src/generated/main/native/include/photon/serde/PhotonPipelineMetadataSerde.h
index d3883605a0..ecdc882379 100644
--- a/photon-targeting/src/generated/main/native/include/photon/serde/PhotonPipelineMetadataSerde.h
+++ b/photon-targeting/src/generated/main/native/include/photon/serde/PhotonPipelineMetadataSerde.h
@@ -34,7 +34,7 @@ namespace photon {
 template <>
 struct WPILIB_DLLEXPORT SerdeType<PhotonPipelineMetadata> {
   static constexpr std::string_view GetSchemaHash() {
-    return "2a7039527bda14d13028a1b9282d40a2";
+    return "626e70461cbdb274fb43ead09c255f4e";
   }
 
   static constexpr std::string_view GetSchema() {
diff --git a/photon-targeting/src/generated/main/native/include/photon/serde/PhotonPipelineResultSerde.h b/photon-targeting/src/generated/main/native/include/photon/serde/PhotonPipelineResultSerde.h
index b7872d067b..49845033cb 100644
--- a/photon-targeting/src/generated/main/native/include/photon/serde/PhotonPipelineResultSerde.h
+++ b/photon-targeting/src/generated/main/native/include/photon/serde/PhotonPipelineResultSerde.h
@@ -39,12 +39,15 @@ namespace photon {
 template <>
 struct WPILIB_DLLEXPORT SerdeType<PhotonPipelineResult> {
   static constexpr std::string_view GetSchemaHash() {
-    return "cb3e1605048ba49325888eb797399fe2";
+    return "5eeaa293d0c69aea90eaddea786a2b3b";
   }
 
   static constexpr std::string_view GetSchema() {
-    return "PhotonPipelineMetadata metadata;PhotonTrackedTarget[?] "
-           "targets;MultiTargetPNPResult? multitagResult;";
+    return "PhotonPipelineMetadata:626e70461cbdb274fb43ead09c255f4e "
+           "metadata;PhotonTrackedTarget:cc6dbb5c5c1e0fa808108019b20863f1 "
+           "targets[?];optional "
+           "MultiTargetPNPResult:541096947e9f3ca2d3f425ff7b04aa7b "
+           "multitagResult;";
   }
 
   static photon::PhotonPipelineResult Unpack(photon::Packet& packet);
diff --git a/photon-targeting/src/generated/main/native/include/photon/serde/PhotonTrackedTargetSerde.h b/photon-targeting/src/generated/main/native/include/photon/serde/PhotonTrackedTargetSerde.h
index abc2196b8b..b1c026a782 100644
--- a/photon-targeting/src/generated/main/native/include/photon/serde/PhotonTrackedTargetSerde.h
+++ b/photon-targeting/src/generated/main/native/include/photon/serde/PhotonTrackedTargetSerde.h
@@ -37,15 +37,16 @@ namespace photon {
 template <>
 struct WPILIB_DLLEXPORT SerdeType<PhotonTrackedTarget> {
   static constexpr std::string_view GetSchemaHash() {
-    return "8fdada56b9162f2e32bd24f0055d7b60";
+    return "cc6dbb5c5c1e0fa808108019b20863f1";
   }
 
   static constexpr std::string_view GetSchema() {
     return "float64 yaw;float64 pitch;float64 area;float64 skew;int32 "
            "fiducialId;int32 objDetectId;float32 objDetectConf;Transform3d "
            "bestCameraToTarget;Transform3d altCameraToTarget;float64 "
-           "poseAmbiguity;TargetCorner[?] minAreaRectCorners;TargetCorner[?] "
-           "detectedCorners;";
+           "poseAmbiguity;TargetCorner:16f6ac0dedc8eaccb951f4895d9e18b6 "
+           "minAreaRectCorners[?];TargetCorner:"
+           "16f6ac0dedc8eaccb951f4895d9e18b6 detectedCorners[?];";
   }
 
   static photon::PhotonTrackedTarget Unpack(photon::Packet& packet);
diff --git a/photon-targeting/src/generated/main/native/include/photon/serde/PnpResultSerde.h b/photon-targeting/src/generated/main/native/include/photon/serde/PnpResultSerde.h
index 8e507b0341..f4359e4512 100644
--- a/photon-targeting/src/generated/main/native/include/photon/serde/PnpResultSerde.h
+++ b/photon-targeting/src/generated/main/native/include/photon/serde/PnpResultSerde.h
@@ -35,7 +35,7 @@ namespace photon {
 template <>
 struct WPILIB_DLLEXPORT SerdeType<PnpResult> {
   static constexpr std::string_view GetSchemaHash() {
-    return "0d1f2546b00f24718e30f38d206d4491";
+    return "ae4d655c0a3104d88df4f5db144c1e86";
   }
 
   static constexpr std::string_view GetSchema() {
diff --git a/photon-targeting/src/generated/main/native/include/photon/serde/TargetCornerSerde.h b/photon-targeting/src/generated/main/native/include/photon/serde/TargetCornerSerde.h
index 27ce589a1e..718d613a4b 100644
--- a/photon-targeting/src/generated/main/native/include/photon/serde/TargetCornerSerde.h
+++ b/photon-targeting/src/generated/main/native/include/photon/serde/TargetCornerSerde.h
@@ -34,7 +34,7 @@ namespace photon {
 template <>
 struct WPILIB_DLLEXPORT SerdeType<TargetCorner> {
   static constexpr std::string_view GetSchemaHash() {
-    return "22b1ff7551d10215af6fb3672fe4eda8";
+    return "16f6ac0dedc8eaccb951f4895d9e18b6";
   }
 
   static constexpr std::string_view GetSchema() {
diff --git a/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/Packet.java b/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/Packet.java
index 54daf04ab9..62d5d2c2c0 100644
--- a/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/Packet.java
+++ b/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/Packet.java
@@ -160,8 +160,8 @@ public void encode(byte src) {
      */
     public void encode(short src) {
         ensureCapacity(2);
-        packetData[writePos++] = (byte) (src >>> 8);
         packetData[writePos++] = (byte) src;
+        packetData[writePos++] = (byte) (src >>> 8);
     }
 
     /**
@@ -171,10 +171,10 @@ public void encode(short src) {
      */
     public void encode(int src) {
         ensureCapacity(4);
-        packetData[writePos++] = (byte) (src >>> 24);
-        packetData[writePos++] = (byte) (src >>> 16);
-        packetData[writePos++] = (byte) (src >>> 8);
         packetData[writePos++] = (byte) src;
+        packetData[writePos++] = (byte) (src >>> 8);
+        packetData[writePos++] = (byte) (src >>> 16);
+        packetData[writePos++] = (byte) (src >>> 24);
     }
 
     /**
@@ -185,10 +185,10 @@ public void encode(int src) {
     public void encode(float src) {
         ensureCapacity(4);
         int data = Float.floatToIntBits(src);
-        packetData[writePos++] = (byte) ((data >> 24) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 16) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 8) & 0xff);
         packetData[writePos++] = (byte) (data & 0xff);
+        packetData[writePos++] = (byte) ((data >> 8) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 16) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 24) & 0xff);
     }
 
     /**
@@ -198,14 +198,14 @@ public void encode(float src) {
      */
     public void encode(long data) {
         ensureCapacity(8);
-        packetData[writePos++] = (byte) ((data >> 56) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 48) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 40) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 32) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 24) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 16) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 8) & 0xff);
         packetData[writePos++] = (byte) (data & 0xff);
+        packetData[writePos++] = (byte) ((data >> 8) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 16) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 24) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 32) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 40) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 48) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 56) & 0xff);
     }
 
     /**
@@ -216,14 +216,14 @@ public void encode(long data) {
     public void encode(double src) {
         ensureCapacity(8);
         long data = Double.doubleToRawLongBits(src);
-        packetData[writePos++] = (byte) ((data >> 56) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 48) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 40) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 32) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 24) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 16) & 0xff);
-        packetData[writePos++] = (byte) ((data >> 8) & 0xff);
         packetData[writePos++] = (byte) (data & 0xff);
+        packetData[writePos++] = (byte) ((data >> 8) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 16) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 24) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 32) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 40) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 48) & 0xff);
+        packetData[writePos++] = (byte) ((data >> 56) & 0xff);
     }
 
     /**
@@ -303,10 +303,10 @@ public int decodeInt() {
         if (packetData.length < readPos + 3) {
             return 0;
         }
-        return (0xff & packetData[readPos++]) << 24
-                | (0xff & packetData[readPos++]) << 16
+        return (0xff & packetData[readPos++])
                 | (0xff & packetData[readPos++]) << 8
-                | (0xff & packetData[readPos++]);
+                | (0xff & packetData[readPos++]) << 16
+                | (0xff & packetData[readPos++]) << 24;
     }
 
     public long decodeLong() {
@@ -314,14 +314,15 @@ public long decodeLong() {
             return 0;
         }
         long data =
-                (long) (0xff & packetData[readPos++]) << 56
-                        | (long) (0xff & packetData[readPos++]) << 48
-                        | (long) (0xff & packetData[readPos++]) << 40
-                        | (long) (0xff & packetData[readPos++]) << 32
-                        | (long) (0xff & packetData[readPos++]) << 24
-                        | (long) (0xff & packetData[readPos++]) << 16
-                        | (long) (0xff & packetData[readPos++]) << 8
-                        | (long) (0xff & packetData[readPos++]);
+                (long)
+                        (0xff & packetData[readPos++]
+                                | (long) (0xff & packetData[readPos++]) << 8
+                                | (long) (0xff & packetData[readPos++]) << 16
+                                | (long) (0xff & packetData[readPos++]) << 24
+                                | (long) (0xff & packetData[readPos++]) << 32
+                                | (long) (0xff & packetData[readPos++]) << 40
+                                | (long) (0xff & packetData[readPos++]) << 48
+                                | (long) (0xff & packetData[readPos++]) << 56);
         return data;
     }
 
@@ -335,14 +336,15 @@ public double decodeDouble() {
             return 0;
         }
         long data =
-                (long) (0xff & packetData[readPos++]) << 56
-                        | (long) (0xff & packetData[readPos++]) << 48
-                        | (long) (0xff & packetData[readPos++]) << 40
-                        | (long) (0xff & packetData[readPos++]) << 32
-                        | (long) (0xff & packetData[readPos++]) << 24
-                        | (long) (0xff & packetData[readPos++]) << 16
-                        | (long) (0xff & packetData[readPos++]) << 8
-                        | (long) (0xff & packetData[readPos++]);
+                (long)
+                        (0xff & packetData[readPos++]
+                                | (long) (0xff & packetData[readPos++]) << 8
+                                | (long) (0xff & packetData[readPos++]) << 16
+                                | (long) (0xff & packetData[readPos++]) << 24
+                                | (long) (0xff & packetData[readPos++]) << 32
+                                | (long) (0xff & packetData[readPos++]) << 40
+                                | (long) (0xff & packetData[readPos++]) << 48
+                                | (long) (0xff & packetData[readPos++]) << 56);
         return Double.longBitsToDouble(data);
     }
 
@@ -355,11 +357,12 @@ public float decodeFloat() {
         if (packetData.length < (readPos + 3)) {
             return 0;
         }
+
         int data =
-                (int) (0xff & packetData[readPos++]) << 24
-                        | (int) (0xff & packetData[readPos++]) << 16
-                        | (int) (0xff & packetData[readPos++]) << 8
-                        | (int) (0xff & packetData[readPos++]);
+                ((0xff & packetData[readPos++]
+                        | (0xff & packetData[readPos++]) << 8
+                        | (0xff & packetData[readPos++]) << 16
+                        | (0xff & packetData[readPos++]) << 24));
         return Float.intBitsToFloat(data);
     }
 
@@ -393,7 +396,7 @@ public short decodeShort() {
         if (packetData.length < readPos + 1) {
             return 0;
         }
-        return (short) ((0xff & packetData[readPos++]) << 8 | (0xff & packetData[readPos++]));
+        return (short) ((0xff & packetData[readPos++]) | (0xff & packetData[readPos++]) << 8);
     }
 
     /**
diff --git a/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/PacketSerde.java b/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/PacketSerde.java
index a9009d41b5..a4e095cbbd 100644
--- a/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/PacketSerde.java
+++ b/photon-targeting/src/main/java/org/photonvision/common/dataflow/structures/PacketSerde.java
@@ -17,6 +17,8 @@
 
 package org.photonvision.common.dataflow.structures;
 
+import edu.wpi.first.util.struct.Struct;
+
 public interface PacketSerde<T> {
     int getMaxByteSize();
 
@@ -24,7 +26,32 @@ public interface PacketSerde<T> {
 
     T unpack(Packet packet);
 
-    String getTypeString();
+    /** The name of this struct (eg "PhotonTrackedTarget") */
+    String getTypeName();
+
+    /**
+     * Gets the type string (e.g. for NetworkTables). This should be globally unique and start with
+     * "photonstruct:".
+     *
+     * @return type string
+     */
+    default String getTypeString() {
+        return "photonstruct:" + getTypeName() + ":" + getInterfaceUUID();
+    }
+
+    /** Gets the list of photonstruct types referenced by this struct. */
+    default PacketSerde<?>[] getNestedPhotonMessages() {
+        return new PacketSerde<?>[] {};
+    }
+
+    /** Gets the list of WPILib struct types referenced by this struct. */
+    default Struct<?>[] getNestedWpilibMessages() {
+        return new Struct<?>[] {};
+    }
+
+    /** The schema definition, as defined in photon-serde/README.md */
+    String getSchema();
 
+    /** The hash of the schema string */
     String getInterfaceUUID();
 }
diff --git a/photon-targeting/src/main/java/org/photonvision/common/networktables/NTTopicSet.java b/photon-targeting/src/main/java/org/photonvision/common/networktables/NTTopicSet.java
index 5617ef869e..1b1fd2698f 100644
--- a/photon-targeting/src/main/java/org/photonvision/common/networktables/NTTopicSet.java
+++ b/photon-targeting/src/main/java/org/photonvision/common/networktables/NTTopicSet.java
@@ -17,6 +17,7 @@
 
 package org.photonvision.common.networktables;
 
+import edu.wpi.first.math.geometry.Transform3d;
 import edu.wpi.first.networktables.BooleanPublisher;
 import edu.wpi.first.networktables.BooleanSubscriber;
 import edu.wpi.first.networktables.BooleanTopic;
@@ -28,6 +29,7 @@
 import edu.wpi.first.networktables.NetworkTable;
 import edu.wpi.first.networktables.ProtobufPublisher;
 import edu.wpi.first.networktables.PubSubOption;
+import edu.wpi.first.networktables.StructPublisher;
 import org.photonvision.targeting.PhotonPipelineResult;
 
 /**
@@ -56,7 +58,7 @@ public class NTTopicSet {
     public DoublePublisher targetPitchEntry;
     public DoublePublisher targetYawEntry;
     public DoublePublisher targetAreaEntry;
-    public DoubleArrayPublisher targetPoseEntry;
+    public StructPublisher<Transform3d> targetPoseEntry;
     public DoublePublisher targetSkewEntry;
 
     // The raw position of the best target, in pixels.
@@ -75,7 +77,10 @@ public void updateEntries() {
         var rawBytesEntry =
                 subTable
                         .getRawTopic("rawBytes")
-                        .publish("rawBytes", PubSubOption.periodic(0.01), PubSubOption.sendAll(true));
+                        .publish(
+                                PhotonPipelineResult.photonStruct.getTypeString(),
+                                PubSubOption.periodic(0.01),
+                                PubSubOption.sendAll(true));
 
         resultPublisher =
                 new PacketPublisher<PhotonPipelineResult>(rawBytesEntry, PhotonPipelineResult.photonStruct);
@@ -99,7 +104,7 @@ public void updateEntries() {
         targetPitchEntry = subTable.getDoubleTopic("targetPitch").publish();
         targetAreaEntry = subTable.getDoubleTopic("targetArea").publish();
         targetYawEntry = subTable.getDoubleTopic("targetYaw").publish();
-        targetPoseEntry = subTable.getDoubleArrayTopic("targetPose").publish();
+        targetPoseEntry = subTable.getStructTopic("targetPose", Transform3d.struct).publish();
         targetSkewEntry = subTable.getDoubleTopic("targetSkew").publish();
 
         bestTargetPosX = subTable.getDoubleTopic("targetPixelsX").publish();
diff --git a/photon-targeting/src/main/java/org/photonvision/common/networktables/PacketPublisher.java b/photon-targeting/src/main/java/org/photonvision/common/networktables/PacketPublisher.java
index aa714fd477..3c36d19774 100644
--- a/photon-targeting/src/main/java/org/photonvision/common/networktables/PacketPublisher.java
+++ b/photon-targeting/src/main/java/org/photonvision/common/networktables/PacketPublisher.java
@@ -20,6 +20,8 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import edu.wpi.first.networktables.RawPublisher;
+import java.util.HashSet;
+import java.util.Set;
 import org.photonvision.common.dataflow.structures.Packet;
 import org.photonvision.common.dataflow.structures.PacketSerde;
 
@@ -33,9 +35,6 @@ public PacketPublisher(RawPublisher publisher, PacketSerde<T> photonStruct) {
 
         var mapper = new ObjectMapper();
         try {
-            this.publisher
-                    .getTopic()
-                    .setProperty("message_format", mapper.writeValueAsString(photonStruct.getTypeString()));
             this.publisher
                     .getTopic()
                     .setProperty("message_uuid", mapper.writeValueAsString(photonStruct.getInterfaceUUID()));
@@ -44,12 +43,12 @@ public PacketPublisher(RawPublisher publisher, PacketSerde<T> photonStruct) {
             e.printStackTrace();
             throw new RuntimeException(e);
         }
+        addSchemaImpl(photonStruct, new HashSet<>());
     }
 
     public void set(T value, int byteSize) {
         var packet = new Packet(byteSize);
         photonStruct.pack(packet, value);
-        // todo: trim to only the bytes we need to send
         publisher.set(packet.getWrittenDataCopy());
     }
 
@@ -61,4 +60,40 @@ public void set(T value) {
     public void close() {
         publisher.close();
     }
+
+    /**
+     * Publish the schema for our type (and all nested types under it) to NT.
+     *
+     * <p>Copyright (c) FIRST and other WPILib contributors. Open Source Software; you can modify
+     * and/or share it under the terms of the WPILib BSD license file in the root directory of this
+     * project.
+     *
+     * @param struct The struct to publish
+     * @param seen The set of types we've already published
+     */
+    private void addSchemaImpl(PacketSerde<?> struct, Set<String> seen) {
+        var instance = this.publisher.getTopic().getInstance();
+
+        String typeString = struct.getTypeString();
+
+        if (instance.hasSchema(typeString)) {
+            return;
+        }
+
+        if (!seen.add(typeString)) {
+            throw new UnsupportedOperationException(typeString + ": circular reference with " + seen);
+        }
+
+        instance.addSchema(typeString, "photonstructschema", struct.getSchema());
+
+        for (var inner : struct.getNestedPhotonMessages()) {
+            System.out.println(inner.getTypeString());
+            addSchemaImpl(inner, seen);
+        }
+        for (var inner : struct.getNestedWpilibMessages()) {
+            System.out.println(inner.getTypeString());
+            instance.addSchema(inner);
+        }
+        seen.remove(typeString);
+    }
 }
diff --git a/photon-targeting/src/main/java/org/photonvision/targeting/PhotonTrackedTarget.java b/photon-targeting/src/main/java/org/photonvision/targeting/PhotonTrackedTarget.java
index 4ae34afa7b..4ddb042b34 100644
--- a/photon-targeting/src/main/java/org/photonvision/targeting/PhotonTrackedTarget.java
+++ b/photon-targeting/src/main/java/org/photonvision/targeting/PhotonTrackedTarget.java
@@ -182,6 +182,8 @@ public int hashCode() {
         temp = Double.doubleToLongBits(skew);
         result = prime * result + (int) (temp ^ (temp >>> 32));
         result = prime * result + fiducialId;
+        result = prime * result + objDetectId;
+        result = prime * result + Float.floatToIntBits(objDetectConf);
         result = prime * result + ((bestCameraToTarget == null) ? 0 : bestCameraToTarget.hashCode());
         result = prime * result + ((altCameraToTarget == null) ? 0 : altCameraToTarget.hashCode());
         temp = Double.doubleToLongBits(poseAmbiguity);
@@ -202,6 +204,9 @@ public boolean equals(Object obj) {
         if (Double.doubleToLongBits(area) != Double.doubleToLongBits(other.area)) return false;
         if (Double.doubleToLongBits(skew) != Double.doubleToLongBits(other.skew)) return false;
         if (fiducialId != other.fiducialId) return false;
+        if (objDetectId != other.objDetectId) return false;
+        if (Float.floatToIntBits(objDetectConf) != Float.floatToIntBits(other.objDetectConf))
+            return false;
         if (bestCameraToTarget == null) {
             if (other.bestCameraToTarget != null) return false;
         } else if (!bestCameraToTarget.equals(other.bestCameraToTarget)) return false;
@@ -221,8 +226,7 @@ public boolean equals(Object obj) {
 
     @Override
     public String toString() {
-        return "PhotonTrackedTarget{"
-                + "yaw="
+        return "PhotonTrackedTarget [yaw="
                 + yaw
                 + ", pitch="
                 + pitch
@@ -232,11 +236,21 @@ public String toString() {
                 + skew
                 + ", fiducialId="
                 + fiducialId
-                + ", cameraToTarget="
+                + ", objDetectId="
+                + objDetectId
+                + ", objDetectConf="
+                + objDetectConf
+                + ", bestCameraToTarget="
                 + bestCameraToTarget
-                + ", targetCorners="
+                + ", altCameraToTarget="
+                + altCameraToTarget
+                + ", poseAmbiguity="
+                + poseAmbiguity
+                + ", minAreaRectCorners="
                 + minAreaRectCorners
-                + '}';
+                + ", detectedCorners="
+                + detectedCorners
+                + "]";
     }
 
     public static final PhotonTrackedTargetProto proto = new PhotonTrackedTargetProto();
diff --git a/photon-targeting/src/main/java/org/photonvision/targeting/proto/PhotonTrackedTargetProto.java b/photon-targeting/src/main/java/org/photonvision/targeting/proto/PhotonTrackedTargetProto.java
index cdd4f6cf21..8eb24ef6b6 100644
--- a/photon-targeting/src/main/java/org/photonvision/targeting/proto/PhotonTrackedTargetProto.java
+++ b/photon-targeting/src/main/java/org/photonvision/targeting/proto/PhotonTrackedTargetProto.java
@@ -81,7 +81,9 @@ public void pack(ProtobufPhotonTrackedTarget msg, PhotonTrackedTarget value) {
                 .setSkew(value.getSkew())
                 .setArea(value.getArea())
                 .setFiducialId(value.getFiducialId())
-                .setPoseAmbiguity(value.getPoseAmbiguity());
+                .setPoseAmbiguity(value.getPoseAmbiguity())
+                .setObjDetectionConf(value.getDetectedObjectConfidence())
+                .setObjDetectionId(value.getDetectedObjectClassID());
 
         Transform3d.proto.pack(msg.getMutableBestCameraToTarget(), value.getBestCameraToTarget());
         Transform3d.proto.pack(msg.getMutableAltCameraToTarget(), value.getAlternateCameraToTarget());
diff --git a/photon-targeting/src/main/native/cpp/photon/targeting/proto/MultiTargetPNPResultProto.cpp b/photon-targeting/src/main/native/cpp/photon/targeting/proto/MultiTargetPNPResultProto.cpp
index 0bd08c1cee..cc67ec213f 100644
--- a/photon-targeting/src/main/native/cpp/photon/targeting/proto/MultiTargetPNPResultProto.cpp
+++ b/photon-targeting/src/main/native/cpp/photon/targeting/proto/MultiTargetPNPResultProto.cpp
@@ -17,6 +17,8 @@
 
 #include "photon/targeting/proto/MultiTargetPNPResultProto.h"
 
+#include <vector>
+
 #include "photon.pb.h"
 #include "photon/targeting/proto/PNPResultProto.h"
 
diff --git a/photon-targeting/src/test/native/cpp/PacketTest.cpp b/photon-targeting/src/test/native/cpp/PacketTest.cpp
index 0fb5697029..5398fae4c1 100644
--- a/photon-targeting/src/test/native/cpp/PacketTest.cpp
+++ b/photon-targeting/src/test/native/cpp/PacketTest.cpp
@@ -16,6 +16,7 @@
  */
 
 #include <chrono>
+#include <vector>
 
 #include <units/angle.h>
 
diff --git a/photonlib-python-examples/aimandrange/robot.py b/photonlib-python-examples/aimandrange/robot.py
index 617f0ccbad..9afa3b3551 100644
--- a/photonlib-python-examples/aimandrange/robot.py
+++ b/photonlib-python-examples/aimandrange/robot.py
@@ -25,8 +25,6 @@
 
 import math
 import wpilib
-import wpimath
-import wpimath.geometry
 import drivetrain
 
 from photonlibpy import PhotonCamera
diff --git a/photonlib-python-examples/aimandrange/tests/pyfrc_test.py b/photonlib-python-examples/aimandrange/tests/pyfrc_test.py
index e195147143..235b61fa34 100644
--- a/photonlib-python-examples/aimandrange/tests/pyfrc_test.py
+++ b/photonlib-python-examples/aimandrange/tests/pyfrc_test.py
@@ -2,5 +2,3 @@
     This test module imports tests that come with pyfrc, and can be used
     to test basic functionality of just about any robot.
 """
-
-from pyfrc.tests import *
diff --git a/photonlib-python-examples/aimattarget/tests/pyfrc_test.py b/photonlib-python-examples/aimattarget/tests/pyfrc_test.py
index e195147143..235b61fa34 100644
--- a/photonlib-python-examples/aimattarget/tests/pyfrc_test.py
+++ b/photonlib-python-examples/aimattarget/tests/pyfrc_test.py
@@ -2,5 +2,3 @@
     This test module imports tests that come with pyfrc, and can be used
     to test basic functionality of just about any robot.
 """
-
-from pyfrc.tests import *
diff --git a/photonlib-python-examples/poseest/tests/pyfrc_test.py b/photonlib-python-examples/poseest/tests/pyfrc_test.py
index e195147143..235b61fa34 100644
--- a/photonlib-python-examples/poseest/tests/pyfrc_test.py
+++ b/photonlib-python-examples/poseest/tests/pyfrc_test.py
@@ -2,5 +2,3 @@
     This test module imports tests that come with pyfrc, and can be used
     to test basic functionality of just about any robot.
 """
-
-from pyfrc.tests import *
diff --git a/scripts/catnt.py b/scripts/catnt.py
new file mode 100644
index 0000000000..8010e68411
--- /dev/null
+++ b/scripts/catnt.py
@@ -0,0 +1,90 @@
+from time import sleep
+import ntcore
+import argparse
+from tabulate import tabulate
+
+
+def list_topics(inst: ntcore.NetworkTableInstance, root: str):
+    topics = inst.getTable(root).getTopics()
+    subtables = inst.getTable(root).getSubTables()
+
+    print(f"Topics under {root}")
+    print(
+        tabulate(
+            [
+                [topic.getName(), topic.getType().name, topic.getTypeString()]
+                for topic in topics
+            ],
+            headers=["Topic Name", "Type", "Type String"],
+        )
+    )
+    print("")
+    print(f"Tables under {root}")
+    print(tabulate([[table] for table in subtables], headers=["Table Name"]))
+    print("")
+
+
+def print_topic(inst: ntcore.NetworkTableInstance, topic: str):
+    sub = inst.getTopic(topic).genericSubscribe(
+        options=ntcore.PubSubOptions(sendAll=True, pollStorage=20)
+    )
+    print("")
+    print(f"Subscribed to {topic}, typestring '{sub.getTopic().getTypeString()}'")
+    print(f"Properties:")
+    print(sub.getTopic().getProperties())
+    print("")
+
+    start_time = ntcore._now()
+    count = 0
+    while True:
+        now = ntcore._now()
+        new_count = len(sub.readQueue())
+        count = count + new_count
+
+        hz = count / float(max(now - start_time, 0.1) * 1e-6)
+
+        print(f"{topic} = {sub.get().value()} (rate={hz:.1f}hz, samples={count})")
+        sleep(1)
+
+
+def connect(inst: ntcore.NetworkTableInstance, server: str):
+    inst.stopServer()
+    inst.setServer(server)
+    inst.startClient4("catnt")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Cat a topic")
+    parser.add_argument(
+        "--echo", type=str, help="Fully qualified topic name", required=False
+    )
+    parser.add_argument(
+        "--server",
+        type=str,
+        default="127.0.0.1",
+        help="IP address of the NT4 server",
+        required=False,
+    )
+    parser.add_argument("--list", help="List all topics", required=False)
+
+    args = parser.parse_args()
+    inst = ntcore.NetworkTableInstance.getDefault()
+
+    connect(inst, args.server)
+    # retained to keep the subscriber alive
+    topicNameSubscriber = ntcore.MultiSubscriber(
+        inst, ["/"], ntcore.PubSubOptions(topicsOnly=True)
+    )
+    sleep(1)
+
+    while not inst.isConnected():
+        sleep(0.1)
+
+    if args.list:
+        list_topics(inst, args.list)
+    if args.echo:
+        print_topic(inst, args.echo)
+
+
+if __name__ == "__main__":
+    main()

From a0c85fc95f5406e62ef37df09613855c9b42a47f Mon Sep 17 00:00:00 2001
From: Matt <matthew.morley.ca@gmail.com>
Date: Mon, 23 Sep 2024 22:44:09 -0400
Subject: [PATCH 4/7] Create photon-targeting-JNI framework (#1428)

Initial framework for adding JNI libraries. Auto generated JNI headers and sticks native libraries into the JAR (and adds to class path for testing)
---
 .github/workflows/build.yml                   |   6 +-
 README.md                                     |   2 +
 build.gradle                                  |   3 +
 .../common/hardware/PlatformUtils.java        |  54 +++++++++
 .../common/networking/NetworkManager.java     |   3 +-
 photon-lib/build.gradle                       |  25 +++++
 photon-server/build.gradle                    |   4 +-
 photon-targeting/build.gradle                 | 104 ++++++++++++++++--
 .../common/hardware/Platform.java             |  31 ------
 9 files changed, 183 insertions(+), 49 deletions(-)
 create mode 100644 photon-core/src/main/java/org/photonvision/common/hardware/PlatformUtils.java
 rename {photon-core => photon-targeting}/src/main/java/org/photonvision/common/hardware/Platform.java (90%)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6c7e710ebb..7d342d07cb 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -160,14 +160,14 @@ jobs:
       - run: git fetch --tags --force
       - run: |
           chmod +x gradlew
-          ./gradlew photon-targeting:build photon-lib:build -Pbuildalldesktop -i
-      - run: ./gradlew photon-lib:publish photon-targeting:publish -Pbuildalldesktop
+          ./gradlew photon-targeting:build photon-lib:build -i
+      - run: ./gradlew photon-lib:publish photon-targeting:publish
         name: Publish
         env:
           ARTIFACTORY_API_KEY: ${{ secrets.ARTIFACTORY_API_KEY }}
         if: github.event_name == 'push' && github.repository_owner == 'photonvision'
       # Copy artifacts to build/outputs/maven
-      - run: ./gradlew photon-lib:publish photon-targeting:publish -PcopyOfflineArtifacts -Pbuildalldesktop
+      - run: ./gradlew photon-lib:publish photon-targeting:publish -PcopyOfflineArtifacts
       - uses: actions/upload-artifact@v4
         with:
           name: maven-${{ matrix.artifact-name }}
diff --git a/README.md b/README.md
index c559bb963c..475d386054 100644
--- a/README.md
+++ b/README.md
@@ -40,6 +40,8 @@ Note that these are case sensitive!
 - `-PtgtIP`: Specifies where `./gradlew deploy` should try to copy the fat JAR to
 - `-Pprofile`: enables JVM profiling
 
+If you're cross-compiling, you'll need the wpilib toolchain installed. This can be done via Gradle: for example `./gradlew installArm64Toolchain` or `./gradlew installRoboRioToolchain`
+
 ## Out-of-Source Dependencies
 
 PhotonVision uses the following additonal out-of-source repositories for building code.
diff --git a/build.gradle b/build.gradle
index 4ba2dad4cc..18aac2cc63 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,12 +1,15 @@
 import edu.wpi.first.toolchain.*
 
 plugins {
+    id "java"
+    id "cpp"
     id "com.diffplug.spotless" version "6.24.0"
     id "edu.wpi.first.NativeUtils" version "2024.6.1" apply false
     id "edu.wpi.first.wpilib.repositories.WPILibRepositoriesPlugin" version "2020.2"
     id "edu.wpi.first.GradleRIO" version "2024.3.2"
     id 'edu.wpi.first.WpilibTools' version '1.3.0'
     id 'com.google.protobuf' version '0.9.4' apply false
+    id 'edu.wpi.first.GradleJni' version '1.1.0'
 }
 
 allprojects {
diff --git a/photon-core/src/main/java/org/photonvision/common/hardware/PlatformUtils.java b/photon-core/src/main/java/org/photonvision/common/hardware/PlatformUtils.java
new file mode 100644
index 0000000000..c5bee8d20a
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/common/hardware/PlatformUtils.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.common.hardware;
+
+import java.io.IOException;
+import org.photonvision.common.util.ShellExec;
+
+@SuppressWarnings("unused")
+public class PlatformUtils {
+    private static final ShellExec shell = new ShellExec(true, false);
+    private static final boolean isRoot = checkForRoot();
+
+    @SuppressWarnings("StatementWithEmptyBody")
+    private static boolean checkForRoot() {
+        if (Platform.isLinux()) {
+            try {
+                shell.executeBashCommand("id -u");
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            while (!shell.isOutputCompleted()) {
+                // TODO: add timeout
+            }
+
+            if (shell.getExitCode() == 0) {
+                return shell.getOutput().split("\n")[0].equals("0");
+            }
+
+        } else {
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean isRoot() {
+        return isRoot;
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/common/networking/NetworkManager.java b/photon-core/src/main/java/org/photonvision/common/networking/NetworkManager.java
index 0ce9b169c5..47b6540708 100644
--- a/photon-core/src/main/java/org/photonvision/common/networking/NetworkManager.java
+++ b/photon-core/src/main/java/org/photonvision/common/networking/NetworkManager.java
@@ -24,6 +24,7 @@
 import org.photonvision.common.dataflow.DataChangeSource;
 import org.photonvision.common.dataflow.events.DataChangeEvent;
 import org.photonvision.common.hardware.Platform;
+import org.photonvision.common.hardware.PlatformUtils;
 import org.photonvision.common.logging.LogGroup;
 import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.ShellExec;
@@ -54,7 +55,7 @@ public void initialize(boolean shouldManage) {
         var config = ConfigManager.getInstance().getConfig().getNetworkConfig();
         logger.info("Setting " + config.connectionType + " with team " + config.ntServerAddress);
         if (Platform.isLinux()) {
-            if (!Platform.isRoot()) {
+            if (!PlatformUtils.isRoot()) {
                 logger.error("Cannot manage hostname without root!");
             }
 
diff --git a/photon-lib/build.gradle b/photon-lib/build.gradle
index 455bde947d..6b9d1f04e3 100644
--- a/photon-lib/build.gradle
+++ b/photon-lib/build.gradle
@@ -1,3 +1,7 @@
+plugins {
+    id 'edu.wpi.first.WpilibTools' version '1.3.0'
+}
+
 import java.nio.file.Path
 
 ext {
@@ -314,3 +318,24 @@ publishing {
         }
     }
 }
+
+// setup wpilib bundled native libs
+wpilibTools.deps.wpilibVersion = wpi.versions.wpilibVersion.get()
+
+def nativeConfigName = 'wpilibNatives'
+def nativeConfig = configurations.create(nativeConfigName)
+
+def nativeTasks = wpilibTools.createExtractionTasks {
+    configurationName = nativeConfigName
+}
+
+nativeTasks.addToSourceSetResources(sourceSets.test)
+
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("wpimath")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("wpinet")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("wpiutil")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("ntcore")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("cscore")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("apriltag")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("hal")
+nativeConfig.dependencies.add wpilibTools.deps.wpilibOpenCv("frc" + wpi.frcYear.get(), wpi.versions.opencvVersion.get())
diff --git a/photon-server/build.gradle b/photon-server/build.gradle
index 7c8c2ba078..2515d65b9e 100644
--- a/photon-server/build.gradle
+++ b/photon-server/build.gradle
@@ -47,9 +47,7 @@ tasks.register("buildAndCopyUI") {
 
 run {
     environment "PATH_PREFIX", "../"
-}
 
-run {
     if (project.hasProperty("profile")) {
         jvmArgs=[
             "-Dcom.sun.management.jmxremote=true",
@@ -105,7 +103,7 @@ task findDeployTarget {
 
 task deploy {
     dependsOn findDeployTarget
-    dependsOn assemble
+    dependsOn 'shadowJar'
 
     doLast {
         println 'Starting deployment to ' + findDeployTarget.rmt.host
diff --git a/photon-targeting/build.gradle b/photon-targeting/build.gradle
index a00897e23e..da7dde2d00 100644
--- a/photon-targeting/build.gradle
+++ b/photon-targeting/build.gradle
@@ -1,3 +1,7 @@
+plugins {
+    id 'edu.wpi.first.WpilibTools' version '1.3.0'
+}
+
 ext {
     nativeName = "photontargeting"
 }
@@ -5,6 +9,7 @@ ext {
 apply plugin: 'cpp'
 apply plugin: 'google-test-test-suite'
 apply plugin: 'edu.wpi.first.NativeUtils'
+apply plugin: 'edu.wpi.first.GradleJni'
 
 apply from: "${rootDir}/shared/config.gradle"
 apply from: "${rootDir}/shared/javacommon.gradle"
@@ -19,6 +24,20 @@ nativeUtils {
 
 sourceSets.main.java.srcDir "${projectDir}/src/generated/main/java"
 
+// Folder whose contents will be included in the final jar
+def outputsFolder = file("$buildDir/extra_resources")
+
+// Sync task: like the copy task, but all files that exist in the destination directory will be deleted before copying files
+task syncOutputsFolder(type: Sync) {
+    into outputsFolder
+}
+
+// And package our outputs folder into the final jar
+jar {
+    from outputsFolder
+    dependsOn syncOutputsFolder
+}
+
 model {
     components {
         "${nativeName}"(NativeLibrarySpec) {
@@ -42,14 +61,59 @@ model {
                 it.tasks.withType(CppCompile) {
                     it.dependsOn generateProto
                 }
-                if(project.hasProperty('includePhotonTargeting')) {
-                    lib project: ':photon-targeting', library: 'photontargeting', linkage: 'shared'
+            }
+
+            nativeUtils.useRequiredLibrary(it, "wpiutil_shared")
+            nativeUtils.useRequiredLibrary(it, "wpimath_shared")
+            nativeUtils.useRequiredLibrary(it, "wpinet_shared")
+            nativeUtils.useRequiredLibrary(it, "wpilibc_shared")
+            nativeUtils.useRequiredLibrary(it, "ntcore_shared")
+        }
+        "${nativeName}JNI"(JniNativeLibrarySpec) {
+
+            enableCheckTask project.hasProperty('doJniCheck')
+            javaCompileTasks << compileJava
+            jniCrossCompileOptions << JniCrossCompileOptions(nativeUtils.wpi.platforms.roborio)
+            jniCrossCompileOptions << JniCrossCompileOptions(nativeUtils.wpi.platforms.linuxarm32)
+            jniCrossCompileOptions << JniCrossCompileOptions(nativeUtils.wpi.platforms.linuxarm64)
+
+            sources {
+                cpp {
+                    source {
+                        srcDirs 'src/main/native/jni'
+                        include '**/*.cpp', '**/*.cc'
+                    }
                 }
             }
 
-            nativeUtils.useRequiredLibrary(it, "wpilib_shared")
-            nativeUtils.useRequiredLibrary(it, "apriltag_shared")
-            nativeUtils.useRequiredLibrary(it, "opencv_shared")
+            binaries.all {
+                lib library: nativeName, linkage: 'shared'
+            }
+
+            nativeUtils.useRequiredLibrary(it, "wpiutil_shared")
+            nativeUtils.useRequiredLibrary(it, "wpinet_shared")
+            nativeUtils.useRequiredLibrary(it, "ntcore_shared")
+        }
+
+        all {
+            binaries.withType(SharedLibraryBinarySpec) { binary ->
+                // check that we're building for the platform (per PArchOverride/wpilib plat detection)
+                if (binary.targetPlatform.name == jniPlatform) {
+
+                    // only include release binaries (hard coded for now)
+                    def isDebug = binary.buildType.name.contains('debug')
+                    if (!isDebug) {
+                        syncOutputsFolder {
+                            // Just shove the shared library into the root of the jar output by photon-targeting:jar
+                            from(binary.sharedLibraryFile) {
+                                into "nativelibraries/${wpilibNativeName}/"
+                            }
+                            // And (not sure if this is a hack) make the jar task depend on the build task
+                            dependsOn binary.identifier.projectScopedName
+                        }
+                    }
+                }
+            }
         }
     }
     testSuites {
@@ -76,17 +140,11 @@ model {
                 it.tasks.withType(CppCompile) {
                     it.dependsOn generateProto
                 }
-                if(project.hasProperty('includePhotonTargeting')) {
-                    lib project: ':photon-targeting', library: 'photontargeting', linkage: 'shared'
-                }
             }
 
-            nativeUtils.useRequiredLibrary(it, "cscore_shared")
-            nativeUtils.useRequiredLibrary(it, "cameraserver_shared")
             nativeUtils.useRequiredLibrary(it, "wpilib_executable_shared")
             nativeUtils.useRequiredLibrary(it, "googletest_static")
             nativeUtils.useRequiredLibrary(it, "apriltag_shared")
-            nativeUtils.useRequiredLibrary(it, "opencv_shared")
         }
     }
 
@@ -129,3 +187,27 @@ cppHeadersZip {
         into '/'
     }
 }
+
+// make sure native libraries can be loaded in tests
+test {
+    classpath += files(outputsFolder)
+    dependsOn syncOutputsFolder
+}
+
+// setup wpilib bundled native libs
+wpilibTools.deps.wpilibVersion = wpi.versions.wpilibVersion.get()
+
+def nativeConfigName = 'wpilibNatives'
+def nativeConfig = configurations.create(nativeConfigName)
+
+def nativeTasks = wpilibTools.createExtractionTasks {
+    configurationName = nativeConfigName
+}
+
+nativeTasks.addToSourceSetResources(sourceSets.test)
+
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("wpiutil")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("wpimath")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("wpinet")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("ntcore")
+nativeConfig.dependencies.add wpilibTools.deps.wpilib("hal")
diff --git a/photon-core/src/main/java/org/photonvision/common/hardware/Platform.java b/photon-targeting/src/main/java/org/photonvision/common/hardware/Platform.java
similarity index 90%
rename from photon-core/src/main/java/org/photonvision/common/hardware/Platform.java
rename to photon-targeting/src/main/java/org/photonvision/common/hardware/Platform.java
index 57f1eab868..e2d0155609 100644
--- a/photon-core/src/main/java/org/photonvision/common/hardware/Platform.java
+++ b/photon-targeting/src/main/java/org/photonvision/common/hardware/Platform.java
@@ -17,13 +17,11 @@
 
 package org.photonvision.common.hardware;
 
-import com.jogamp.common.os.Platform.OSType;
 import edu.wpi.first.util.RuntimeDetector;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
-import org.photonvision.common.util.ShellExec;
 
 @SuppressWarnings("unused")
 public enum Platform {
@@ -63,7 +61,6 @@ private enum OSType {
         UNKNOWN
     }
 
-    private static final ShellExec shell = new ShellExec(true, false);
     public final String description;
     public final String nativeLibraryFolderName;
     public final boolean isPi;
@@ -72,7 +69,6 @@ private enum OSType {
 
     // Set once at init, shouldn't be needed after.
     private static final Platform currentPlatform = getCurrentPlatform();
-    private static final boolean isRoot = checkForRoot();
 
     Platform(
             String description,
@@ -115,10 +111,6 @@ public static String getNativeLibraryFolderName() {
         return currentPlatform.nativeLibraryFolderName;
     }
 
-    public static boolean isRoot() {
-        return isRoot;
-    }
-
     public static boolean isSupported() {
         return currentPlatform.isSupported;
     }
@@ -131,29 +123,6 @@ public static boolean isSupported() {
     private static final String UnknownPlatformString =
             String.format("Unknown Platform. OS: %s, Architecture: %s", OS_NAME, OS_ARCH);
 
-    @SuppressWarnings("StatementWithEmptyBody")
-    private static boolean checkForRoot() {
-        if (isLinux()) {
-            try {
-                shell.executeBashCommand("id -u");
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
-
-            while (!shell.isOutputCompleted()) {
-                // TODO: add timeout
-            }
-
-            if (shell.getExitCode() == 0) {
-                return shell.getOutput().split("\n")[0].equals("0");
-            }
-
-        } else {
-            return true;
-        }
-        return false;
-    }
-
     private static Platform getCurrentPlatform() {
         if (RuntimeDetector.isWindows()) {
             if (RuntimeDetector.is32BitIntel()) {

From a8daff3ed4e3220e41dad70ea23e75f9729f082f Mon Sep 17 00:00:00 2001
From: Chris Gerth <gerth2@users.noreply.github.com>
Date: Tue, 24 Sep 2024 00:02:16 -0500
Subject: [PATCH 5/7] Revised 9782 defaults (#1431)

revised order to prevent some randomness around init
---
 .../org/photonvision/vision/camera/QuirkyCamera.java     | 6 ++++--
 .../camera/USBCameras/ArduOV9782CameraSettables.java     | 9 +++++++++
 .../camera/USBCameras/GenericUSBCameraSettables.java     | 1 -
 .../USBCameras/LifeCam3kWindowsCameraSettables.java      | 1 +
 .../vision/camera/USBCameras/PsEyeCameraSettables.java   | 2 ++
 5 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/QuirkyCamera.java b/photon-core/src/main/java/org/photonvision/vision/camera/QuirkyCamera.java
index 2eb1982fd9..5debd40108 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/QuirkyCamera.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/QuirkyCamera.java
@@ -55,6 +55,7 @@ public class QuirkyCamera {
                             "",
                             "Arducam Generic",
                             CameraQuirk.ArduCamCamera,
+                            CameraQuirk.Gain,
                             CameraQuirk.StickyFPS),
                     // Arducam OV2311
                     new QuirkyCamera(
@@ -73,17 +74,18 @@ public class QuirkyCamera {
                             "OV9281",
                             CameraQuirk.ArduCamCamera,
                             CameraQuirk.ArduOV9281Controls),
-                    // Arducam OV
+                    // Arducam OV9782
                     new QuirkyCamera(
                             0x0c45,
                             0x6366,
                             "OV9782",
                             "OV9782",
                             CameraQuirk.ArduCamCamera,
+                            CameraQuirk.Gain,
                             CameraQuirk.ArduOV9782Controls),
                     // Innomaker OV9281
                     new QuirkyCamera(
-                            0x0c45, 0x636d, "USB Camera", "USB Camera", CameraQuirk.InnoOV9281Controls));
+                            0x0c45, 0x636d, "USB Camera", "Innomaker OV9281", CameraQuirk.InnoOV9281Controls));
 
     public static final QuirkyCamera DefaultCamera = new QuirkyCamera(0, 0, "");
     public static final QuirkyCamera ZeroCopyPiCamera =
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/ArduOV9782CameraSettables.java b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/ArduOV9782CameraSettables.java
index caf8036894..70fdbf9e1d 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/ArduOV9782CameraSettables.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/ArduOV9782CameraSettables.java
@@ -26,6 +26,15 @@ public ArduOV9782CameraSettables(CameraConfiguration configuration, UsbCamera ca
         whiteBalanceTemperature = 3500;
     }
 
+    @Override
+    public void setAllCamDefaults() {
+        softSet("power_line_frequency", 2); // Assume 60Hz USA
+        softSet("exposure_metering_mode", 0);
+        softSet("exposure_dynamic_framerate", 0);
+        softSet("white_balance_automatic", 0);
+        softSet("white_balance_temperature", whiteBalanceTemperature);
+    }
+
     @Override
     protected void setUpExposureProperties() {
         super.setUpExposureProperties();
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/GenericUSBCameraSettables.java b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/GenericUSBCameraSettables.java
index e83fe11b50..818b567df3 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/GenericUSBCameraSettables.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/GenericUSBCameraSettables.java
@@ -100,7 +100,6 @@ public void setAllCamDefaults() {
         softSet("exposure_dynamic_framerate", 0);
         softSet("focus_auto", 0);
         softSet("focus_absolute", 0); // Focus into infinity
-        softSet("white_balance_temperature", whiteBalanceTemperature);
     }
 
     public void setAutoExposure(boolean cameraAutoExposure) {
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/LifeCam3kWindowsCameraSettables.java b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/LifeCam3kWindowsCameraSettables.java
index ef4a3029cd..b52dbd84de 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/LifeCam3kWindowsCameraSettables.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/LifeCam3kWindowsCameraSettables.java
@@ -61,6 +61,7 @@ public void setExposureRaw(double exposureRaw) {
         }
     }
 
+    @Override
     public void setAutoExposure(boolean cameraAutoExposure) {
         logger.debug("Setting auto exposure to " + cameraAutoExposure);
 
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/PsEyeCameraSettables.java b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/PsEyeCameraSettables.java
index 8195ca4931..50e06916d0 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/PsEyeCameraSettables.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/PsEyeCameraSettables.java
@@ -25,6 +25,7 @@ public PsEyeCameraSettables(CameraConfiguration configuration, UsbCamera camera)
         super(configuration, camera);
     }
 
+    @Override
     public void setAutoExposure(boolean cameraAutoExposure) {
         logger.debug("Setting auto exposure to " + cameraAutoExposure);
 
@@ -42,6 +43,7 @@ public void setAutoExposure(boolean cameraAutoExposure) {
         }
     }
 
+    @Override
     public void setAllCamDefaults() {
         // Common settings for all cameras to attempt to get their image
         // as close as possible to what we want for image processing

From b7cab0431dc02235f14385b7cb0a33f56ca57099 Mon Sep 17 00:00:00 2001
From: Banks T <btrout.dhrs@gmail.com>
Date: Tue, 24 Sep 2024 19:18:59 -0400
Subject: [PATCH 6/7] See3Cam_24CUG Quirks (#1302)

Co-authored-by: Matt <matthew.morley.ca@gmail.com>
Co-authored-by: Chris Gerth <chrisgerth010592@gmail.com>
---
 .../vision/camera/CameraQuirk.java            |  7 +++-
 .../vision/camera/QuirkyCamera.java           |  3 ++
 .../USBCameras/See3Cam24CUGSettables.java     | 39 +++++++++++++++++++
 .../camera/USBCameras/USBCameraSource.java    |  2 +
 4 files changed, 49 insertions(+), 2 deletions(-)
 create mode 100644 photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/See3Cam24CUGSettables.java

diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/CameraQuirk.java b/photon-core/src/main/java/org/photonvision/vision/camera/CameraQuirk.java
index 9258c53b42..cd96d1d00a 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/CameraQuirk.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/CameraQuirk.java
@@ -45,8 +45,11 @@ public enum CameraQuirk {
     ArduOV2311Controls,
     ArduOV9782Controls,
     /**
-     * Camera is innomaker USB OV9281 which also has incorrect v4l exposure times Real range is more
-     * like 0-500
+     * Camera is one brand of USB OV9281 which also has incorrect v4l exposure times Real range is
+     * more like 0-500
      */
     InnoOV9281Controls,
+    ArduOV9782,
+    /** Camera has odd exposure range, and supports gain control */
+    See3Cam_24CUG,
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/QuirkyCamera.java b/photon-core/src/main/java/org/photonvision/vision/camera/QuirkyCamera.java
index 5debd40108..1f927d4c9c 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/QuirkyCamera.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/QuirkyCamera.java
@@ -28,6 +28,9 @@
 public class QuirkyCamera {
     private static final List<QuirkyCamera> quirkyCameras =
             List.of(
+                    // SeeCam, which has an odd exposure range
+                    new QuirkyCamera(
+                            0x2560, 0xc128, "See3Cam_24CUG", CameraQuirk.Gain, CameraQuirk.See3Cam_24CUG),
                     // Chris's older generic "Logitec HD Webcam"
                     new QuirkyCamera(0x9331, 0x5A3, CameraQuirk.CompletelyBroken),
                     // Logitec C270
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/See3Cam24CUGSettables.java b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/See3Cam24CUGSettables.java
new file mode 100644
index 0000000000..26f3f94d71
--- /dev/null
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/See3Cam24CUGSettables.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) Photon Vision.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.photonvision.vision.camera.USBCameras;
+
+import edu.wpi.first.cscore.UsbCamera;
+import org.photonvision.common.configuration.CameraConfiguration;
+
+/*
+ * This class holds the camera quirks for the See3Cam 24UGS.
+ */
+public class See3Cam24CUGSettables extends GenericUSBCameraSettables {
+    public See3Cam24CUGSettables(CameraConfiguration configuration, UsbCamera camera) {
+        super(configuration, camera);
+    }
+
+    @Override
+    protected void setUpExposureProperties() {
+        super.setUpExposureProperties();
+
+        // Property limits are incorrect
+        this.minExposure = 0;
+        this.maxExposure = 600;
+    }
+}
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/USBCameraSource.java b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/USBCameraSource.java
index aefb092a42..dd655a370f 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/USBCameraSource.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/USBCameras/USBCameraSource.java
@@ -139,6 +139,8 @@ protected GenericUSBCameraSettables createSettables(
             settables = new ArduOV9782CameraSettables(config, camera);
         } else if (quirks.hasQuirk(CameraQuirk.InnoOV9281Controls)) {
             settables = new InnoOV9281CameraSettables(config, camera);
+        } else if (quirks.hasQuirk(CameraQuirk.See3Cam_24CUG)) {
+            settables = new See3Cam24CUGSettables(config, camera);
         } else {
             logger.debug("Using Generic USB Cam Settables");
             settables = new GenericUSBCameraSettables(config, camera);

From 354f11a6d61511beee8d6b2362e79f3d2b01600c Mon Sep 17 00:00:00 2001
From: Chris Gerth <gerth2@users.noreply.github.com>
Date: Tue, 24 Sep 2024 18:19:49 -0500
Subject: [PATCH 7/7] Fix broken links (#1430)

---
 docs/source/docs/examples/poseest.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/source/docs/examples/poseest.md b/docs/source/docs/examples/poseest.md
index 3d10e6c875..ffa9710591 100644
--- a/docs/source/docs/examples/poseest.md
+++ b/docs/source/docs/examples/poseest.md
@@ -1,8 +1,8 @@
 # Using WPILib Pose Estimation, Simulation, and PhotonVision Together
 
-The following example comes from the PhotonLib example repository ([Java](https://github.com/gerth2/photonvision/tree/master/photonlib-java-examples/poseest)/[C++](https://github.com/gerth2/photonvision/tree/master/photonlib-cpp-examples/poseest)/[Python](https://github.com/gerth2/photonvision/tree/master/photonlib-python-examples/poseest)).  Full code is available at that links.
+The following example comes from the PhotonLib example repository ([Java](https://github.com/PhotonVision/photonvision/tree/master/photonlib-java-examples/poseest)/[C++](https://github.com/PhotonVision/photonvision/tree/master/photonlib-cpp-examples/poseest)/[Python](https://github.com/PhotonVision/photonvision/tree/master/photonlib-python-examples/poseest)).  Full code is available at that links.
 
-## Knowledge and Equipment Needed
+## Knowledge and Equipment Needed 
 
 - Everything required in {ref}`Combining Aiming and Getting in Range <docs/examples/aimandrange:Knowledge and Equipment Needed>`, plus some familiarity with WPILib pose estimation functionality.