Backport maven changes

photon-client/src/components/dashboard/tabs/ObjectDetectionTab.vue

@@ -11,16 +11,6 @@ const currentPipelineSettings = computed<ActivePipelineSettings>(
   () => useCameraSettingsStore().currentPipelineSettings
 );
 
-// TODO fix pv-range-slider so that store access doesn't need to be deferred
-const contourArea = computed<[number, number]>({
-  get: () => Object.values(useCameraSettingsStore().currentPipelineSettings.contourArea) as [number, number],
-  set: (v) => (useCameraSettingsStore().currentPipelineSettings.contourArea = v)
-});
-const contourRatio = computed<[number, number]>({
-  get: () => Object.values(useCameraSettingsStore().currentPipelineSettings.contourRatio) as [number, number],
-  set: (v) => (useCameraSettingsStore().currentPipelineSettings.contourRatio = v)
-});
-
 const interactiveCols = computed(() =>
   (getCurrentInstance()?.proxy.$vuetify.breakpoint.mdAndDown || false) &&
   (!useStateStore().sidebarFolded || useCameraSettingsStore().isDriverMode)
@@ -42,42 +32,5 @@ const interactiveCols = computed(() =>
       :step="0.01"
       @input="(value) => useCameraSettingsStore().changeCurrentPipelineSetting({ confidence: value }, false)"
     />
-    <pv-range-slider
-      v-model="contourArea"
-      label="Area"
-      :min="0"
-      :max="100"
-      :slider-cols="interactiveCols"
-      :step="0.01"
-      @input="(value) => useCameraSettingsStore().changeCurrentPipelineSetting({ contourArea: value }, false)"
-    />
-    <pv-range-slider
-      v-model="contourRatio"
-      label="Ratio (W/H)"
-      tooltip="Min and max ratio between the width and height of a contour's bounding rectangle"
-      :min="0"
-      :max="100"
-      :slider-cols="interactiveCols"
-      :step="0.01"
-      @input="(value) => useCameraSettingsStore().changeCurrentPipelineSetting({ contourRatio: value }, false)"
-    />
-    <pv-select
-      v-model="useCameraSettingsStore().currentPipelineSettings.contourTargetOrientation"
-      label="Target Orientation"
-      tooltip="Used to determine how to calculate target landmarks, as well as aspect ratio"
-      :items="['Portrait', 'Landscape']"
-      :select-cols="interactiveCols"
-      @input="
-        (value) => useCameraSettingsStore().changeCurrentPipelineSetting({ contourTargetOrientation: value }, false)
-      "
-    />
-    <pv-select
-      v-model="currentPipelineSettings.contourSortMode"
-      label="Target Sort"
-      tooltip="Chooses the sorting mode used to determine the 'best' targets to provide to user code"
-      :select-cols="interactiveCols"
-      :items="['Largest', 'Smallest', 'Highest', 'Lowest', 'Rightmost', 'Leftmost', 'Centermost']"
-      @input="(value) => useCameraSettingsStore().changeCurrentPipelineSetting({ contourSortMode: value }, false)"
-    />
   </div>
 </template>

photon-core/src/main/java/org/photonvision/vision/opencv/Contour.java

@@ -47,16 +47,6 @@ public class Contour implements Releasable {
         this.mat = mat;
     }
 
-    public Contour(Rect2d box) {
-        // no easy way to convert a Rect2d to Mat, diy it. Order is tl tr br bl
-        this.mat =
-                new MatOfPoint(
-                        box.tl(),
-                        new Point(box.x + box.width, box.y),
-                        box.br(),
-                        new Point(box.x, box.y + box.height));
-    }
-
     public MatOfPoint2f getMat2f() {
         if (mat2f == null) {
             mat2f = new MatOfPoint2f(mat.toArray());

photon-core/src/main/java/org/photonvision/vision/opencv/ContourSortMode.java

@@ -25,15 +25,15 @@ public enum ContourSortMode {
             Comparator.comparingDouble(PotentialTarget::getArea)
                     .reversed()), // reversed so that zero index has the largest size
     Smallest(Largest.getComparator().reversed()),
-    Highest(Comparator.comparingDouble(tgt -> tgt.getMinAreaRect().center.y)),
+    Highest(Comparator.comparingDouble(rect -> rect.getMinAreaRect().center.y)),
     Lowest(Highest.getComparator().reversed()),
-    Leftmost(Comparator.comparingDouble(tgt -> tgt.getMinAreaRect().center.x * -1)),
+    Leftmost(Comparator.comparingDouble(target -> target.getMinAreaRect().center.x * -1)),
     Rightmost(Leftmost.getComparator().reversed()),
     Centermost(
             Comparator.comparingDouble(
-                    tgt ->
-                            (Math.pow(tgt.getMinAreaRect().center.y, 2)
-                                    + Math.pow(tgt.getMinAreaRect().center.x, 2))));
+                    rect ->
+                            (Math.pow(rect.getMinAreaRect().center.y, 2)
+                                    + Math.pow(rect.getMinAreaRect().center.x, 2))));
 
     private final Comparator<PotentialTarget> m_comparator;
 

photon-core/src/main/java/org/photonvision/vision/pipe/impl/FilterObjectDetectionsPipe.java

@@ -1,89 +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.util.ArrayList;
-import java.util.List;
-import org.photonvision.common.util.numbers.DoubleCouple;
-import org.photonvision.vision.frame.FrameStaticProperties;
-import org.photonvision.vision.pipe.CVPipe;
-
-public class FilterObjectDetectionsPipe
-        extends CVPipe<
-                List<NeuralNetworkPipeResult>,
-                List<NeuralNetworkPipeResult>,
-                FilterObjectDetectionsPipe.FilterContoursParams> {
-    List<NeuralNetworkPipeResult> m_filteredContours = new ArrayList<>();
-
-    @Override
-    protected List<NeuralNetworkPipeResult> process(List<NeuralNetworkPipeResult> in) {
-        m_filteredContours.clear();
-        for (var contour : in) {
-            filterContour(contour);
-        }
-
-        return m_filteredContours;
-    }
-
-    private void filterContour(NeuralNetworkPipeResult contour) {
-        var boc = contour.box;
-
-        // Area filtering
-        double areaPercentage = boc.area() / params.getFrameStaticProperties().imageArea * 100.0;
-        double minAreaPercentage = params.getArea().getFirst();
-        double maxAreaPercentage = params.getArea().getSecond();
-        if (areaPercentage < minAreaPercentage || areaPercentage > maxAreaPercentage) return;
-
-        // Aspect ratio filtering; much simpler since always axis-aligned
-        double aspectRatio = boc.width / boc.height;
-        if (aspectRatio < params.getRatio().getFirst() || aspectRatio > params.getRatio().getSecond())
-            return;
-
-        m_filteredContours.add(contour);
-    }
-
-    public static class FilterContoursParams {
-        private final DoubleCouple m_area;
-        private final DoubleCouple m_ratio;
-        private final FrameStaticProperties m_frameStaticProperties;
-        public final boolean isLandscape;
-
-        public FilterContoursParams(
-                DoubleCouple area,
-                DoubleCouple ratio,
-                FrameStaticProperties camProperties,
-                boolean isLandscape) {
-            this.m_area = area;
-            this.m_ratio = ratio;
-            this.m_frameStaticProperties = camProperties;
-            this.isLandscape = isLandscape;
-        }
-
-        public DoubleCouple getArea() {
-            return m_area;
-        }
-
-        public DoubleCouple getRatio() {
-            return m_ratio;
-        }
-
-        public FrameStaticProperties getFrameStaticProperties() {
-            return m_frameStaticProperties;
-        }
-    }
-}

photon-core/src/main/java/org/photonvision/vision/pipe/impl/SortContoursPipe.java

@@ -42,7 +42,6 @@ public class SortContoursPipe
             if (params.getSortMode() != ContourSortMode.Centermost) {
                 m_sortedContours.sort(params.getSortMode().getComparator());
             } else {
-                // we need knowledge of camera properties to calculate this distance -- do it ourselves
                 m_sortedContours.sort(Comparator.comparingDouble(this::calcSquareCenterDistance));
             }
         }
@@ -51,10 +50,10 @@ public class SortContoursPipe
                 m_sortedContours.subList(0, Math.min(in.size(), params.getMaxTargets())));
     }
 
