Fix .gitignore, move vision package out of common

photon-server/src/test/java/org/photonvision/vision/pipeline/CirclePNPTest.java

@@ -0,0 +1,164 @@
+package org.photonvision.vision.pipeline;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import edu.wpi.first.wpilibj.geometry.Rotation2d;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.stream.Collectors;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.photonvision.common.util.TestUtils;
+import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
+import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.frame.provider.FileFrameProvider;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.opencv.ContourGroupingMode;
+import org.photonvision.vision.opencv.ContourIntersectionDirection;
+import org.photonvision.vision.opencv.ContourShape;
+import org.photonvision.vision.target.TargetModel;
+import org.photonvision.vision.target.TrackedTarget;
+
+public class CirclePNPTest {
+
+    private static final String LIFECAM_240P_CAL_FILE = "lifecam240p.json";
+    private static final String LIFECAM_480P_CAL_FILE = "lifecam480p.json";
+
+    @BeforeEach
+    public void Init() {
+        TestUtils.loadLibraries();
+    }
+
+    @Test
+    public void loadCameraIntrinsics() {
+        var lifecam240pCal = getCoeffs(LIFECAM_240P_CAL_FILE);
+        var lifecam480pCal = getCoeffs(LIFECAM_480P_CAL_FILE);
+
+        assertNotNull(lifecam240pCal);
+        checkCameraCoefficients(lifecam240pCal);
+        assertNotNull(lifecam480pCal);
+        checkCameraCoefficients(lifecam480pCal);
+    }
+
+    private CameraCalibrationCoefficients getCoeffs(String filename) {
+        try {
+            var cameraCalibration =
+                    new ObjectMapper()
+                            .readValue(
+                                    (Path.of(TestUtils.getCalibrationPath().toString(), filename).toFile()),
+                                    CameraCalibrationCoefficients.class);
+
+            checkCameraCoefficients(cameraCalibration);
+
+            return cameraCalibration;
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private void checkCameraCoefficients(CameraCalibrationCoefficients cameraCalibration) {
+        assertEquals(3, cameraCalibration.cameraIntrinsics.rows);
+        assertEquals(3, cameraCalibration.cameraIntrinsics.cols);
+        assertEquals(3, cameraCalibration.cameraIntrinsics.getAsMat().rows());
+        assertEquals(3, cameraCalibration.cameraIntrinsics.getAsMat().cols());
+        assertEquals(3, cameraCalibration.cameraIntrinsics.getAsMatOfDouble().rows());
+        assertEquals(3, cameraCalibration.cameraIntrinsics.getAsMatOfDouble().cols());
+        assertEquals(3, cameraCalibration.getCameraIntrinsicsMat().rows());
+        assertEquals(3, cameraCalibration.getCameraIntrinsicsMat().cols());
+        assertEquals(1, cameraCalibration.cameraExtrinsics.rows);
+        assertEquals(5, cameraCalibration.cameraExtrinsics.cols);
+        assertEquals(1, cameraCalibration.cameraExtrinsics.getAsMat().rows());
+        assertEquals(5, cameraCalibration.cameraExtrinsics.getAsMat().cols());
+        assertEquals(1, cameraCalibration.cameraExtrinsics.getAsMatOfDouble().rows());
+        assertEquals(5, cameraCalibration.cameraExtrinsics.getAsMatOfDouble().cols());
+        assertEquals(1, cameraCalibration.getCameraExtrinsicsMat().rows());
+        assertEquals(5, cameraCalibration.getCameraExtrinsicsMat().cols());
+    }
+
+    @Test
+    public void testCircle() {
+        var pipeline = new ColoredShapePipeline();
+
+        pipeline.getSettings().hsvHue.set(0, 100);
+        pipeline.getSettings().hsvSaturation.set(100, 255);
+        pipeline.getSettings().hsvValue.set(100, 255);
+        pipeline.getSettings().outputShowThresholded = true;
+        pipeline.getSettings().maxCannyThresh = 50;
+        pipeline.getSettings().accuracy = 15;
+        pipeline.getSettings().allowableThreshold = 5;
+        pipeline.getSettings().solvePNPEnabled = true;
+        pipeline.getSettings().cornerDetectionAccuracyPercentage = 4;
+        pipeline.getSettings().cornerDetectionUseConvexHulls = true;
+        pipeline.getSettings().cameraCalibration = getCoeffs(LIFECAM_480P_CAL_FILE);
+        pipeline.getSettings().targetModel = TargetModel.getCircleTarget(7);
+        pipeline.getSettings().cameraPitch = Rotation2d.fromDegrees(0.0);
+        pipeline.getSettings().outputShowThresholded = true;
+        pipeline.getSettings().outputShowMultipleTargets = false;
+        pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
+        pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
+        pipeline.getSettings().desiredShape = ContourShape.Circle;
+        pipeline.getSettings().allowableThreshold = 10;
+        pipeline.getSettings().minRadius = 30;
+        pipeline.getSettings().accuracyPercentage = 30.0;
+
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getPowercellImagePath(TestUtils.PowercellTestImages.kPowercell_test_6),
+                        TestUtils.WPI2020Image.FOV);
+
+        CVPipelineResult pipelineResult = pipeline.run(frameProvider.get());
+        printTestResults(pipelineResult);
+
+        TestUtils.showImage(pipelineResult.outputFrame.image.getMat(), "Pipeline output", 999999);
+    }
+
+    private static void continuouslyRunPipeline(Frame frame, ReflectivePipelineSettings settings) {
+        var pipeline = new ReflectivePipeline();
+        pipeline.settings = settings;
+
+        while (true) {
+            CVPipelineResult pipelineResult = pipeline.run(frame);
+            printTestResults(pipelineResult);
+            int preRelease = CVMat.getMatCount();
+            pipelineResult.release();
+            int postRelease = CVMat.getMatCount();
+
+            System.out.printf("Pre: %d, Post: %d\n", preRelease, postRelease);
+        }
+    }
+
+    // used to run VisualVM for profiling, which won't run on unit tests.
+    public static void main(String[] args) {
+        TestUtils.loadLibraries();
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getWPIImagePath(TestUtils.WPI2019Image.kCargoStraightDark72in_HighRes),
+                        TestUtils.WPI2019Image.FOV);
+
+        var settings = new ReflectivePipelineSettings();
+        settings.hsvHue.set(60, 100);
+        settings.hsvSaturation.set(100, 255);
+        settings.hsvValue.set(190, 255);
+        settings.outputShowThresholded = true;
+        settings.outputShowMultipleTargets = true;
+        settings.contourGroupingMode = ContourGroupingMode.Dual;
+        settings.contourIntersection = ContourIntersectionDirection.Up;
+
+        continuouslyRunPipeline(frameProvider.get(), settings);
+    }
+
+    private static void printTestResults(CVPipelineResult pipelineResult) {
+        double fps = 1000 / pipelineResult.getLatencyMillis();
+        System.out.println(
+                "Pipeline ran in " + pipelineResult.getLatencyMillis() + "ms (" + fps + " " + "fps)");
+        System.out.println("Found " + pipelineResult.targets.size() + " valid targets");
+        System.out.println(
+                "Found targets at "
+                        + pipelineResult.targets.stream()
+                                .map(TrackedTarget::getRobotRelativePose)
+                                .collect(Collectors.toList()));
+    }
+}