-    private double calcSquareCenterDistance(PotentialTarget tgt) {
+    private double calcSquareCenterDistance(PotentialTarget rect) {
         return Math.sqrt(
-                Math.pow(params.getCamProperties().centerX - tgt.getMinAreaRect().center.x, 2)
-                        + Math.pow(params.getCamProperties().centerY - tgt.getMinAreaRect().center.y, 2));
+                Math.pow(params.getCamProperties().centerX - rect.getMinAreaRect().center.x, 2)
+                        + Math.pow(params.getCamProperties().centerY - rect.getMinAreaRect().center.y, 2));
     }
 
     public static class SortContoursParams {

photon-core/src/main/java/org/photonvision/vision/pipeline/CVPipeline.java

@@ -26,8 +26,6 @@ import org.photonvision.vision.pipeline.result.CVPipelineResult;
 
 public abstract class CVPipeline<R extends CVPipelineResult, S extends CVPipelineSettings>
         implements Releasable {
-    static final int MAX_MULTI_TARGET_RESULTS = 10;
-
     protected S settings;
     protected FrameStaticProperties frameStaticProperties;
     protected QuirkyCamera cameraQuirks;

photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipeline.java

@@ -109,7 +109,7 @@ public class ColoredShapePipeline
         SortContoursPipe.SortContoursParams sortContoursParams =
                 new SortContoursPipe.SortContoursParams(
                         settings.contourSortMode,
-                        settings.outputShowMultipleTargets ? MAX_MULTI_TARGET_RESULTS : 1,
+                        settings.outputShowMultipleTargets ? 5 : 1,
                         frameStaticProperties); // TODO don't hardcode?
         sortContoursPipe.setParams(sortContoursParams);
 

photon-core/src/main/java/org/photonvision/vision/pipeline/ObjectDetectionPipeline.java

@@ -17,26 +17,21 @@
 
 package org.photonvision.vision.pipeline;
 
+import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
 import org.photonvision.vision.frame.Frame;
 import org.photonvision.vision.frame.FrameThresholdType;
-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.pipeline.result.CVPipelineResult;
-import org.photonvision.vision.target.PotentialTarget;
-import org.photonvision.vision.target.TargetOrientation;
 import org.photonvision.vision.target.TrackedTarget;
+import org.photonvision.vision.target.TrackedTarget.TargetCalculationParameters;
 
 public class ObjectDetectionPipeline
         extends CVPipeline<CVPipelineResult, ObjectDetectionPipelineSettings> {
     private final CalculateFPSPipe calculateFPSPipe = new CalculateFPSPipe();
     private final RknnDetectionPipe rknnPipe = new RknnDetectionPipe();
-    private final SortContoursPipe sortContoursPipe = new SortContoursPipe();
-    private final Collect2dTargetsPipe collect2dTargetsPipe = new Collect2dTargetsPipe();
-    private final FilterObjectDetectionsPipe filterContoursPipe = new FilterObjectDetectionsPipe();
 
     private static final FrameThresholdType PROCESSING_TYPE = FrameThresholdType.NONE;
 
@@ -57,38 +52,6 @@ public class ObjectDetectionPipeline
         params.confidence = settings.confidence;
         params.nms = settings.nms;
         rknnPipe.setParams(params);
-
-        DualOffsetValues dualOffsetValues =
-                new DualOffsetValues(
-                        settings.offsetDualPointA,
-                        settings.offsetDualPointAArea,
-                        settings.offsetDualPointB,
-                        settings.offsetDualPointBArea);
-
-        SortContoursPipe.SortContoursParams sortContoursParams =
-                new SortContoursPipe.SortContoursParams(
-                        settings.contourSortMode,
-                        settings.outputShowMultipleTargets ? MAX_MULTI_TARGET_RESULTS : 1,
-                        frameStaticProperties);
-        sortContoursPipe.setParams(sortContoursParams);
-
-        var filterContoursParams =
-                new FilterObjectDetectionsPipe.FilterContoursParams(
-                        settings.contourArea,
-                        settings.contourRatio,
-                        frameStaticProperties,
-                        settings.contourTargetOrientation == TargetOrientation.Landscape);
-        filterContoursPipe.setParams(filterContoursParams);
-
-        Collect2dTargetsPipe.Collect2dTargetsParams collect2dTargetsParams =
-                new Collect2dTargetsPipe.Collect2dTargetsParams(
-                        settings.offsetRobotOffsetMode,
-                        settings.offsetSinglePoint,
-                        dualOffsetValues,
-                        settings.contourTargetOffsetPointEdge,
-                        settings.contourTargetOrientation,
-                        frameStaticProperties);
-        collect2dTargetsPipe.setParams(collect2dTargetsParams);
     }
 
     @Override
@@ -97,35 +60,31 @@ public class ObjectDetectionPipeline
 
         // ***************** change based on backend ***********************
 
-        CVPipeResult<List<NeuralNetworkPipeResult>> rknnResult = rknnPipe.run(input_frame.colorImage);
-        sumPipeNanosElapsed += rknnResult.nanosElapsed;
+        CVPipeResult<List<NeuralNetworkPipeResult>> ret = rknnPipe.run(input_frame.colorImage);
+        sumPipeNanosElapsed += ret.nanosElapsed;
         List<NeuralNetworkPipeResult> targetList;
 
+        targetList = ret.output;
         var names = rknnPipe.getClassNames();
 
         input_frame.colorImage.getMat().copyTo(input_frame.processedImage.getMat());
 
         // ***************** change based on backend ***********************
 
-        var filterContoursResult = filterContoursPipe.run(rknnResult.output);
-        sumPipeNanosElapsed += filterContoursResult.nanosElapsed;
+        List<TrackedTarget> targets = new ArrayList<>();
 
-        CVPipeResult<List<PotentialTarget>> sortContoursResult =
-                sortContoursPipe.run(
-                        filterContoursResult.output.stream()
-                                .map(shape -> new PotentialTarget(shape))
-                                .collect(Collectors.toList()));
-        sumPipeNanosElapsed += sortContoursResult.nanosElapsed;
-
-        CVPipeResult<List<TrackedTarget>> collect2dTargetsResult =
-                collect2dTargetsPipe.run(sortContoursResult.output);
-        sumPipeNanosElapsed += collect2dTargetsResult.nanosElapsed;
+        for (var t : targetList) {
+            targets.add(
+                    new TrackedTarget(
+                            t,
+                            new TargetCalculationParameters(
+                                    false, null, null, null, null, frameStaticProperties)));
+        }
 
         var fpsResult = calculateFPSPipe.run(null);
         var fps = fpsResult.output;
 
-        return new CVPipelineResult(
-                sumPipeNanosElapsed, fps, collect2dTargetsResult.output, input_frame, names);
+        return new CVPipelineResult(sumPipeNanosElapsed, fps, targets, input_frame, names);
     }
 
     @Override

photon-core/src/main/java/org/photonvision/vision/pipeline/ReflectivePipeline.java

@@ -64,6 +64,29 @@ public class ReflectivePipeline extends CVPipeline<CVPipelineResult, ReflectiveP
                         settings.offsetDualPointB,
                         settings.offsetDualPointBArea);
 
+        // var rotateImageParams = new
+        // RotateImagePipe.RotateImageParams(settings.inputImageRotationMode);
+        // rotateImagePipe.setParams(rotateImageParams);
+
+        // if (cameraQuirks.hasQuirk(CameraQuirk.PiCam) && LibCameraJNI.isSupported()) {
+        //     LibCameraJNI.setThresholds(
+        //             settings.hsvHue.getFirst() / 180d,
+        //             settings.hsvSaturation.getFirst() / 255d,
+        //             settings.hsvValue.getFirst() / 255d,
+        //             settings.hsvHue.getSecond() / 180d,
+        //             settings.hsvSaturation.getSecond() / 255d,
+        //             settings.hsvValue.getSecond() / 255d);
+        //     //     LibCameraJNI.setInvertHue(settings.hueInverted);
+        //     LibCameraJNI.setRotation(settings.inputImageRotationMode.value);
+        //     //     LibCameraJNI.setShouldCopyColor(settings.inputShouldShow);
+        // } else {
+        //     var hsvParams =
+        //             new HSVPipe.HSVParams(
+        //                     settings.hsvHue, settings.hsvSaturation, settings.hsvValue,
+        // settings.hueInverted);
+        //     hsvPipe.setParams(hsvParams);
+        // }
+
         var findContoursParams = new FindContoursPipe.FindContoursParams();
         findContoursPipe.setParams(findContoursParams);
 