photon-server/src/test/java/org/photonvision/vision/pipeline/ColoredShapePipelineTest.java

@@ -0,0 +1,121 @@
+package org.photonvision.vision.pipeline;
+
+import org.junit.jupiter.api.Test;
+import org.photonvision.common.util.TestUtils;
+import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.frame.FrameStaticProperties;
+import org.photonvision.vision.frame.provider.FileFrameProvider;
+import org.photonvision.vision.opencv.ContourGroupingMode;
+import org.photonvision.vision.opencv.ContourIntersectionDirection;
+import org.photonvision.vision.opencv.ContourShape;
+
+public class ColoredShapePipelineTest {
+
+    public static void testTriangleDetection(
+            ColoredShapePipeline pipeline,
+            ColoredShapePipelineSettings settings,
+            FrameStaticProperties frameStaticProperties,
+            Frame frame) {
+        pipeline.setPipeParams(frameStaticProperties, settings);
+        CVPipelineResult colouredShapePipelineResult = pipeline.run(frame);
+        TestUtils.showImage(
+                colouredShapePipelineResult.outputFrame.image.getMat(), "Pipeline output: Triangle.");
+        printTestResults(colouredShapePipelineResult);
+    }
+
+    public static void testQuadrilateralDetection(
+            ColoredShapePipeline pipeline,
+            ColoredShapePipelineSettings settings,
+            FrameStaticProperties frameStaticProperties,
+            Frame frame) {
+        settings.desiredShape = ContourShape.Quadrilateral;
+        pipeline.setPipeParams(frameStaticProperties, settings);
+        CVPipelineResult colouredShapePipelineResult = pipeline.run(frame);
+        TestUtils.showImage(
+                colouredShapePipelineResult.outputFrame.image.getMat(), "Pipeline output: Quadrilateral.");
+        printTestResults(colouredShapePipelineResult);
+    }
+
+    public static void testCustomShapeDetection(
+            ColoredShapePipeline pipeline,
+            ColoredShapePipelineSettings settings,
+            FrameStaticProperties frameStaticProperties,
+            Frame frame) {
+        settings.desiredShape = ContourShape.Custom;
+        pipeline.setPipeParams(frameStaticProperties, settings);
+        CVPipelineResult colouredShapePipelineResult = pipeline.run(frame);
+        TestUtils.showImage(
+                colouredShapePipelineResult.outputFrame.image.getMat(), "Pipeline output: Custom.");
+        printTestResults(colouredShapePipelineResult);
+    }
+
+    @Test
+    public static void testCircleShapeDetection(
+            ColoredShapePipeline pipeline,
+            ColoredShapePipelineSettings settings,
+            FrameStaticProperties frameStaticProperties,
+            Frame frame) {
+        settings.desiredShape = ContourShape.Circle;
+        pipeline.setPipeParams(frameStaticProperties, settings);
+        CVPipelineResult colouredShapePipelineResult = pipeline.run(frame);
+        TestUtils.showImage(
+                colouredShapePipelineResult.outputFrame.image.getMat(), "Pipeline output: Circle.");
+        printTestResults(colouredShapePipelineResult);
+    }
+
+    @Test
+    public static void testPowercellDetection(
+            ColoredShapePipelineSettings settings, ColoredShapePipeline pipeline) {
+
+        settings.hsvHue.set(10, 40);
+        settings.hsvSaturation.set(100, 255);
+        settings.hsvValue.set(100, 255);
+        settings.maxCannyThresh = 50;
+        settings.accuracy = 15;
+        settings.allowableThreshold = 5;
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getPowercellImagePath(TestUtils.PowercellTestImages.kPowercell_test_6),
+                        TestUtils.WPI2019Image.FOV);
+        testCircleShapeDetection(
+                pipeline, settings, frameProvider.get().frameStaticProperties, frameProvider.get());
+    }
+
+    public static void main(String[] args) {
+        TestUtils.loadLibraries();
+        System.out.println(TestUtils.getWPIImagePath(TestUtils.WPI2020Image.kBlueGoal_108in_Center));
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getPolygonImagePath(TestUtils.PolygonTestImages.kPolygons),
+                        TestUtils.WPI2019Image.FOV);
+        var settings = new ColoredShapePipelineSettings();
+        settings.hsvHue.set(0, 100);
+        settings.hsvSaturation.set(100, 255);
+        settings.hsvValue.set(100, 255);
+        settings.outputShowThresholded = true;
+        settings.outputShowMultipleTargets = true;
+        settings.contourGroupingMode = ContourGroupingMode.Single;
+        settings.contourIntersection = ContourIntersectionDirection.Up;
+        settings.desiredShape = ContourShape.Triangle;
+        settings.allowableThreshold = 10;
+        settings.accuracyPercentage = 30.0;
+
+        ColoredShapePipeline pipeline = new ColoredShapePipeline();
+        testTriangleDetection(
+                pipeline, settings, frameProvider.get().frameStaticProperties, frameProvider.get());
+        testQuadrilateralDetection(
+                pipeline, settings, frameProvider.get().frameStaticProperties, frameProvider.get());
+        testCustomShapeDetection(
+                pipeline, settings, frameProvider.get().frameStaticProperties, frameProvider.get());
+        testCircleShapeDetection(
+                pipeline, settings, frameProvider.get().frameStaticProperties, frameProvider.get());
+        testPowercellDetection(settings, pipeline);
+    }
+
+    private static void printTestResults(CVPipelineResult pipelineResult) {
+        double fps = 1000 / pipelineResult.getLatencyMillis();
+        System.out.print(
+                "Pipeline ran in " + pipelineResult.getLatencyMillis() + "ms (" + fps + " fps), ");
+        System.out.println("Found " + pipelineResult.targets.size() + " valid targets");
+    }
+}

photon-server/src/test/java/org/photonvision/vision/pipeline/ReflectivePipelineTest.java

@@ -0,0 +1,105 @@
+package org.photonvision.vision.pipeline;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.photonvision.common.util.TestUtils;
+import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.frame.provider.FileFrameProvider;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.opencv.ContourGroupingMode;
+import org.photonvision.vision.opencv.ContourIntersectionDirection;
+
+public class ReflectivePipelineTest {
+
+    @Test
+    public void test2019() {
+        TestUtils.loadLibraries();
+        var pipeline = new ReflectivePipeline();
+        pipeline.getSettings().hsvHue.set(60, 100);
+        pipeline.getSettings().hsvSaturation.set(100, 255);
+        pipeline.getSettings().hsvValue.set(190, 255);
+        pipeline.getSettings().outputShowThresholded = true;
+        pipeline.getSettings().outputShowMultipleTargets = true;
+        pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Dual;
+        pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
+
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getWPIImagePath(TestUtils.WPI2019Image.kCargoStraightDark72in_HighRes),
+                        TestUtils.WPI2019Image.FOV);
+
+        TestUtils.showImage(frameProvider.get().image.getMat(), "Pipeline input", 1);
+
+        CVPipelineResult pipelineResult;
+
+        pipelineResult = pipeline.run(frameProvider.get());
+        printTestResults(pipelineResult);
+
+        Assertions.assertTrue(pipelineResult.hasTargets());
+        Assertions.assertEquals(2, pipelineResult.targets.size(), "Target count wrong!");
+
+        TestUtils.showImage(pipelineResult.outputFrame.image.getMat(), "Pipeline output");
+    }
+
+    @Test
+    public void test2020() {
+        TestUtils.loadLibraries();
+        var pipeline = new ReflectivePipeline();
+
+        pipeline.getSettings().hsvHue.set(60, 100);
+        pipeline.getSettings().hsvSaturation.set(200, 255);
+        pipeline.getSettings().hsvValue.set(200, 255);
+        pipeline.getSettings().outputShowThresholded = true;
+
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getWPIImagePath(TestUtils.WPI2020Image.kBlueGoal_108in_Center),
+                        TestUtils.WPI2020Image.FOV);
+
+        CVPipelineResult pipelineResult = pipeline.run(frameProvider.get());
+        printTestResults(pipelineResult);
+
+        TestUtils.showImage(pipelineResult.outputFrame.image.getMat(), "Pipeline output");
+    }
+
+    private static void continuouslyRunPipeline(Frame frame, ReflectivePipelineSettings settings) {
+        var pipeline = new ReflectivePipeline();
+
+        while (true) {
+            CVPipelineResult pipelineResult = pipeline.run(frame);
+            printTestResults(pipelineResult);
+            int preRelease = CVMat.getMatCount();
+            pipelineResult.release();
+            int postRelease = CVMat.getMatCount();
+
+            System.out.printf("Pre: %d, Post: %d\n", preRelease, postRelease);
+        }
+    }
+
+    // used to run VisualVM for profiling. It won't run on unit tests.
+    public static void main(String[] args) {
+        TestUtils.loadLibraries();
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getWPIImagePath(TestUtils.WPI2019Image.kCargoStraightDark72in_HighRes),
+                        TestUtils.WPI2019Image.FOV);
+
+        var settings = new ReflectivePipelineSettings();
+        settings.hsvHue.set(60, 100);
+        settings.hsvSaturation.set(100, 255);
+        settings.hsvValue.set(190, 255);
+        settings.outputShowThresholded = true;
+        settings.outputShowMultipleTargets = true;
+        settings.contourGroupingMode = ContourGroupingMode.Dual;
+        settings.contourIntersection = ContourIntersectionDirection.Up;
+
+        continuouslyRunPipeline(frameProvider.get(), settings);
+    }
+
+    private static void printTestResults(CVPipelineResult pipelineResult) {
+        double fps = 1000 / pipelineResult.getLatencyMillis();
+        System.out.print(
+                "Pipeline ran in " + pipelineResult.getLatencyMillis() + "ms (" + fps + " fps), ");
+        System.out.println("Found " + pipelineResult.targets.size() + " valid targets");
+    }
+}