@@ -90,7 +113,7 @@ public class ReflectivePipeline extends CVPipeline<CVPipelineResult, ReflectiveP
         var sortContoursParams =
                 new SortContoursPipe.SortContoursParams(
                         settings.contourSortMode,
-                        settings.outputShowMultipleTargets ? MAX_MULTI_TARGET_RESULTS : 1,
+                        settings.outputShowMultipleTargets ? 8 : 1, // TODO don't hardcode?
                         frameStaticProperties);
         sortContoursPipe.setParams(sortContoursParams);
 

photon-core/src/main/java/org/photonvision/vision/processes/VisionRunner.java

@@ -98,7 +98,8 @@ public class VisionRunner {
                 var pipelineResult = pipeline.run(frame, cameraQuirks);
                 pipelineResultConsumer.accept(pipelineResult);
             } catch (Exception ex) {
-                logger.error("Exception on loop " + loopCount, ex);
+                logger.error("Exception on loop " + loopCount);
+                ex.printStackTrace();
             }
 
             loopCount++;

photon-core/src/main/java/org/photonvision/vision/target/PotentialTarget.java

@@ -21,9 +21,7 @@ import java.util.List;
 import org.opencv.core.RotatedRect;
 import org.photonvision.vision.opencv.CVShape;
 import org.photonvision.vision.opencv.Contour;
-import org.photonvision.vision.opencv.ContourShape;
 import org.photonvision.vision.opencv.Releasable;
-import org.photonvision.vision.pipe.impl.NeuralNetworkPipeResult;
 
 public class PotentialTarget implements Releasable {
 
@@ -31,10 +29,6 @@ public class PotentialTarget implements Releasable {
     public final List<Contour> m_subContours;
     public final CVShape shape;
 
-    // additional metadata about object detections we need to keep around
-    public final double confidence;
-    public final int clsId;
-
     public PotentialTarget(Contour inputContour) {
         this(inputContour, List.of());
     }
@@ -47,26 +41,12 @@ public class PotentialTarget implements Releasable {
         m_mainContour = inputContour;
         m_subContours = new ArrayList<>(subContours);
         this.shape = shape;
-        this.clsId = -1;
-        this.confidence = -1;
     }
 
     public PotentialTarget(Contour inputContour, CVShape shape) {
         this(inputContour, List.of(), shape);
     }
 
-    public PotentialTarget(NeuralNetworkPipeResult det) {
-        this.shape = new CVShape(new Contour(det.box), ContourShape.Quadrilateral);
-        this.m_mainContour = this.shape.getContour();
-        m_subContours = List.of();
-        this.clsId = det.classIdx;
-        this.confidence = det.confidence;
-    }
-
-    public PotentialTarget(CVShape cvShape) {
-        this(cvShape.getContour(), cvShape);
-    }
-
     public RotatedRect getMinAreaRect() {
         return m_mainContour.getMinAreaRect();
     }
@@ -81,7 +61,7 @@ public class PotentialTarget implements Releasable {
         for (var sc : m_subContours) {
             sc.release();
         }
-        if (!m_subContours.isEmpty()) m_subContours.clear();
+        m_subContours.clear();
         if (shape != null) shape.release();
     }
 }

photon-core/src/main/java/org/photonvision/vision/target/TrackedTarget.java

@@ -27,6 +27,7 @@ import org.opencv.core.Mat;
 import org.opencv.core.MatOfPoint;
 import org.opencv.core.MatOfPoint2f;
 import org.opencv.core.Point;
+import org.opencv.core.Rect2d;
 import org.opencv.core.RotatedRect;
 import org.photonvision.common.util.SerializationUtils;
 import org.photonvision.common.util.math.MathUtils;
@@ -38,6 +39,7 @@ import org.photonvision.vision.opencv.CVShape;
 import org.photonvision.vision.opencv.Contour;
 import org.photonvision.vision.opencv.DualOffsetValues;
 import org.photonvision.vision.opencv.Releasable;
+import org.photonvision.vision.pipe.impl.NeuralNetworkPipeResult;
 
 public class TrackedTarget implements Releasable {
     public final Contour m_mainContour;
@@ -74,9 +76,6 @@ public class TrackedTarget implements Releasable {
         this.m_subContours = origTarget.m_subContours;
         this.m_shape = shape;
         calculateValues(params);
-
-        this.m_classId = origTarget.clsId;
-        this.m_confidence = origTarget.confidence;
     }
 
     public TrackedTarget(
@@ -160,6 +159,47 @@ public class TrackedTarget implements Releasable {
         m_robotOffsetPoint = new Point();
     }
 
+    public TrackedTarget(
+            Rect2d box, int class_id, double confidence, TargetCalculationParameters params) {
+        m_targetOffsetPoint = new Point(box.x + box.width / 2.0, box.y + box.height / 2.0);
+        m_robotOffsetPoint = new Point();
+
+        var yawPitch =
+                TargetCalculations.calculateYawPitch(
+                        params.cameraCenterPoint.x,
+                        box.x + box.width / 2.0,
+                        params.horizontalFocalLength,
+                        params.cameraCenterPoint.y,
+                        box.y + box.height / 2.0,
+                        params.verticalFocalLength);
+        m_yaw = yawPitch.getFirst();
+        m_pitch = yawPitch.getSecond();
+
+        Point[] cornerPoints =
+                new Point[] {
+                    // Box.x/y is the top-left corner, not the center
+                    new Point(box.x, box.y), // tl
+                    new Point(box.x + box.width, box.y), // tr
+                    new Point(box.x + box.width, box.y + box.height), // br
+                    new Point(box.x, box.y + box.height), // bl
+                };
+
+        m_targetCorners = List.of(cornerPoints);
+        MatOfPoint contourMat = new MatOfPoint(cornerPoints);
+        m_approximateBoundingPolygon = new MatOfPoint2f(cornerPoints);
+
+        m_mainContour = new Contour(contourMat);
+        m_area = m_mainContour.getArea() / params.imageArea * 100;
+
+        m_classId = class_id;
+        m_confidence = confidence;
+    }
+
+    public TrackedTarget(
+            NeuralNetworkPipeResult t, TargetCalculationParameters targetCalculationParameters) {
+        this(t.box, t.classIdx, t.confidence, targetCalculationParameters);
+    }
+
     /**
      * @return Returns the confidence of the detection ranging from 0 - 1.
      */

photon-lib/src/main/native/include/photon/simulation/PhotonCameraSim.h

@@ -435,7 +435,7 @@ class PhotonCameraSim {
   double minTargetAreaPercent;
 
   frc::AprilTagFieldLayout tagLayout{
-      frc::LoadAprilTagLayoutField(frc::AprilTagField::k2024Crescendo)};
+      frc::LoadAprilTagLayoutField(frc::AprilTagField::k2023ChargedUp)};
 
   cs::CvSource videoSimRaw;
   cv::Mat videoSimFrameRaw{};

photon-server/src/main/java/org/photonvision/server/Server.java

@@ -138,6 +138,7 @@ public class Server {
         app.post("/api/calibration/importFromData", RequestHandler::onDataCalibrationImportRequest);
 
         app.start(port);
+        System.out.println("hi");
     }
 
     /**

photonlib-cpp-examples/swervedriveposeestsim/src/main/include/Constants.h

@@ -35,48 +35,48 @@
 
 namespace constants {
 namespace Vision {
-inline constexpr std::string_view kCameraName{"YOUR CAMERA NAME"};
-inline const frc::Transform3d kRobotToCam{
+static constexpr std::string_view kCameraName{"YOUR CAMERA NAME"};
+static const frc::Transform3d kRobotToCam{
     frc::Translation3d{0.5_m, 0.0_m, 0.5_m},
     frc::Rotation3d{0_rad, 0_rad, 0_rad}};
-inline const frc::AprilTagFieldLayout kTagLayout{
-    frc::LoadAprilTagLayoutField(frc::AprilTagField::k2024Crescendo)};
+static const frc::AprilTagFieldLayout kTagLayout{
+    frc::LoadAprilTagLayoutField(frc::AprilTagField::k2023ChargedUp)};
 
-inline const Eigen::Matrix<double, 3, 1> kSingleTagStdDevs{4, 4, 8};
-inline const Eigen::Matrix<double, 3, 1> kMultiTagStdDevs{0.5, 0.5, 1};
+static const Eigen::Matrix<double, 3, 1> kSingleTagStdDevs{4, 4, 8};
+static const Eigen::Matrix<double, 3, 1> kMultiTagStdDevs{0.5, 0.5, 1};
 }  // namespace Vision
 namespace Swerve {
 
-inline constexpr units::meter_t kTrackWidth{18.5_in};
-inline constexpr units::meter_t kTrackLength{18.5_in};
-inline constexpr units::meter_t kRobotWidth{25_in + 3.25_in * 2};
-inline constexpr units::meter_t kRobotLength{25_in + 3.25_in * 2};
-inline constexpr units::meters_per_second_t kMaxLinearSpeed{15.5_fps};
-inline constexpr units::radians_per_second_t kMaxAngularSpeed{720_deg_per_s};
-inline constexpr units::meter_t kWheelDiameter{4_in};
-inline constexpr units::meter_t kWheelCircumference{kWheelDiameter *
+static constexpr units::meter_t kTrackWidth{18.5_in};
+static constexpr units::meter_t kTrackLength{18.5_in};
+static constexpr units::meter_t kRobotWidth{25_in + 3.25_in * 2};
+static constexpr units::meter_t kRobotLength{25_in + 3.25_in * 2};
+static constexpr units::meters_per_second_t kMaxLinearSpeed{15.5_fps};
+static constexpr units::radians_per_second_t kMaxAngularSpeed{720_deg_per_s};
+static constexpr units::meter_t kWheelDiameter{4_in};
+static constexpr units::meter_t kWheelCircumference{kWheelDiameter *
                                                     std::numbers::pi};
 
-inline constexpr double kDriveGearRatio = 6.75;
-inline constexpr double kSteerGearRatio = 12.8;
+static constexpr double kDriveGearRatio = 6.75;
+static constexpr double kSteerGearRatio = 12.8;
 
-inline constexpr units::meter_t kDriveDistPerPulse =
+static constexpr units::meter_t kDriveDistPerPulse =
     kWheelCircumference / 1024.0 / kDriveGearRatio;
-inline constexpr units::radian_t kSteerRadPerPulse =
+static constexpr units::radian_t kSteerRadPerPulse =
     units::radian_t{2 * std::numbers::pi} / 1024.0;
 
-inline constexpr double kDriveKP = 1.0;
-inline constexpr double kDriveKI = 0.0;
-inline constexpr double kDriveKD = 0.0;
+static constexpr double kDriveKP = 1.0;
+static constexpr double kDriveKI = 0.0;
+static constexpr double kDriveKD = 0.0;
 
-inline constexpr double kSteerKP = 20.0;
-inline constexpr double kSteerKI = 0.0;
-inline constexpr double kSteerKD = 0.25;
+static constexpr double kSteerKP = 20.0;
+static constexpr double kSteerKI = 0.0;
+static constexpr double kSteerKD = 0.25;
 
-inline const frc::SimpleMotorFeedforward<units::meters> kDriveFF{
+static const frc::SimpleMotorFeedforward<units::meters> kDriveFF{
     0.25_V, 2.5_V / 1_mps, 0.3_V / 1_mps_sq};
 
-inline const frc::SimpleMotorFeedforward<units::radians> kSteerFF{
+static const frc::SimpleMotorFeedforward<units::radians> kSteerFF{
     0.5_V, 0.25_V / 1_rad_per_s, 0.01_V / 1_rad_per_s_sq};
 
 struct ModuleConstants {
@@ -106,13 +106,13 @@ struct ModuleConstants {
         centerOffset(frc::Translation2d{xOffset, yOffset}) {}
 };
 
-inline const ModuleConstants FL_CONSTANTS{
+static const ModuleConstants FL_CONSTANTS{
     1, 0, 0, 1, 1, 2, 3, 0, kTrackLength / 2, kTrackWidth / 2};
-inline const ModuleConstants FR_CONSTANTS{
+static const ModuleConstants FR_CONSTANTS{
     2, 2, 4, 5, 3, 6, 7, 0, kTrackLength / 2, -kTrackWidth / 2};
-inline const ModuleConstants BL_CONSTANTS{
+static const ModuleConstants BL_CONSTANTS{
     3, 4, 8, 9, 5, 10, 11, 0, -kTrackLength / 2, kTrackWidth / 2};
-inline const ModuleConstants BR_CONSTANTS{
+static const ModuleConstants BR_CONSTANTS{
     4, 6, 12, 13, 7, 14, 15, 0, -kTrackLength / 2, -kTrackWidth / 2};
 }  // namespace Swerve
 }  // namespace constants

photonlib-cpp-examples/swervedriveposeestsim/src/main/include/Vision.h

@@ -61,7 +61,7 @@ class Vision {
       cameraSim = std::make_shared<photon::PhotonCameraSim>(camera.get(),
                                                             *cameraProp.get());
 
-      visionSim->AddCamera(cameraSim.get(), constants::Vision::kRobotToCam);
+      visionSim->AddCamera(cameraSim.get(), robotToCam);
       cameraSim->EnableDrawWireframe(true);
     }
   }
@@ -138,10 +138,12 @@ class Vision {
   frc::Field2d& GetSimDebugField() { return visionSim->GetDebugField(); }
 
  private:
+  frc::Transform3d robotToCam{frc::Translation3d{0.5_m, 0.5_m, 0.5_m},
+                              frc::Rotation3d{}};
   photon::PhotonPoseEstimator photonEstimator{
-      constants::Vision::kTagLayout,
+      LoadAprilTagLayoutField(frc::AprilTagField::k2023ChargedUp),
       photon::PoseStrategy::MULTI_TAG_PNP_ON_COPROCESSOR,
-      photon::PhotonCamera{"photonvision"}, constants::Vision::kRobotToCam};
+      photon::PhotonCamera{"photonvision"}, robotToCam};
   std::shared_ptr<photon::PhotonCamera> camera{photonEstimator.GetCamera()};
   std::unique_ptr<photon::VisionSystemSim> visionSim;
   std::unique_ptr<photon::SimCameraProperties> cameraProp;