photon-server/src/test/java/org/photonvision/vision/pipeline/SolvePNPTest.java

@@ -0,0 +1,214 @@
+package org.photonvision.vision.pipeline;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import edu.wpi.first.wpilibj.geometry.Rotation2d;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.stream.Collectors;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.photonvision.common.util.TestUtils;
+import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
+import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.frame.provider.FileFrameProvider;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.opencv.ContourGroupingMode;
+import org.photonvision.vision.opencv.ContourIntersectionDirection;
+import org.photonvision.vision.target.TargetModel;
+import org.photonvision.vision.target.TrackedTarget;
+
+public class SolvePNPTest {
+
+    private static final String LIFECAM_240P_CAL_FILE = "lifecam240p.json";
+    private static final String LIFECAM_480P_CAL_FILE = "lifecam480p.json";
+
+    @BeforeEach
+    public void Init() {
+        TestUtils.loadLibraries();
+    }
+
+    @Test
+    public void loadCameraIntrinsics() {
+        var lifecam240pCal = getCoeffs(LIFECAM_240P_CAL_FILE);
+        var lifecam480pCal = getCoeffs(LIFECAM_480P_CAL_FILE);
+
+        assertNotNull(lifecam240pCal);
+        checkCameraCoefficients(lifecam240pCal);
+        assertNotNull(lifecam480pCal);
+        checkCameraCoefficients(lifecam480pCal);
+    }
+
+    private CameraCalibrationCoefficients getCoeffs(String filename) {
+        try {
+            var cameraCalibration =
+                    new ObjectMapper()
+                            .readValue(
+                                    (Path.of(TestUtils.getCalibrationPath().toString(), filename).toFile()),
+                                    CameraCalibrationCoefficients.class);
+
+            checkCameraCoefficients(cameraCalibration);
+
+            return cameraCalibration;
+        } catch (IOException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private void checkCameraCoefficients(CameraCalibrationCoefficients cameraCalibration) {
+        assertEquals(3, cameraCalibration.cameraIntrinsics.rows);
+        assertEquals(3, cameraCalibration.cameraIntrinsics.cols);
+        assertEquals(3, cameraCalibration.cameraIntrinsics.getAsMat().rows());
+        assertEquals(3, cameraCalibration.cameraIntrinsics.getAsMat().cols());
+        assertEquals(3, cameraCalibration.cameraIntrinsics.getAsMatOfDouble().rows());
+        assertEquals(3, cameraCalibration.cameraIntrinsics.getAsMatOfDouble().cols());
+        assertEquals(3, cameraCalibration.getCameraIntrinsicsMat().rows());
+        assertEquals(3, cameraCalibration.getCameraIntrinsicsMat().cols());
+        assertEquals(1, cameraCalibration.cameraExtrinsics.rows);
+        assertEquals(5, cameraCalibration.cameraExtrinsics.cols);
+        assertEquals(1, cameraCalibration.cameraExtrinsics.getAsMat().rows());
+        assertEquals(5, cameraCalibration.cameraExtrinsics.getAsMat().cols());
+        assertEquals(1, cameraCalibration.cameraExtrinsics.getAsMatOfDouble().rows());
+        assertEquals(5, cameraCalibration.cameraExtrinsics.getAsMatOfDouble().cols());
+        assertEquals(1, cameraCalibration.getCameraExtrinsicsMat().rows());
+        assertEquals(5, cameraCalibration.getCameraExtrinsicsMat().cols());
+    }
+
+    @Test
+    public void test2019() {
+        var pipeline = new ReflectivePipeline();
+
+        pipeline.getSettings().hsvHue.set(60, 100);
+        pipeline.getSettings().hsvSaturation.set(100, 255);
+        pipeline.getSettings().hsvValue.set(190, 255);
+        pipeline.getSettings().outputShowThresholded = true;
+        pipeline.getSettings().outputShowMultipleTargets = true;
+        pipeline.getSettings().solvePNPEnabled = true;
+        pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Dual;
+        pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
+        pipeline.getSettings().cornerDetectionUseConvexHulls = true;
+        pipeline.getSettings().targetModel = TargetModel.get2019Target();
+        pipeline.getSettings().cameraCalibration = getCoeffs(LIFECAM_240P_CAL_FILE);
+
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getWPIImagePath(TestUtils.WPI2019Image.kCargoStraightDark48in),
+                        TestUtils.WPI2019Image.FOV);
+
+        CVPipelineResult pipelineResult;
+
+        pipelineResult = pipeline.run(frameProvider.get());
+        printTestResults(pipelineResult);
+
+        // these numbers are not *accurate*, but they are known and expected
+        var pose = pipelineResult.targets.get(0).getRobotRelativePose();
+        Assertions.assertEquals(41.96, pose.getTranslation().getX(), 0.05);
+        Assertions.assertEquals(-1.03, pose.getTranslation().getY(), 0.05);
+        Assertions.assertEquals(1.46, pose.getRotation().getDegrees(), 0.05);
+
+        TestUtils.showImage(pipelineResult.outputFrame.image.getMat(), "Pipeline output", 1000 * 90);
+    }
+
+    @Test
+    public void test2020() {
+        var pipeline = new ReflectivePipeline();
+
+        pipeline.getSettings().hsvHue.set(60, 100);
+        pipeline.getSettings().hsvSaturation.set(100, 255);
+        pipeline.getSettings().hsvValue.set(60, 255);
+        pipeline.getSettings().outputShowThresholded = true;
+        pipeline.getSettings().solvePNPEnabled = true;
+        pipeline.getSettings().cornerDetectionAccuracyPercentage = 4;
+        pipeline.getSettings().cornerDetectionUseConvexHulls = true;
+        pipeline.getSettings().cameraCalibration = getCoeffs(LIFECAM_480P_CAL_FILE);
+        pipeline.getSettings().targetModel = TargetModel.get2020Target(36);
+        pipeline.getSettings().cameraPitch = Rotation2d.fromDegrees(0.0);
+
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getWPIImagePath(TestUtils.WPI2020Image.kBlueGoal_224in_Left),
+                        TestUtils.WPI2020Image.FOV);
+
+        CVPipelineResult pipelineResult = pipeline.run(frameProvider.get());
+        printTestResults(pipelineResult);
+
+        // these numbers are not *accurate*, but they are known and expected
+        var pose = pipelineResult.targets.get(0).getRobotRelativePose();
+        Assertions.assertEquals(260.26, pose.getTranslation().getX(), 0.05);
+        Assertions.assertEquals(64.26, pose.getTranslation().getY(), 0.05);
+        Assertions.assertEquals(36.88, pose.getRotation().getDegrees(), 0.05);
+
+        TestUtils.showImage(pipelineResult.outputFrame.image.getMat(), "Pipeline output", 999999);
+    }
+
+    //    @Test
+    //    public void junk() {
+    //        var frameProvider =
+    //                new FileFrameProvider(
+    //
+    // TestUtils.getWPIImagePath(TestUtils.WPI2019Image.kCargoStraightDark72in_HighRes),
+    //                        TestUtils.WPI2019Image.FOV);
+    //
+    //        var settings = new ReflectivePipelineSettings();
+    //        settings.hsvHue.set(60, 100);
+    //        settings.hsvSaturation.set(100, 255);
+    //        settings.hsvValue.set(190, 255);
+    //        settings.outputShowThresholded = true;
+    //        settings.outputShowMultipleTargets = true;
+    //        settings.contourGroupingMode = ContourGroupingMode.Dual;
+    //        settings.contourIntersection = ContourIntersectionDirection.Up;
+    //
+    //        continuouslyRunPipeline(frameProvider.getFrame(), settings);
+    //    }
+
+    private static void continuouslyRunPipeline(Frame frame, ReflectivePipelineSettings settings) {
+        var pipeline = new ReflectivePipeline();
+        pipeline.settings = settings;
+
+        while (true) {
+            CVPipelineResult pipelineResult = pipeline.run(frame);
+            printTestResults(pipelineResult);
+            int preRelease = CVMat.getMatCount();
+            pipelineResult.release();
+            int postRelease = CVMat.getMatCount();
+
+            System.out.printf("Pre: %d, Post: %d\n", preRelease, postRelease);
+        }
+    }
+
+    // used to run VisualVM for profiling, which won't run on unit tests.
+    public static void main(String[] args) {
+        TestUtils.loadLibraries();
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getWPIImagePath(TestUtils.WPI2019Image.kCargoStraightDark72in_HighRes),
+                        TestUtils.WPI2019Image.FOV);
+
+        var settings = new ReflectivePipelineSettings();
+        settings.hsvHue.set(60, 100);
+        settings.hsvSaturation.set(100, 255);
+        settings.hsvValue.set(190, 255);
+        settings.outputShowThresholded = true;
+        settings.outputShowMultipleTargets = true;
+        settings.contourGroupingMode = ContourGroupingMode.Dual;
+        settings.contourIntersection = ContourIntersectionDirection.Up;
+
+        continuouslyRunPipeline(frameProvider.get(), settings);
+    }
+
+    private static void printTestResults(CVPipelineResult pipelineResult) {
+        double fps = 1000 / pipelineResult.getLatencyMillis();
+        System.out.println(
+                "Pipeline ran in " + pipelineResult.getLatencyMillis() + "ms (" + fps + " " + "fps)");
+        System.out.println("Found " + pipelineResult.targets.size() + " valid targets");
+        System.out.println(
+                "Found targets at "
+                        + pipelineResult.targets.stream()
+                                .map(TrackedTarget::getRobotRelativePose)
+                                .collect(Collectors.toList()));
+    }
+}