Pull thinclient into built JAR (#558)

* Add prints to image generation

* Make xz multithreaded

* More rename copypasta

.github/workflows/main.yml

@@ -24,24 +24,20 @@ jobs:
     # The type of runner that the job will run on.
     runs-on: ubuntu-latest
 
-    # Grab the docker container.
-    container:
-      image: docker://node:10
-
     steps:
     # Checkout code.
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v3
 
     # Setup Node.js
     - name: Setup Node.js
-      uses: actions/setup-node@v1
+      uses: actions/setup-node@v3
       with:
-        node-version: 10
+        node-version: 16
 
     # Run npm
-    - run: |
-        npm ci
-        npm run build --if-present
+    - run: npm update -g npm
+    - run: npm ci
+    - run: npm run build --if-present
 
     # Upload client artifact.
     - uses: actions/upload-artifact@master
@@ -56,7 +52,9 @@ jobs:
     steps:
       # Checkout code.
       - name: Checkout code
-        uses: actions/checkout@v1
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
 
       # Fetch tags.
       - name: Fetch tags
@@ -64,9 +62,10 @@ jobs:
 
       # Install Java 11.
       - name: Install Java 11
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v3
         with:
           java-version: 11
+          distribution: temurin
 
       # Run Gradle build.
       - name: Gradle Build
@@ -84,12 +83,12 @@ jobs:
 
       # Publish Coverage Report.
       - name: Publish Server Coverage Report
-        uses: codecov/codecov-action@v1
+        uses: codecov/codecov-action@v3
         with:
           file: ./photon-server/build/reports/jacoco/test/jacocoTestReport.xml
 
       - name: Publish Core Coverage Report
-        uses: codecov/codecov-action@v1
+        uses: codecov/codecov-action@v3
         with:
           file: ./photon-core/build/reports/jacoco/test/jacocoTestReport.xml
 
@@ -98,13 +97,13 @@ jobs:
 
     steps:
       # Checkout docs.
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           repository: 'PhotonVision/photonvision-docs.git'
           ref: master
 
       # Install Python.
-      - uses: actions/setup-python@v2
+      - uses: actions/setup-python@v4
         with:
           python-version: '3.6'
 
@@ -135,12 +134,15 @@ jobs:
 
     steps:
       # Checkout code.
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
 
       # Install Java 11.
-      - uses: actions/setup-java@v1
+      - uses: actions/setup-java@v3
         with:
           java-version: 11
+          distribution: temurin
 
       # Check server code with Spotless.
       - run: |
@@ -167,12 +169,13 @@ jobs:
     runs-on: ${{ matrix.os }}
     name: "Photonlib - Build - ${{ matrix.artifact-name }}"
     steps:
-      - uses: actions/checkout@v2.3.4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
-      - uses: actions/setup-java@v1
+      - uses: actions/setup-java@v3
         with:
           java-version: 11
+          distribution: temurin
       - run: git fetch --tags --force
       - run: |
           chmod +x gradlew
@@ -199,12 +202,13 @@ jobs:
     container: ${{ matrix.container }}
     name: "Photonlib - Build - ${{ matrix.artifact-name }}"
     steps:
-      - uses: actions/checkout@v2.3.4
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 0
-      - uses: actions/setup-java@v1
+      - uses: actions/setup-java@v3
         with:
           java-version: 11
+          distribution: temurin
       - run: |
           chmod +x gradlew
           ./gradlew photon-lib:build --max-workers 1
@@ -219,14 +223,14 @@ jobs:
     name: "wpiformat"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Fetch all history and metadata
         run: |
           git fetch --prune --unshallow
           git checkout -b pr
           git branch -f master origin/master
       - name: Set up Python 3.8
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v4
         with:
           python-version: 3.8
       - name: Install clang-format
@@ -243,7 +247,7 @@ jobs:
       - name: Generate diff
         run: git diff HEAD > wpiformat-fixes.patch
         if: ${{ failure() }}
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v3
         with:
           name: wpiformat fixes
           path: wpiformat-fixes.patch
@@ -257,12 +261,15 @@ jobs:
 
     steps:
       # Checkout code.
-      - uses: actions/checkout@v1
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
 
       # Install Java 11.
-      - uses: actions/setup-java@v1
+      - uses: actions/setup-java@v3
         with:
           java-version: 11
+          distribution: temurin
 
       # Clear any existing web resources.
       - run: |
@@ -270,13 +277,16 @@ jobs:
           mkdir -p photon-server/src/main/resources/web/docs
 
       # Download client artifact to resources folder.
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
         with:
           name: built-client
           path: photon-server/src/main/resources/web/
 
+      # Copy thinclient in as well
+      - run: cp -r photon-thinclient/* photon-server/src/main/resources/web/
+
       # Download docs artifact to resources folder.
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v3
         with:
           name: built-docs
           path: photon-server/src/main/resources/web/docs
@@ -295,14 +305,15 @@ jobs:
           ./scripts/generatePiImage.sh
 
       # Upload final fat jar as artifact.
-      - uses: actions/upload-artifact@master
+      - uses: actions/upload-artifact@v3
         with:
-          name: jar
+          name: jars
           path: photon-server/build/libs
-      - uses: actions/upload-artifact@master
+      - uses: actions/upload-artifact@v3
+        if: github.event_name != 'pull_request'
         with:
           name: image
-          path: photonvision*.zip
+          path: photonvision*.xz
 
       - uses: pyTooling/Actions/releaser@r0
         with:
@@ -311,7 +322,7 @@ jobs:
           rm: true
           files: |
             photon-server/build/libs/*.jar
-            photonvision*.zip
+            photonvision*.xz
         if: github.event_name == 'push'
 
   photon-release:
@@ -322,7 +333,7 @@ jobs:
       # This *should* pull in fat and pi-only jars
       - uses: actions/download-artifact@v2
         with:
-          name: jar
+          name: jars
 
       # And the image we made previously
       - uses: actions/download-artifact@v2

.gitignore

@@ -30,6 +30,7 @@ backend/settings/
 *.nar
 *.ear
 *.zip
+*.xz
 *.tar.gz
 *.rar
 
@@ -144,3 +145,8 @@ build
 photon-lib/src/main/java/org/photonvision/PhotonVersion.java
 /photonlib-java-examples/bin/
 photon-lib/src/generate/native/include/PhotonVersion.h
+.gitattributes
+lib/*
+photon-server/lib/libapriltag.so
+photon-server/bin/main/nativelibraries/apriltag/*
+photon-server/src/main/resources/nativelibraries/apriltag/*

.styleguide

@@ -11,8 +11,11 @@ cppSrcFileInclude {
 
 modifiableFileExclude {
   \.jpg$
+  \.jpeg$
   \.png$
+  \.gif$
   \.so$
+  \.dll$
 }
 
 includeProject {

build.gradle

@@ -11,7 +11,7 @@ plugins {
 
 allprojects {
     repositories {
-        jcenter()
+        mavenCentral()
         maven { url = "https://maven.photonvision.org/repository/internal/" }
     }
     wpilibRepositories.addAllReleaseRepositories(it)
@@ -28,9 +28,14 @@ ext {
     pubVersion = versionString
     isDev = pubVersion.startsWith("dev")
 
+    if(project.hasProperty('pionly')) {
+        jniPlatforms = ['linuxraspbian']
+    } else if(project.hasProperty('winonly')) {
+        jniPlatforms = ['windowsx86-64']
+    } else {
+        jniPlatforms = ['linuxaarch64bionic', 'linuxraspbian', 'linuxx86-64', 'osxx86-64', 'windowsx86-64']
 
-    jniPlatforms = project.hasProperty('pionly') ? ['linuxraspbian']
-        : ['linuxaarch64bionic', 'linuxraspbian', 'linuxx86-64', 'osxx86-64', 'windowsx86-64']
+    }
 
     println("Building for archs " + jniPlatforms)
 }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright <20> 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,68 +16,58 @@
 # limitations under the License.
 #
 
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=${0##*/}
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -87,9 +77,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -98,7 +88,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -106,80 +96,95 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,89 +1,89 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

photon-client/package.json

@@ -16,9 +16,10 @@
     "jspdf": "^2.4.0",
     "material-design-icons-iconfont": "^5.0.1",
     "msgpack5": "^4.2.1",
+    "three-full": "^28.0.2",
     "vue": "^2.6.12",
     "vue-axios": "^2.1.5",
-    "vue-native-websocket": "git+https://github.com/PhotonVision/vue-native-websocket.git#7a32791",
+    "vue-native-websocket": "git+https://git@github.com/PhotonVision/vue-native-websocket.git#5189f29",
     "vue-router": "^3.4.3",
     "vuetify": "^2.3.10",
     "vuex": "^3.5.1"

photon-client/src/App.vue

@@ -201,7 +201,7 @@
             class="accent--text"
             @click="switchToSettingsTab"
           >
-            vist the settings tab
+            visit the settings tab
           </router-link>
           and set your team number.
         </v-card-text>

photon-client/src/components/common/cv-image.vue

@@ -5,7 +5,7 @@
     :style="styleObject"
     :src="src"
     alt=""
-    @click="e => $emit('click', e)"
+    @click="e => {this.openThinclientStream(e)}"
   >
 </template>
 
@@ -13,7 +13,7 @@
     export default {
         name: "CvImage",
         // eslint-disable-next-line vue/require-prop-types
-        props: ['address', 'scale', 'maxHeight', 'maxHeightMd', 'maxHeightLg', 'maxHeightXl', 'colorPicking', 'id', 'disconnected'],
+        props: ['idx', 'scale', 'maxHeight', 'maxHeightMd', 'maxHeightLg', 'maxHeightXl', 'colorPicking', 'id', 'disconnected'],
         data() {
             return {
                 seed: 1.0,
@@ -46,18 +46,48 @@
                     return ret;
                 }
             },
-            src: {
+            port: {
               get() {
-                return this.disconnected ? require("../../assets/noStream.jpg") : this.address + "?" + this.seed // This prevents caching
-              },
-            },
+                if(this.idx == 0){
+                  return this.$store.state.cameraSettings[this.$store.state.currentCameraIndex].inputStreamPort;
+                } else {
+                  return this.$store.state.cameraSettings[this.$store.state.currentCameraIndex].outputStreamPort;
+                }
+              }
+            }
+        },
+        watch : {
+          port(newPort, oldPort){
+            newPort;
+            oldPort;
+            this.reload();
+          },
+          disconnected(newVal, oldVal){
+            oldVal;
+            if(newVal){
+              this.wsStream.stopStream();
+            } else {
+              this.wsStream.startStream();
+            }
+          }
         },
         mounted() {
-            this.reload(); // Force reload image on creation
+          var wsvs = require('../../plugins/WebsocketVideoStream');
+          this.wsStream = new wsvs.WebsocketVideoStream(this.id, this.port, window.location.host);
+        },
+        unmounted() {
+          this.wsStream.stopStream();
+          this.wsStream.ws_close();
         },
         methods: {
             reload() {
-                this.seed = new Date().getTime();
+              console.log("Reloading " + this.id + " with port " + String(this.port));
+              this.wsStream.setPort(this.port);
+            },
+            openThinclientStream(e){
+              e;
+              var URL = "/thinclient.html?port=" + String(this.port) + "&host=" + window.location.hostname;
+              window.open(URL, '_blank');
             }
         },
     }

photon-client/src/components/pipeline/3D/MiniMap.vue

@@ -1,154 +1,268 @@
 <template>
-  <div>
+  <div
+    id="MapContainer"
+    style="flex-grow:1"
+  >
     <v-row>
       <v-col
         align="center"
         cols="12"
       >
         <span class="white--text">Target Location</span>
+      </v-col>
+    </v-row>
+    <v-row>
+      <v-col
+        align="center"
+        cols="12"
+        align-self="stretch"
+      >
         <canvas
           id="canvasId"
-          class="mt-2"
-          width="800"
-          height="800"
+          style="width:100%;height:100%"
         />
       </v-col>
+      <v-row>
+        <v-col>
+          <v-btn
+            class="ml-10"
+            color="secondary"
+            @click="resetCamFirstPerson"
+          >
+            First Person
+          </v-btn>
+        </v-col>
+        <v-col>
+          <v-btn
+            class="ml-10"
+            color="secondary"
+            @click="resetCamThirdPerson"
+          >
+            Third Person
+          </v-btn>
+        </v-col>
+      </v-row>
     </v-row>
   </div>
 </template>
 
 <script>
-    import theme from "../../../theme";
 
-    export default {
-        name: "MiniMap",
-        props: {
-          // eslint-disable-next-line vue/require-default-prop
-          targets: Array,
-          // eslint-disable-next-line vue/require-default-prop
-          horizontalFOV: Number
-        },
-        data() {
-            return {
-                ctx: undefined,
-                canvas: undefined,
-                x: 0,
-                y: 0,
-                targetWidth: 40,
-                targetHeight: 6
-            }
-        },
-        computed: {
-            hLen: {
-                get() {
-                    return Math.tan(this.horizontalFOV / 2 * Math.PI / 180) * 150;
-                }
-            }
-        },
-        watch: {
-            targets: {
-                deep: true,
-                handler() {
-                    this.draw();
-                }
-            },
-            horizontalFOV() {
-                this.draw();
-            }
-        },
-        mounted: function () {
-            const canvas = document.getElementById("canvasId"); // getting the canvas element
-            const ctx = canvas.getContext("2d"); // getting the canvas context
-            this.canvas = canvas; // setting the canvas as a vue variable
-            this.ctx = ctx; // setting the canvas context as a vue variable
-            this.grad = this.ctx.createLinearGradient(400, 800, 400, 600);
-            this.grad.addColorStop(0, "rgb(119,119,119)");
-            this.grad.addColorStop(0.05, "rgba(14,92,22,0.96)");
-            this.grad.addColorStop(0.8, 'rgba(43,43,43,0.48)');
+import {
+  ArrowHelper,
+  BoxGeometry,
+  ConeGeometry,
+  Mesh,
+  MeshNormalMaterial,
+  PerspectiveCamera,
+  Quaternion,
+  Scene,
+  TrackballControls,
+  Vector3,
+    Color,
+  WebGLRenderer
+} from "three-full";
 
-            // setting canvas context values for drawing
+export default {
+  name: "MiniMap",
+  props: {
+    // eslint-disable-next-line vue/require-default-prop
+    targets: Array,
+    // eslint-disable-next-line vue/require-default-prop
+    horizontalFOV: Number
+  },
+  data() {
+    return {
+      scene: undefined,
+      cubes: [],
 
-
-            this.ctx.font = "26px Arial";
-            this.ctx.strokeStyle = "whitesmoke";
-            this.ctx.lineWidth = 2;
-
-            this.$nextTick(function () {
-                this.drawPlayer();
-            });
-        },
-        methods: {
-            draw() {
-                this.clearBoard();
-                this.drawPlayer();
-                for (let index in this.targets) {
-                    this.drawTarget(index, this.targets[index].pose);
-                }
-            },
-            drawTarget(index, target) {
-                // first save the untranslated/unrotated context
-                let x = 800 - (160 * target.x); // getting meters as pixels
-                let y = 400 - (160 * target.y);
-                this.ctx.save();
-                this.ctx.beginPath();
-                // move the rotation point to the center of the rect
-                this.ctx.translate(y + this.targetWidth / 2, x + this.targetHeight / 2); // wpi lib makes x forward and back and y left to right
-                // rotate the rect
-                this.ctx.rotate(target.rot * -1 * Math.PI / 180.0);
-
-                // draw the rect on the transformed context
-                // Note: after transforming [0,0] is visually [x,y]
-                //       so the rect needs to be offset accordingly when drawn
-                this.ctx.rect(-this.targetWidth / 2, -this.targetHeight / 2, this.targetWidth, this.targetHeight);
-
-                this.ctx.fillStyle = theme.accent;
-                this.ctx.fill();
-
-                // restore the context to its untranslated/unrotated state
-                this.ctx.restore();
-                this.ctx.fillStyle = "whitesmoke";
-                this.ctx.beginPath();
-                this.ctx.arc(y + this.targetWidth / 2, x + this.targetHeight / 2, 3, 0, 2 * Math.PI, true);
-                this.ctx.fill();
-                this.ctx.fillText(index, y - 30, x - 5);
-
-            },
-            drawPlayer() {
-                this.ctx.beginPath();
-                this.ctx.moveTo(400, 820);
-                this.ctx.lineTo(400 + this.hLen, 650);
-                this.ctx.lineTo(400 - this.hLen, 650);
-                this.ctx.closePath();
-                this.ctx.fillStyle = this.grad;
-                this.ctx.fill();
-                this.ctx.beginPath();
-                this.ctx.moveTo(400, 820);
-                this.ctx.lineTo(400 + this.hLen, 650);
-                this.ctx.stroke();
-                this.ctx.moveTo(400, 820);
-                this.ctx.lineTo(400 - this.hLen, 650);
-                this.ctx.stroke();
-
-            },
-            clearBoard() {
-                this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height); // clearing the canvas
-            }
-        }
     }
+  },
+  watch: {
+    targets: {
+      deep: true,
+      handler() {
+        this.drawTargets();
+      }
+    },
+  },
+
+  mounted() {
+    const scene = new Scene();
+    this.scene = scene;
+    const camera = new PerspectiveCamera(75, 800 / 800, 0.1, 1000);
+    this.camera = camera;
+
+    const canvas = document.getElementById("canvasId"); // getting the canvas element
+    this.canvas = canvas;
+    const renderer = new WebGLRenderer({"canvas": canvas});
+    this.renderer = renderer;
+    scene.background = new Color(0xa9a9a9)
+
+    //Set up resize handlers
+    this.onWindowResize();
+    window.addEventListener( 'resize', this.onWindowResize, false );
+
+    //Add the reference frame cues
+    this.refFrameCues = []
+    // coordinate system
+    this.refFrameCues.push(new ArrowHelper(new Vector3(1, 0, 0).normalize(), new Vector3(0, 0, 0),
+        1, // length
+        0xff0000,
+        0.1,
+        0.1,
+    ))
+    this.refFrameCues.push(new ArrowHelper(new Vector3(0, 1, 0).normalize(), new Vector3(0, 0, 0),
+        1, // length
+        0x00ff00,
+        0.1,
+        0.1,
+    ))
+    this.refFrameCues.push(new ArrowHelper(new Vector3(0, 0, 1).normalize(), new Vector3(0, 0, 0),
+        1, // length
+        0x0000ff,
+        0.1,
+        0.1,
+    ))
+
+    //something that looks vaguely like a camera
+    const camSize = 0.2;
+    const camBodyGeometry = new BoxGeometry(camSize, camSize, camSize);
+    const camLensGeometry = new ConeGeometry(camSize*0.4, camSize*0.8, 30);
+    const camMaterial = new MeshNormalMaterial();
+    const camBody = new Mesh(camBodyGeometry, camMaterial);
+    const camLens = new Mesh(camLensGeometry, camMaterial);
+    camBody.position.set(0,0,0);
+    camLens.rotateZ(Math.PI / 2);
+    camLens.position.set(camSize*0.8,0,0);
+    this.refFrameCues.push(camBody)
+    this.refFrameCues.push(camLens)
+
+    var controls = new TrackballControls(
+        camera,
+        renderer.domElement
+    );
+    controls.rotateSpeed = 1.0;
+    controls.zoomSpeed = 1.2;
+    controls.panSpeed = 0.8;
+    controls.noZoom = false;
+    controls.noPan = false;
+    controls.staticMoving = true;
+    controls.dynamicDampingFactor = 0.3;
+    controls.keys = [65, 83, 68];
+    this.controls = controls;
+
+    this.scene.add(...this.refFrameCues)
+    this.resetCamFirstPerson();
+
+    controls.update();
+
+    function animate() {
+      requestAnimationFrame(animate);
+
+      controls.update();
+      renderer.render(scene, camera);
+
+      //camera.updateMatrixWorld();
+      //console.log("================")
+      //console.log(camera.position);
+      //console.log(camera.rotation);
+      //console.log(camera.up);
+
+    }
+
+    this.drawTargets()
+
+    animate();
+  },
+  methods: {
+    drawTargets() {
+      this.scene.remove(...this.cubes)
+      this.cubes = []
+
+      for (const target of this.targets) {
+        const geometry = new BoxGeometry(0.3 / 5, 0.2, 0.2);
+        const material = new MeshNormalMaterial();
+        let quat = (new Quaternion(
+            target.pose.qx,
+            target.pose.qy,
+            target.pose.qz,
+            target.pose.qw,
+        ))
+        const cube = new Mesh(geometry, material);
+        cube.position.set(target.pose.x, target.pose.y, target.pose.z)
+        cube.rotation.setFromQuaternion(quat);
+        this.cubes.push(cube)
+
+        let arrow = (new ArrowHelper(new Vector3(1, 0, 0).normalize(), new Vector3(0, 0, 0),
+            1, // length
+            0xff0000,
+            0.1,
+            0.1,
+        ));
+        arrow.rotation.setFromQuaternion(quat)
+        arrow.rotateZ(-Math.PI / 2)
+        arrow.position.set(target.pose.x, target.pose.y, target.pose.z)
+        this.cubes.push(arrow);
+
+        arrow = (new ArrowHelper(new Vector3(1, 0, 0).normalize(), new Vector3(0, 0, 0),
+            1, // length
+            0x00ff00,
+            0.1,
+            0.1,
+        ));
+        arrow.rotation.setFromQuaternion(quat)
+        // arrow.rotateX(Math.PI / 2)
+        arrow.position.set(target.pose.x, target.pose.y, target.pose.z)
+        this.cubes.push(arrow);
+        arrow = (new ArrowHelper(new Vector3(1, 0, 0).normalize(), new Vector3(0, 0, 0),
+            1, // length
+            0x0000ff,
+            0.1,
+            0.1,
+        ));
+        arrow.setRotationFromQuaternion(quat)
+        arrow.rotateX(Math.PI / 2)
+        arrow.position.set(target.pose.x, target.pose.y, target.pose.z)
+        this.cubes.push(arrow);
+      }
+      if(this.cubes.length > 0)
+        this.scene.add(...this.cubes);
+    },
+
+    onWindowResize() {
+      var container = document.getElementById("MapContainer")
+      if(container){
+        this.canvas.width = container.clientWidth * 0.95;
+        this.canvas.height = container.clientWidth * 0.85;
+        this.camera.aspect = this.canvas.width / this.canvas.height;
+        this.camera.updateProjectionMatrix();
+        this.renderer.setSize( this.canvas.width, this.canvas.height );
+      }
+    },
+    resetCamThirdPerson(){
+      //Sets camera to third person position
+      this.controls.reset();
+      this.camera.position.set(-1.39,-1.09,1.17);
+      this.camera.up.set(0,0,1);
+      this.controls.target.set(4.0,0.0,0.0);
+      this.controls.update();
+      this.scene.add(...this.refFrameCues)
+    },
+    resetCamFirstPerson(){
+      //Sets camera to first person position
+      this.controls.reset();
+      this.camera.position.set(-0.1,0,0);
+      this.camera.up.set(0,0,1);
+      this.controls.target.set(0.0,0.0,0.0);
+      this.controls.update();
+      this.scene.remove(...this.refFrameCues)
+    },
+  }
+
+
+}
 </script>
 
 <style scoped>
-    #canvasId {
-        width: 400px;
-        height: 400px;
-        background-color: #232C37;
-        border-radius: 5px;
-        border: 2px solid grey;
-        box-shadow: 0 0 5px 1px;
-    }
-
-    th {
-        width: 80px;
-        text-align: center;
-    }
 </style>

photon-client/src/components/pipeline/CameraAndPipelineSelect.vue

@@ -153,7 +153,7 @@
           v-model="currentPipelineType"
           name="Type"
           tooltip="Changes the pipeline type, which changes the type of processing that will happen on input frames"
-          :list="['Reflective Tape', 'Colored Shape']"
+          :list="['Reflective Tape', 'Colored Shape', 'AprilTag']"
           @input="e => showTypeDialog(e)"
         />
       </v-col>

photon-client/src/main.js

@@ -15,11 +15,11 @@ if (process.env.NODE_ENV === "production") {
     Vue.prototype.$address = location.hostname + ":5800";
 }
 
-const wsURL = '//' + Vue.prototype.$address + '/websocket';
+const wsDataURL = '//' + Vue.prototype.$address + '/websocket_data';
 
 import VueNativeSock from 'vue-native-websocket';
 
-Vue.use(VueNativeSock, wsURL, {
+Vue.use(VueNativeSock, wsDataURL, {
     reconnection: true,
     reconnectionDelay: 100,
     connectManually: true,

photon-client/src/plugins/ColorPicker.js

@@ -5,7 +5,7 @@ function initColorPicker() {
     if (!canvas)
         canvas = document.createElement('canvas');
 
-    image = document.querySelector('#normal-stream');
+    image = document.querySelector('#raw-stream');
     if (image !== null) {
       canvas.width = image.width;
       canvas.height = image.height;

photon-client/src/plugins/WebsocketVideoStream.js

@@ -0,0 +1,148 @@
+
+
+export class WebsocketVideoStream{
+
+
+    constructor(drawDiv, streamPort, host) {
+
+        this.drawDiv = drawDiv;
+        this.image = document.getElementById(this.drawDiv);
+        this.streamPort = streamPort;
+        this.serverAddr = "ws://" + host + "/websocket_cameras";
+        this.noStream = false;
+        this.noStreamPrev = false;
+        this.setNoStream();
+        this.ws_connect();
+        this.imgData = null;
+        this.imgDataTime = -1;
+        this.imgObjURL = null;
+        this.frameRxCount = 0;
+
+        requestAnimationFrame(()=>this.animationLoop());
+
+    }
+
+    animationLoop(){
+        var now = window.performance.now();
+
+        if((now - this.imgDataTime) > 2500 && this.imgData != null){
+            //Handle websocket send timeouts by restarting
+            this.setNoStream();
+            this.stopStream();
+            setTimeout(this.startStream.bind(this), 1000); //restart stream one second later
+        } else {
+            if(this.streamPort == null){
+                this.setNoStream();
+            } else if (this.imgData != null) {
+                //From https://stackoverflow.com/questions/67507616/set-image-src-from-image-blob/67507685#67507685
+                if(this.imgObjURL != null){
+                    URL.revokeObjectURL(this.imgObjURL)
+                }
+                this.imgObjURL = URL.createObjectURL(this.imgData);
+
+                //Update the image with the new mimetype and image
+                this.image.src = this.imgObjURL;
+                this.noStream = false;
+
+            } else {
+                //Nothing, hold previous image while waiting for next frame
+            }
+        }
+
+
+        requestAnimationFrame(()=>this.animationLoop());
+    }
+
+    setNoStream() {
+        this.noStreamPrev = this.noStream;
+        this.noStream = true;
+        if(this.noStreamPrev == false && this.noStream == true){
+            //One-shot background change to preserve animation
+            this.image.src = require("../assets/loading.gif");
+        }
+    }
+
+    startStream() {
+        if(this.serverConnectionActive == true && this.streamPort > 0){
+            this.ws.send(JSON.stringify({"cmd": "subscribe", "port":this.streamPort}));
+            this.noStream = false;
+        }
+    }
+
+    stopStream() {
+        if(this.serverConnectionActive == true && this.streamPort > 0){
+            this.ws.send(JSON.stringify({"cmd": "unsubscribe"}));
+            this.noStream = true;
+        }
+    }
+
+    setPort(streamPort){
+        this.stopStream();
+        this.frameRxCount = 0;
+        this.streamPort = streamPort;
+        this.startStream();
+    }
+
+    ws_onOpen() {
+        // Set the flag allowing general server communication
+        this.serverConnectionActive = true;
+        console.log("Connected!");
+        this.startStream();
+    }
+
+    ws_onClose(e) {
+        this.setNoStream();
+
+        //Clear flags to stop server communication
+        this.ws = null;
+        this.serverConnectionActive = false;
+
+        console.log('Camera Socket is closed. Reconnect will be attempted in 0.5 second.', e.reason);
+        setTimeout(this.ws_connect.bind(this), 500);
+
+        if(!e.wasClean){
+            console.error('Socket encountered error!');
+        }
+
+    }
+
+    ws_onError(e){
+        e; //prevent unused failure
+        this.ws.close();
+    }
+
+    ws_onMessage(e){
+        if(typeof e.data === 'string'){
+            //string data from host
+            //TODO - anything to receive info here? Maybe "available streams?"
+        } else {
+            if(e.data.size > 0){
+                //binary data - a frame
+                this.imgData = e.data;
+                this.imgDataTime = window.performance.now();
+                this.frameRxCount++;
+            } else {
+                //TODO - server is sending empty frames?
+            }
+        }
+
+    }
+
+    ws_connect() {
+        this.ws = new WebSocket(this.serverAddr);
+        this.ws.binaryType = "blob";
+        this.ws.onopen = this.ws_onOpen.bind(this);
+        this.ws.onmessage = this.ws_onMessage.bind(this);
+        this.ws.onclose = this.ws_onClose.bind(this);
+        this.ws.onerror = this.ws_onError.bind(this);
+        console.log("Connecting to server " + this.serverAddr);
+    }
+
+    ws_close(){
+        this.ws.close();
+    }
+
+}
+
+
+export default {WebsocketVideoStream}

photon-client/src/store/index.js

@@ -35,8 +35,8 @@ export default new Vuex.Store({
                 tiltDegrees: 0.0,
                 currentPipelineIndex: 0,
                 pipelineNicknames: ["Unknown"],
-                outputStreamPort: 1181,
-                inputStreamPort: 1182,
+                outputStreamPort: 0,
+                inputStreamPort: 0,
                 nickname: "Unknown",
                 videoFormatList: [
                     {
@@ -51,12 +51,13 @@ export default new Vuex.Store({
                 isFovConfigurable: true,
                 calibrated: false,
                 currentPipelineSettings: {
-                    pipelineType: 2, // One of "calib", "driver", "reflective", "shape"
+                    pipelineType: 4, // One of "calib", "driver", "reflective", "shape", "AprilTag"
                     // 2 is reflective
 
                     // Settings that apply to all pipeline types
                     cameraExposure: 1,
                     cameraBrightness: 2,
+                    cameraAutoExposure: false,
                     cameraRedGain: 3,
                     cameraBlueGain: 4,
                     inputImageRotationMode: 0,
@@ -88,7 +89,14 @@ export default new Vuex.Store({
 
                     cornerDetectionAccuracyPercentage: 10,
 
-                    // Settings that apply to shape
+                    // Settings that apply to AprilTag
+                    tagFamily: 0,
+                    decimate: 1.0,
+                    blur: 0.0,
+                    threads: 1,
+                    debug: false,
+                    refineEdges: true,
+                    numIterations: 1,
                 }
             }
         ],
@@ -102,9 +110,18 @@ export default new Vuex.Store({
                     skew: 0,
                     area: 0,
                     // 3D only
-                    pose: {x: 0, y: 0, rot: 0},
-                }]
-            },
+                    pose: {x: 1, y: 1, z: 0, qw: 1, qx: 0, qy: 0, qz: 0},
+                },
+            {
+                // Available in both 2D and 3D
+                pitch: 0,
+                yaw: 0,
+                skew: 0,
+                area: 0,
+                // 3D only
+                pose: {x: 2, y: 3, z: 0, qw: 1, qx: 0, qy: 0, qz: 0},
+            }]
+        },
         settings: {
             general: {
                 version: "Unknown",

photon-client/src/views/CamerasView.vue

@@ -31,14 +31,6 @@
               :label-cols="$vuetify.breakpoint.mdAndUp ? undefined : 7"
             />
             <br>
-            <CVnumberinput
-              v-model="cameraSettings.tiltDegrees"
-              name="Camera pitch"
-              tooltip="How many degrees above the horizontal the physical camera is tilted"
-              :step="0.01"
-              :label-cols="$vuetify.breakpoint.mdAndUp ? undefined : 7"
-            />
-            <br>
             <v-btn
               style="margin-top:10px"
               small
@@ -146,6 +138,24 @@
                             text="Standard Deviation"
                           />
                         </th>
+                        <th class="text-center">
+                          <tooltipped-label
+                            tooltip="Estimated Horizontal FOV, in degrees"
+                            text="Horizontal FOV"
+                          />
+                        </th>
+                        <th class="text-center">
+                          <tooltipped-label
+                            tooltip="Estimated Vertical FOV, in degrees"
+                            text="Vertical FOV"
+                          />
+                        </th>
+                        <th class="text-center">
+                          <tooltipped-label
+                            tooltip="Estimated Diagonal FOV, in degrees"
+                            text="Diagonal FOV"
+                          />
+                        </th>
                       </tr>
                     </thead>
                     <tbody>
@@ -158,6 +168,9 @@
                           {{ isCalibrated(value) ? value.mean.toFixed(2) + "px" : "—" }}
                         </td>
                         <td> {{ isCalibrated(value) ? value.standardDeviation.toFixed(2) + "px" : "—" }} </td>
+                        <td> {{ isCalibrated(value) ? value.horizontalFOV.toFixed(2) + "°" : "—" }} </td>
+                        <td> {{ isCalibrated(value) ? value.verticalFOV.toFixed(2) + "°" : "—" }} </td>
+                        <td> {{ isCalibrated(value) ? value.diagonalFOV.toFixed(2) + "°" : "—" }} </td>
                       </tr>
                     </tbody>
                   </v-simple-table>
@@ -181,10 +194,13 @@
               >
                 <CVslider
                   v-model="$store.getters.currentPipelineSettings.cameraExposure"
+                  :disabled="$store.getters.currentPipelineSettings.cameraAutoExposure"
                   name="Exposure"
                   :min="0"
                   :max="100"
                   slider-cols="8"
+                  step="0.1"
+                  tooltip="Directly controls how much light is allowed to fall onto the sensor, which affects apparent brightness"
                   @input="e => handlePipelineUpdate('cameraExposure', e)"
                 />
                 <CVslider
@@ -195,6 +211,13 @@
                   slider-cols="8"
                   @input="e => handlePipelineUpdate('cameraBrightness', e)"
                 />
+                <CVswitch
+                  v-model="$store.getters.currentPipelineSettings.cameraAutoExposure"
+                  class="pt-2"
+                  name="Auto Exposure"
+                  tooltip="Enables or Disables camera automatic adjustment for current lighting conditions"
+                  @input="e => handlePipelineUpdate('cameraAutoExposure', e)"
+                />
                 <CVslider
                   v-if="$store.getters.currentPipelineSettings.cameraRedGain !== -1"
                   v-model="$store.getters.currentPipelineSettings.cameraRedGain"
@@ -268,7 +291,8 @@
       >
         <template>
           <CVimage
-            :address="$store.getters.streamAddress[1]"
+            :id="cameras-cal"
+            :idx=1
             :disconnected="!$store.state.backendConnected"
             scale="100"
             style="border-radius: 5px;"
@@ -339,6 +363,7 @@
 import CVselect from '../components/common/cv-select';
 import CVnumberinput from '../components/common/cv-number-input';
 import CVslider from '../components/common/cv-slider';
+import CVswitch from '../components/common/cv-switch';
 import CVimage from "../components/common/cv-image";
 import TooltippedLabel from "../components/common/cv-tooltipped-label";
 import jsPDF from "jspdf";
@@ -351,6 +376,7 @@ export default {
         CVselect,
         CVnumberinput,
         CVslider,
+        CVswitch,
         CVimage
     },
     data() {
@@ -396,6 +422,9 @@ export default {
                         if (calib != null) {
                             it['standardDeviation'] = calib.standardDeviation;
                             it['mean'] = calib.perViewErrors.reduce((a, b) => a + b) / calib.perViewErrors.length;
+                            it['horizontalFOV'] = 2 * Math.atan2(it.width/2,calib.intrinsics[0]) * (180/Math.PI);
+                            it['verticalFOV'] = 2 * Math.atan2(it.height/2,calib.intrinsics[4]) * (180/Math.PI);
+                            it['diagonalFOV'] = 2 * Math.atan2(Math.sqrt(it.width**2 + (it.height/(calib.intrinsics[4]/calib.intrinsics[0]))**2)/2,calib.intrinsics[0]) * (180/Math.PI);
                         }
                         filtered.push(it);
                     }
@@ -404,13 +433,11 @@ export default {
                 return filtered
             }
         },
-
         stringResolutionList: {
             get() {
                 return this.filteredResolutionList.map(res => `${res['width']} X ${res['height']}`);
             }
         },
-
         cameraSettings: {
             get() {
                 return this.$store.getters.currentCameraSettings;
@@ -419,7 +446,6 @@ export default {
                 this.$store.commit('cameraSettings', value);
             }
         },
-
         boardType: {
             get() {
                 return this.calibrationData.boardType
@@ -601,8 +627,7 @@ export default {
             this.axios.post("http://" + this.$address + "/api/settings/camera", {
                 "settings": this.cameraSettings,
                 "index": this.$store.state.currentCameraIndex
-            }).then(
-                function (response) {
+            }).then(response => {
                     if (response.status === 200) {
                         this.$store.state.saveBar = true;
                     }
@@ -623,13 +648,14 @@ export default {
             if (this.isCalibrating === true) {
                 data['takeCalibrationSnapshot'] = true
             } else {
+                // This store prevents an edge case of a user not selecting a different resolution, which causes the set logic to not be called
+                this.$store.commit('mutateCalibrationState', {['videoModeIndex']: this.filteredResolutionList[this.selectedFilteredResIndex].index});
                 const calData = this.calibrationData;
                 calData.isCalibrating = true;
                 data['startPnpCalibration'] = calData;
-
                 console.log("starting calibration with index " + calData.videoModeIndex);
             }
-
+            this.$store.commit('currentPipelineIndex', -2);
             this.$socket.send(this.$msgPack.encode(data));
         },
         sendCalibrationFinish() {

photon-client/src/views/PipelineView.vue

@@ -34,9 +34,9 @@
                 :text-color="fpsTooLow ? 'white' : 'grey'"
               >
                 <span class="pr-1">{{ Math.round($store.state.pipelineResults.fps) }}&nbsp;FPS &ndash;</span>
-                <span v-if="!fpsTooLow">{{ Math.min(Math.round($store.state.pipelineResults.latency), 100) }} ms latency</span>
+                <span v-if="!fpsTooLow">{{ Math.min(Math.round($store.state.pipelineResults.latency), 9999) }} ms latency</span>
                 <span v-else-if="!$store.getters.currentPipelineSettings.inputShouldShow">HSV thresholds are too broad; narrow them for better performance</span>
-                <span v-else>stop viewing the color stream for better performance</span>
+                <span v-else>stop viewing the raw stream for better performance</span>
               </v-chip>
               <v-switch
                 v-model="driverMode"
@@ -58,16 +58,16 @@
               >
                 <div style="position: relative; width: 100%; height: 100%;">
                   <cv-image
-                    :id="idx === 0 ? 'normal-stream' : ''"
+                    :id="idx === 0 ? 'raw-stream' : 'processed-stream'"
                     ref="streams"
-                    :address="$store.getters.streamAddress[idx]"
+                    :idx=idx
                     :disconnected="!$store.state.backendConnected"
                     scale="100"
                     :max-height="$store.getters.isDriverMode ? '40vh' : '300px'"
                     :max-height-md="$store.getters.isDriverMode ? '50vh' : '380px'"
                     :max-height-lg="$store.getters.isDriverMode ? '55vh' : '390px'"
                     :max-height-xl="$store.getters.isDriverMode ? '60vh' : '450px'"
-                    :alt="'Stream' + idx"
+                    :alt="'Stream ' + idx"
                     :color-picking="$store.state.colorPicking && idx === 0"
                     @click="onImageClick"
                   />
@@ -85,7 +85,7 @@
           <v-card
             color="primary"
           >
-            <camera-and-pipeline-select @camera-name-changed="reloadStreams" />
+            <camera-and-pipeline-select />
           </v-card>
           <v-card
             :disabled="$store.getters.isDriverMode || $store.state.colorPicking"
@@ -136,15 +136,15 @@
                     color="secondary"
                     class="fill"
                   >
-                    <v-icon>mdi-palette</v-icon>
-                    <span>Normal</span>
+                    <v-icon>mdi-import</v-icon>
+                    <span>Raw</span>
                   </v-btn>
                   <v-btn
                     color="secondary"
                     class="fill"
                   >
-                    <v-icon>mdi-compare</v-icon>
-                    <span>Threshold</span>
+                    <v-icon>mdi-export</v-icon>
+                    <span>Processed</span>
                   </v-btn>
                 </v-btn-toggle>
               </v-col>
@@ -175,7 +175,7 @@
               slider-color="accent"
             >
               <v-tab
-                v-for="(tab, i) in tabs.filter(it => it.name !== '3D' || $store.getters.currentPipelineSettings.solvePNPEnabled)"
+                v-for="(tab, i) in tabs"
                 :key="i"
               >
                 {{ tab.name }}
@@ -261,7 +261,9 @@ import ThresholdTab from './PipelineViews/ThresholdTab';
 import ContoursTab from './PipelineViews/ContoursTab';
 import OutputTab from './PipelineViews/OutputTab';
 import TargetsTab from "./PipelineViews/TargetsTab";
+import Map3DTab from './PipelineViews/Map3DTab';
 import PnPTab from './PipelineViews/PnPTab';
+import AprilTagTab from './PipelineViews/AprilTagTab';
 
 export default {
     name: 'Pipeline',
@@ -273,7 +275,9 @@ export default {
         ContoursTab,
         OutputTab,
         TargetsTab,
+        Map3DTab,
         PnPTab,
+        AprilTagTab,
     },
     data() {
         return {
@@ -308,20 +312,33 @@ export default {
                         name: "Contours",
                         component: "ContoursTab",
                     },
+                    apriltag: {
+                        name: "AprilTag",
+                        component: "AprilTagTab",
+                    },
                     output: {
                         name: "Output",
                         component: "OutputTab",
                     },
                     targets: {
-                        name: "Target Info",
+                        name: "Targets",
                         component: "TargetsTab",
                     },
                     pnp: {
-                        name: "3D",
+                        name: "PnP",
                         component: "PnPTab",
+                    },
+                    map3d: {
+                        name: "3D",
+                        component: "Map3DTab",
                     }
                 };
 
+                // If not in 3d, name "3D" is illegal
+                const allow3d = this.$store.getters.currentPipelineSettings.solvePNPEnabled;
+                // If in apriltag, "Threshold" and "Contours" are illegal -- otherwise "AprilTag" is
+                const isAprilTag = (this.$store.getters.currentPipelineSettings.pipelineType - 2) === 2;
+
                 // 2D array of tab names and component names; each sub-array is a separate tab group
                 let ret = [];
                 if (this.$vuetify.breakpoint.smAndDown || this.$store.getters.isDriverMode || (this.$vuetify.breakpoint.mdAndDown && !this.$store.state.compactMode)) {
@@ -329,22 +346,37 @@ export default {
                     ret[0] = Object.values(tabs);
                 } else if (this.$vuetify.breakpoint.mdAndDown || !this.$store.state.compactMode) {
                     // Two tab groups, one with "input, threshold, contours, output" and the other with "target info, 3D"
-                    ret[0] = [tabs.input, tabs.threshold, tabs.contours, tabs.output];
-                    ret[1] = [tabs.targets, tabs.pnp];
+                    ret[0] = [tabs.input, tabs.threshold, tabs.contours, tabs.apriltag, tabs.output];
+                    ret[1] = [tabs.targets, tabs.pnp, tabs.map3d];
                 } else if (this.$vuetify.breakpoint.lgAndDown) {
                     // Three tab groups, one with "input", one with "threshold, contours, output", and the other with "target info, 3D"
                     ret[0] = [tabs.input];
-                    ret[1] = [tabs.threshold, tabs.contours, tabs.output];
-                    ret[2] = [tabs.targets, tabs.pnp];
+                    ret[1] = [tabs.threshold, tabs.contours, tabs.apriltag, tabs.output];
+                    ret[2] = [tabs.targets, tabs.pnp, tabs.map3d];
                 } else if (this.$vuetify.breakpoint.xl) {
                     // Three tab groups, one with "input", one with "threshold, contours", and the other with "output, target info, 3D"
                     ret[0] = [tabs.input];
                     ret[1] = [tabs.threshold];
-                    ret[2] = [tabs.contours, tabs.output];
-                    ret[3] = [tabs.targets, tabs.pnp];
+                    ret[2] = [tabs.contours, tabs.apriltag, tabs.output];
+                    ret[3] = [tabs.targets, tabs.pnp, tabs.map3d];
                 }
 
-                return ret;
+                for(let i = 0; i < ret.length; i++) {
+                  const group = ret[i];
+
+                  // All the tabs we allow
+                  const filteredGroup = group.filter(it =>
+                          !(!allow3d && it.name === "3D") //Filter out 3D tab any time 3D isn't calibrated
+                       && !((!allow3d || isAprilTag) && it.name === "PnP") //Filter out the PnP config tab if 3D isn't available, or we're doing Apriltags
+                       && !(isAprilTag && (it.name === "Threshold")) //Filter out threshold tab if we're doing apriltags
+                       && !(isAprilTag && (it.name === "Contours")) //Filter out contours if we're doing Apriltag
+                       && !(!isAprilTag && it.name === "AprilTag") //Filter out apriltag unless we actually are doing Apriltags
+                      );
+                  ret[i] = filteredGroup;
+                }
+
+                // One last filter to remove empty lists
+                return ret.filter(it => it !== undefined && it.length > 0);
             }
         },
         processingMode: {

photon-client/src/views/PipelineViews/AprilTagTab.vue

@@ -0,0 +1,136 @@
+<template>
+  <div>
+    <v-select
+      v-model="selectedFamily"
+      dark
+      color="accent"
+      item-color="secondary"
+      label="Select target family"
+      :items="familyList"
+      @input="handlePipelineUpdate('tagFamily', targetList.indexOf(selectedModel))"
+    />
+    <CVslider
+      v-model="decimate"
+      class="pt-2"
+      slider-cols="8"
+      name="Decimate"
+      min="0"
+      max="3"
+      step=".5"
+      tooltip="Increases FPS at the expense of range by reducing image resolution initially"
+      @input="handlePipelineData('decimate')"
+    />
+    <CVslider
+      v-model="blur"
+      class="pt-2"
+      slider-cols="8"
+      name="Blur"
+      min="0"
+      max="5"
+      step=".01"
+      tooltip="Gaussian blur added to the image, high FPS cost for slightly decreased noise"
+      @input="handlePipelineData('blur')"
+    />
+    <CVslider
+      v-model="threads"
+      class="pt-2"
+      slider-cols="8"
+      name="Threads"
+      min="1"
+      max="8"
+      step="1"
+      tooltip="Number of threads spawned by the AprilTag detector"
+      @input="handlePipelineData('threads')"
+    />
+    <CVswitch
+      v-model="refineEdges"
+      class="pt-2"
+      slider-cols="8"
+      name="Refine Edges"
+      tooltip="Further refines the apriltag corner position initial estimate, suggested left on"
+      @input="handlePipelineData('refineEdges')"
+    />
+    <CVslider
+      v-model="numIterations"
+      class="pt-2 pb-4"
+      slider-cols="8"
+      name="Pose Estimation Iterations"
+      min="0"
+      max="500"
+      step="1"
+      tooltip="Number of iterations the pose estimation algorithm will run, 50-100 is a good starting point"
+      @input="handlePipelineData('numIterations')"
+    />
+  </div>
+</template>
+
+<script>
+    import CVslider from '../../components/common/cv-slider'
+    import CVswitch from '../../components/common/cv-switch'
+
+    export default {
+        name: "AprilTag",
+        components: {
+          CVslider,
+          CVswitch,
+        },
+        data() {
+            return {
+              familyList: ["tag36h11"],
+            }
+        },
+        computed: {
+          selectedFamily: {
+            get() {
+                let ret = this.$store.getters.currentPipelineSettings.tagFamily
+                return this.familyList[ret];
+            },
+            set(val) {
+                this.$store.commit("mutatePipeline", {"tagFamily": this.familyList.indexOf(val)})
+            }
+          },
+          decimate: {
+            get() {
+                return this.$store.getters.currentPipelineSettings.decimate
+            },
+            set(val) {
+                this.$store.commit("mutatePipeline", {"decimate": val});
+            }
+          },
+          numIterations: {
+            get() {
+                return this.$store.getters.currentPipelineSettings.numIterations
+            },
+            set(val) {
+                this.$store.commit("mutatePipeline", {"numIterations": val});
+            }
+          },
+          blur: {
+            get() {
+                return this.$store.getters.currentPipelineSettings.blur
+            },
+            set(val) {
+                this.$store.commit("mutatePipeline", {"blur": val});
+            }
+          },
+          threads: {
+            get() {
+                return this.$store.getters.currentPipelineSettings.threads
+            },
+            set(val) {
+                this.$store.commit("mutatePipeline", {"threads": val});
+            }
+          },
+          refineEdges: {
+            get() {
+                return this.$store.getters.currentPipelineSettings.refineEdges
+            },
+            set(val) {
+                this.$store.commit("mutatePipeline", {"refineEdges": val});
+            }
+          },
+        },
+        methods: {
+        }
+    }
+</script>

photon-client/src/views/PipelineViews/ContoursTab.vue

@@ -19,12 +19,12 @@
       @input="handlePipelineData('contourRatio')"
     />
     <CVselect
-        v-model="contourTargetOrientation"
-        name="Target Orientation"
-        tooltip="Used to determine how to calculate target landmarks, as well as aspect ratio"
-        :list="['Portrait', 'Landscape']"
-        @input="handlePipelineData('contourTargetOrientation')"
-        @rollback="e=> rollback('contourTargetOrientation', e)"
+      v-model="contourTargetOrientation"
+      name="Target Orientation"
+      tooltip="Used to determine how to calculate target landmarks, as well as aspect ratio"
+      :list="['Portrait', 'Landscape']"
+      @input="handlePipelineData('contourTargetOrientation')"
+      @rollback="e=> rollback('contourTargetOrientation', e)"
     />
     <CVrangeSlider
       v-if="currentPipelineType() !== 3"

photon-client/src/views/PipelineViews/InputTab.vue

@@ -2,11 +2,12 @@
   <div>
     <CVslider
       v-model="cameraExposure"
+      :disabled="cameraAutoExposure"
       name="Exposure"
       min="0"
       max="100"
       step="0.1"
-      tooltip="Directly controls how much light is allowed to fall onto the sensor, which affects brightness"
+      tooltip="Directly controls how much light is allowed to fall onto the sensor, which affects apparent brightness"
       :slider-cols="largeBox"
       @input="handlePipelineData('cameraExposure')"
       @rollback="e => rollback('cameraExposure', e)"
@@ -21,10 +22,28 @@
       @input="handlePipelineData('cameraBrightness')"
       @rollback="e => rollback('cameraBrightness', e)"
     />
+    <CVswitch
+      v-model="cameraAutoExposure"
+      class="pt-2"
+      name="Auto Exposure"
+      tooltip="Enables or Disables camera automatic adjustment for current lighting conditions"
+      @input="handlePipelineData('cameraAutoExposure')"
+    />
+    <CVslider
+      v-if="cameraGain >= 0"
+      v-model="cameraGain"
+      name="Camera Gain"
+      min="0"
+      max="100"
+      tooltip="Controls camera gain, similar to brightness"
+      :slider-cols="largeBox"
+      @input="handlePipelineData('cameraGain')"
+      @rollback="e => rollback('cameraGain', e)"
+    />
     <CVslider
       v-if="cameraRedGain !== -1"
       v-model="cameraRedGain"
-      name="Red AWB Gain"
+      name="Red Balance"
       min="0"
       max="100"
       tooltip="Controls red automatic white balance gain, which affects how the camera captures colors in different conditions"
@@ -35,7 +54,7 @@
     <CVslider
       v-if="cameraBlueGain !== -1"
       v-model="cameraBlueGain"
-      name="Blue AWB Gain"
+      name="Blue Balance"
       min="0"
       max="100"
       tooltip="Controls blue automatic white balance gain, which affects how the camera captures colors in different conditions"
@@ -75,6 +94,7 @@
 <script>
     import CVslider from '../../components/common/cv-slider'
     import CVselect from '../../components/common/cv-select'
+    import CVswitch from '../../components/common/cv-switch'
 
     const unfilteredStreamDivisors = [1, 2, 4, 6];
 
@@ -83,6 +103,7 @@
         components: {
             CVslider,
             CVselect,
+            CVswitch,
         },
         // eslint-disable-next-line vue/require-prop-types
         props: ['value'],
@@ -108,6 +129,14 @@
                     this.$store.commit("mutatePipeline", {"cameraExposure": parseFloat(val)});
                 }
             },
+            cameraAutoExposure: {
+                get() {
+                    return this.$store.getters.currentPipelineSettings.cameraAutoExposure;
+                },
+                set(val) {
+                    this.$store.commit("mutatePipeline", {"cameraAutoExposure": val});
+                }
+            },
             cameraBrightness: {
                 get() {
                     return parseInt(this.$store.getters.currentPipelineSettings.cameraBrightness)
@@ -116,6 +145,14 @@
                     this.$store.commit("mutatePipeline", {"cameraBrightness": parseInt(val)});
                 }
             },
+            cameraGain: {
+                get() {
+                    return parseInt(this.$store.getters.currentPipelineSettings.cameraGain)
+                },
+                set(val) {
+                    this.$store.commit("mutatePipeline", {"cameraGain": parseInt(val)});
+                }
+            },
             cameraRedGain: {
                 get() {
                     return parseInt(this.$store.getters.currentPipelineSettings.cameraRedGain)

photon-client/src/views/PipelineViews/Map3DTab.vue

@@ -0,0 +1,53 @@
+<template>
+  <div>
+    <mini-map
+      class="miniMapClass"
+      :targets="targets"
+      :horizontal-f-o-v="horizontalFOV"
+    />
+  </div>
+</template>
+
+<script>
+    import miniMap from '../../components/pipeline/3D/MiniMap';
+
+    export default {
+        name: "Map3D",
+        components: {
+            miniMap
+        },
+        data() {
+            return {
+            }
+        },
+        computed: {
+            targets: {
+                get() {
+                    return this.$store.getters.currentPipelineResults.targets;
+                }
+            },
+            horizontalFOV: {
+                get() {
+                    let index = this.$store.getters.currentPipelineSettings.cameraVideoModeIndex;
+                    let FOV = this.$store.getters.currentCameraSettings.fov;
+                    let resolution = this.$store.getters.videoFormatList[index];
+                    let diagonalView = FOV * (Math.PI / 180);
+                    let diagonalAspect = Math.hypot(resolution.width, resolution.height);
+                    return Math.atan(Math.tan(diagonalView / 2) * (resolution.width / diagonalAspect)) * 2 * (180 / Math.PI)
+                }
+            },
+        },
+        methods: {
+        }
+    }
+</script>
+
+<style scoped>
+    .miniMapClass {
+        width: 400px !important;
+        height: 100% !important;
+
+        margin-left: auto;
+        margin-right: auto;
+    }
+</style>

photon-client/src/views/PipelineViews/PnPTab.vue

@@ -6,7 +6,6 @@
       type="file"
       accept=".csv"
       style="display: none;"
-
       @change="readFile"
     >
 
@@ -32,11 +31,7 @@
       @input="handlePipelineData('cornerDetectionAccuracyPercentage')"
       @rollback="e => rollback('cornerDetectionAccuracyPercentage', e)"
     />
-    <mini-map
-      class="miniMapClass"
-      :targets="targets"
-      :horizontal-f-o-v="horizontalFOV"
-    />
+
     <v-snackbar
       v-model="snack"
       top
@@ -49,14 +44,12 @@
 
 <script>
     import Papa from 'papaparse';
-    import miniMap from '../../components/pipeline/3D/MiniMap';
     import CVslider from '../../components/common/cv-slider'
 
     export default {
         name: "PnP",
         components: {
-            CVslider,
-            miniMap
+            CVslider
         },
         data() {
             return {
@@ -87,21 +80,6 @@
                     this.$store.commit("mutatePipeline", {"cornerDetectionAccuracyPercentage": val});
                 }
             },
-            targets: {
-                get() {
-                    return this.$store.getters.currentPipelineResults.targets;
-                }
-            },
-            horizontalFOV: {
-                get() {
-                    let index = this.$store.getters.currentPipelineSettings.cameraVideoModeIndex;
-                    let FOV = this.$store.getters.currentCameraSettings.fov;
-                    let resolution = this.$store.getters.videoFormatList[index];
-                    let diagonalView = FOV * (Math.PI / 180);
-                    let diagonalAspect = Math.hypot(resolution.width, resolution.height);
-                    return Math.atan(Math.tan(diagonalView / 2) * (resolution.width / diagonalAspect)) * 2 * (180 / Math.PI)
-                }
-            },
         },
         methods: {
             readFile(event) {

photon-client/src/views/PipelineViews/TargetsTab.vue

@@ -18,29 +18,40 @@
               <th class="text-center">
                 Target
               </th>
+              <th
+                v-if="$store.getters.pipelineType === 4"
+                class="text-center"
+              >
+                Fiducial ID
+              </th>
               <template v-if="!$store.getters.currentPipelineSettings.solvePNPEnabled">
                 <th class="text-center">
-                  Pitch
+                  Pitch,&nbsp;&deg;
                 </th>
                 <th class="text-center">
-                  Yaw
+                  Yaw,&nbsp;&deg;
                 </th>
                 <th class="text-center">
-                  Skew
+                  Skew,&nbsp;&deg;
+                </th>
+                <th class="text-center">
+                  Area, %
                 </th>
               </template>
-              <th class="text-center">
-                Area
-              </th>
-              <template v-if="$store.getters.currentPipelineSettings.solvePNPEnabled">
+              <template v-else>
                 <th class="text-center">
-                  X
+                  X,&nbsp;m
                 </th>
                 <th class="text-center">
-                  Y
+                  Y,&nbsp;m
                 </th>
                 <th class="text-center">
-                  Angle
+                  Z Angle,&nbsp;&deg;
+                </th>
+              </template>
+              <template v-if="$store.getters.pipelineType === 4 && $store.getters.currentPipelineSettings.solvePNPEnabled">
+                <th class="text-center">
+                  Ambiguity
                 </th>
               </template>
             </tr>
@@ -51,17 +62,29 @@
               :key="index"
             >
               <td>{{ index }}</td>
+              <td v-if="$store.getters.pipelineType === 4">
+                {{ parseInt(value.fiducialId) }}
+              </td>
               <template v-if="!$store.getters.currentPipelineSettings.solvePNPEnabled">
                 <td>{{ parseFloat(value.pitch).toFixed(2) }}</td>
                 <td>{{ parseFloat(value.yaw).toFixed(2) }}</td>
                 <td>{{ parseFloat(value.skew).toFixed(2) }}</td>
+                <td>{{ parseFloat(value.area).toFixed(2) }}</td>
               </template>
-              <td>{{ parseFloat(value.area).toFixed(2) }}</td>
-              <template v-if="$store.getters.currentPipelineSettings.solvePNPEnabled">
-                <!-- TODO: Make sure that units are correct -->
+              <template v-else-if="$store.getters.currentPipelineSettings.solvePNPEnabled && $store.getters.pipelineType === 4">
                 <td>{{ parseFloat(value.pose.x).toFixed(2) }}&nbsp;m</td>
                 <td>{{ parseFloat(value.pose.y).toFixed(2) }}&nbsp;m</td>
-                <td>{{ parseFloat(value.pose.rot).toFixed(2) }}&deg;</td>
+                <td>{{ (parseFloat(value.pose.angle_z) * 180 / Math.PI).toFixed(2) }}&deg;</td>
+              </template>
+              <template v-else-if="$store.getters.currentPipelineSettings.solvePNPEnabled">
+                <td>{{ parseFloat(value.pose.x).toFixed(2) }}&nbsp;m</td>
+                <td>{{ parseFloat(value.pose.y).toFixed(2) }}&nbsp;m</td>
+                <td>{{ (parseFloat(value.pose.angle_z) * 180 / Math.PI).toFixed(2) }}&deg;</td>
+              </template>
+              <template v-if="$store.getters.pipelineType === 4 && $store.getters.currentPipelineSettings.solvePNPEnabled">
+                <td>
+                  {{ parseFloat(value.ambiguity).toFixed(2) }}
+                </td>
               </template>
             </tr>
           </tbody>

photon-client/src/views/SettingsViews/General.vue

@@ -49,22 +49,46 @@
           <th class="infoElem">
             Disk Usage
           </th>
+          <th class="infoElem">
+            <v-tooltip top>
+              <template v-slot:activator="{ on, attrs }">
+                <span
+                  v-bind="attrs"
+                  v-on="on"
+                >
+                ⓘ CPU Throttling
+                </span>
+              </template>
+              <span>
+                    Current or Previous Reason for the cpu being held back from maximum performance.
+              </span>
+            </v-tooltip>
+          </th>
+          <th class="infoElem">
+            CPU Uptime
+          </th>
         </tr>
         <tr v-if="metrics.cpuUtil !== 'N/A'">
           <td class="infoElem">
-            {{ metrics.cpuUtil.replace(" ", "") }}%
+            {{ metrics.cpuUtil }}%
           </td>
           <td class="infoElem">
             {{ parseInt(metrics.cpuTemp) }}&deg;&nbsp;C
           </td>
           <td class="infoElem">
-            {{ metrics.ramUtil.replace(" ", "") }}MB of {{ metrics.cpuMem }}MB
+            {{ metrics.ramUtil }}MB of {{ metrics.cpuMem }}MB
           </td>
           <td class="infoElem">
-            {{ metrics.gpuMemUtil.replace(" ", "") }}MB of {{ metrics.gpuMem }}MB
+            {{ metrics.gpuMemUtil }}MB of {{ metrics.gpuMem }}MB
           </td>
           <td class="infoElem">
-            {{ metrics.diskUtilPct.replace(" ", "") }}
+            {{ metrics.diskUtilPct }}
+          </td>
+          <td class="infoElem">
+            {{ metrics.cpuThr }}
+          </td>
+          <td class="infoElem">
+            {{ metrics.cpuUptime }}
           </td>
         </tr>
         <tr v-if="metrics.cpuUtil === 'N/A'">
@@ -83,6 +107,12 @@
           <td class="infoElem">
             ---
           </td>
+          <td class="infoElem">
+            ---
+          </td>
+          <td class="infoElem">
+            ---
+          </td>
         </tr>
       </table>
     </v-row>

photon-client/src/views/SettingsViews/Networking.vue

@@ -66,7 +66,16 @@
     >
       Save
     </v-btn>
+    <v-snackbar
+      v-model="snack"
+      top
+      :color="snackbar.color"
+      timeout="5000"
+    >
+      <span>{{ snackbar.text }}</span>
+    </v-snackbar>
     <v-divider class="mt-4 mb-4" />
+    <!-- TEMP - RIO finder is not currently enabled
     <v-row>
       <v-col
         cols="12"
@@ -125,6 +134,7 @@
         </v-simple-table>
       </v-col>
     </v-row>
+    -->
   </div>
 </template>
 
@@ -237,7 +247,7 @@ export default {
         },
         sendGeneralSettings() {
             this.axios.post("http://" + this.$address + "/api/settings/general", this.settings).then(
-                function (response) {
+                response => {
                     if (response.status === 200) {
                         this.snackbar = {
                             color: "success",
@@ -246,7 +256,7 @@ export default {
                         this.snack = true;
                     }
                 },
-                function (error) {
+                error => {
                     this.snackbar = {
                         color: "error",
                         text: (error.response || {data: "Couldn't save settings"}).data

photon-core/.gitignore

@@ -9,5 +9,7 @@ build
 build/*
 photonvision/*
 photonvision_config/*
+photon-server/lib/*
+photon-server/package-lock.json
 
 src/main/java/org/photonvision/PhotonVersion.java

photon-core/src/main/java/org/photonvision/common/configuration/CameraConfiguration.java

@@ -20,7 +20,6 @@ package org.photonvision.common.configuration;
 import com.fasterxml.jackson.annotation.JsonCreator;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import edu.wpi.first.math.geometry.Rotation2d;
 import java.util.ArrayList;
 import java.util.List;
 import org.photonvision.common.logging.LogGroup;
@@ -50,7 +49,6 @@ public class CameraConfiguration {
     public double FOV = 70;
     public final List<CameraCalibrationCoefficients> calibrations;
     public int currentPipelineIndex = 0;
-    public Rotation2d camPitch = new Rotation2d();
 
     public int streamIndex = 0; // 0 index means ports [1181, 1182], 1 means [1183, 1184], etc...
 
@@ -74,6 +72,7 @@ public class CameraConfiguration {
         logger.debug(
                 "Creating USB camera configuration for "
                         + cameraType
+                        + " "
                         + baseName
                         + " (AKA "
                         + nickname
@@ -90,8 +89,7 @@ public class CameraConfiguration {
             @JsonProperty("path") String path,
             @JsonProperty("cameraType") CameraType cameraType,
             @JsonProperty("calibration") List<CameraCalibrationCoefficients> calibrations,
-            @JsonProperty("currentPipelineIndex") int currentPipelineIndex,
-            @JsonProperty("camPitch") Rotation2d camPitch) {
+            @JsonProperty("currentPipelineIndex") int currentPipelineIndex) {
         this.baseName = baseName;
         this.uniqueName = uniqueName;
         this.nickname = nickname;
@@ -100,11 +98,11 @@ public class CameraConfiguration {
         this.cameraType = cameraType;
         this.calibrations = calibrations != null ? calibrations : new ArrayList<>();
         this.currentPipelineIndex = currentPipelineIndex;
-        this.camPitch = camPitch;
 
         logger.debug(
                 "Creating camera configuration for "
                         + cameraType
+                        + " "
                         + baseName
                         + " (AKA "
                         + nickname

photon-core/src/main/java/org/photonvision/common/configuration/ConfigManager.java

@@ -438,7 +438,7 @@ public class ConfigManager {
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
-                logger.error("Exception waiting for settings semaphor", e);
+                logger.error("Exception waiting for settings semaphore", e);
             }
         }
     }

photon-core/src/main/java/org/photonvision/common/configuration/HardwareConfig.java

@@ -41,6 +41,8 @@ public class HardwareConfig {
     public final String cpuTempCommand;
     public final String cpuMemoryCommand;
     public final String cpuUtilCommand;
+    public final String cpuThrottleReasonCmd;
+    public final String cpuUptimeCommand;
     public final String gpuMemoryCommand;
     public final String ramUtilCommand;
     public final String gpuMemUsageCommand;
@@ -65,6 +67,8 @@ public class HardwareConfig {
         cpuTempCommand = "";
         cpuMemoryCommand = "";
         cpuUtilCommand = "";
+        cpuThrottleReasonCmd = "";
+        cpuUptimeCommand = "";
         gpuMemoryCommand = "";
         ramUtilCommand = "";
         ledBlinkCommand = "";
@@ -91,6 +95,8 @@ public class HardwareConfig {
             String cpuTempCommand,
             String cpuMemoryCommand,
             String cpuUtilCommand,
+            String cpuThrottleReasonCmd,
+            String cpuUptimeCommand,
             String gpuMemoryCommand,
             String ramUtilCommand,
             String gpuMemUsageCommand,
@@ -111,6 +117,8 @@ public class HardwareConfig {
         this.cpuTempCommand = cpuTempCommand;
         this.cpuMemoryCommand = cpuMemoryCommand;
         this.cpuUtilCommand = cpuUtilCommand;
+        this.cpuThrottleReasonCmd = cpuThrottleReasonCmd;
+        this.cpuUptimeCommand = cpuUptimeCommand;
         this.gpuMemoryCommand = gpuMemoryCommand;
         this.ramUtilCommand = ramUtilCommand;
         this.gpuMemUsageCommand = gpuMemUsageCommand;

photon-core/src/main/java/org/photonvision/common/configuration/PhotonConfiguration.java

@@ -128,7 +128,8 @@ public class PhotonConfiguration {
 
     public static class UICameraConfiguration {
         @SuppressWarnings("unused")
-        public double fov, tiltDegrees;
+        public double fov;
+
         public String nickname;
         public HashMap<String, Object> currentPipelineSettings;
         public int currentPipelineIndex;

photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NTDataPublisher.java

@@ -189,10 +189,17 @@ public class NTDataPublisher implements CVPipelineResultConsumer {
             targetAreaEntry.forceSetDouble(bestTarget.getArea());
             targetSkewEntry.forceSetDouble(bestTarget.getSkew());
 
-            var poseX = bestTarget.getCameraToTarget().getTranslation().getX();
-            var poseY = bestTarget.getCameraToTarget().getTranslation().getY();
-            var poseRot = bestTarget.getCameraToTarget().getRotation().getDegrees();
-            targetPoseEntry.forceSetDoubleArray(new double[] {poseX, poseY, poseRot});
+            var pose = bestTarget.getBestCameraToTarget3d();
+            targetPoseEntry.forceSetDoubleArray(
+                    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()
+                    });
 
             var targetOffsetPoint = bestTarget.getTargetOffsetPoint();
             bestTargetPosX.forceSetDouble(targetOffsetPoint.x);
@@ -224,7 +231,10 @@ public class NTDataPublisher implements CVPipelineResultConsumer {
                             t.getPitch(),
                             t.getArea(),
                             t.getSkew(),
-                            t.getCameraToTarget(),
+                            t.getFiducialId(),
+                            t.getBestCameraToTarget3d(),
+                            t.getAltCameraToTarget3d(),
+                            t.getPoseAmbiguity(),
                             cornerList));
         }
         return ret;

photon-core/src/main/java/org/photonvision/common/dataflow/networktables/NetworkTablesManager.java

@@ -23,6 +23,7 @@ import edu.wpi.first.networktables.NetworkTableInstance;
 import java.util.HashMap;
 import java.util.function.Consumer;
 import org.photonvision.PhotonVersion;
+import org.photonvision.common.configuration.ConfigManager;
 import org.photonvision.common.configuration.NetworkConfig;
 import org.photonvision.common.dataflow.DataChangeService;
 import org.photonvision.common.dataflow.events.OutgoingUIEvent;
@@ -37,8 +38,11 @@ public class NetworkTablesManager {
     private final String kRootTableName = "/photonvision";
     public final NetworkTable kRootTable = ntInstance.getTable(kRootTableName);
 
+    private boolean isRetryingConnection = false;
+
     private NetworkTablesManager() {
         ntInstance.addLogger(new NTLogger(), 0, 255); // to hide error messages
+        TimedTaskManager.getInstance().addTask("NTManager", this::ntTick, 5000);
     }
 
     private static NetworkTablesManager INSTANCE;
@@ -109,17 +113,11 @@ public class NetworkTablesManager {
     }
 
     private void setClientMode(int teamNumber) {
-        logger.info("Starting NT Client");
+        if (!isRetryingConnection) logger.info("Starting NT Client");
         ntInstance.stopServer();
 
         ntInstance.startClientTeam(teamNumber);
         ntInstance.startDSClient();
-        if (ntInstance.isConnected()) {
-            logger.info("[NetworkTablesManager] Connected to the robot!");
-        } else {
-            logger.error(
-                    "[NetworkTablesManager] Could not connect to the robot! Will retry in the background...");
-        }
         broadcastVersion();
     }
 
@@ -129,4 +127,22 @@ public class NetworkTablesManager {
         ntInstance.startServer();
         broadcastVersion();
     }
+
+    // So it seems like if Photon starts before the robot NT server does, and both aren't static IP,
+    // it'll never connect. This hack works around it by restarting the client/server while the nt
+    // instance
+    // isn't connected, same as clicking the save button in the settings menu (or restarting the
+    // service)
+    private void ntTick() {
+        if (!ntInstance.isConnected()
+                && !ConfigManager.getInstance().getConfig().getNetworkConfig().runNTServer) {
+            setConfig(ConfigManager.getInstance().getConfig().getNetworkConfig());
+        }
+
+        if (!ntInstance.isConnected() && !isRetryingConnection) {
+            isRetryingConnection = true;
+            logger.error(
+                    "[NetworkTablesManager] Could not connect to the robot! Will retry in the background...");
+        }
+    }
 }

photon-core/src/main/java/org/photonvision/common/hardware/Platform.java

@@ -49,20 +49,20 @@ public enum Platform {
 
     // These are queried on init and should never change after
     public static final Platform currentPlatform = getCurrentPlatform();
-    protected static final String currentPiVersionStr = getPiVersionString();
+    static final String currentPiVersionStr = getPiVersionString();
     public static final PiVersion currentPiVersion = PiVersion.getPiVersion();
 
-    private static String UnknownPlatformString =
+    private static final String UnknownPlatformString =
             String.format("Unknown Platform. OS: %s, Architecture: %s", OS_NAME, OS_ARCH);
 
-    public boolean isWindows() {
-        return this == WINDOWS_64 || this == WINDOWS_32;
+    public static boolean isWindows() {
+        return currentPlatform == WINDOWS_64 || currentPlatform == WINDOWS_32;
     }
 
     public static boolean isLinux() {
-        return getCurrentPlatform() == LINUX_64
-                || getCurrentPlatform() == LINUX_RASPBIAN
-                || getCurrentPlatform() == LINUX_ARM64;
+        return currentPlatform == LINUX_64
+                || currentPlatform == LINUX_RASPBIAN
+                || currentPlatform == LINUX_ARM64;
     }
 
     public static boolean isRaspberryPi() {

photon-core/src/main/java/org/photonvision/common/hardware/VisionLED.java

@@ -85,6 +85,8 @@ public class VisionLED {
                 pigpioSocket.generateAndSendWaveform(pulseLengthMillis, blinkCount, ledPins);
             } catch (PigpioException e) {
                 logger.error("Failed to blink!", e);
+            } catch (NullPointerException e) {
+                logger.error("Failed to blink, pigpio internal issue!", e);
             }
         } else {
             for (GPIOBase led : visionLEDs) {
@@ -100,13 +102,19 @@ public class VisionLED {
                 pigpioSocket.waveTxStop();
             } catch (PigpioException e) {
                 logger.error("Failed to stop blink!", e);
+            } catch (NullPointerException e) {
+                logger.error("Failed to blink, pigpio internal issue!", e);
             }
         }
-        // if the user has set an LED brightness other than 100%, use that instead
-        if (mappedBrightnessPercentage == 100 || !state) {
-            visionLEDs.forEach((led) -> led.setState(state));
-        } else {
-            visionLEDs.forEach((led) -> led.setBrightness(mappedBrightnessPercentage));
+        try {
+            // if the user has set an LED brightness other than 100%, use that instead
+            if (mappedBrightnessPercentage == 100 || !state) {
+                visionLEDs.forEach((led) -> led.setState(state));
+            } else {
+                visionLEDs.forEach((led) -> led.setBrightness(mappedBrightnessPercentage));
+            }
+        } catch (NullPointerException e) {
+            logger.error("Failed to blink, pigpio internal issue!", e);
         }
     }
 

photon-core/src/main/java/org/photonvision/common/hardware/metrics/CPUMetrics.java

@@ -40,4 +40,12 @@ public class CPUMetrics extends MetricsBase {
     public String getUtilization() {
         return execute(cpuUtilizationCommand);
     }
+
+    public String getUptime() {
+        return execute(cpuUptimeCommand);
+    }
+
+    public String getThrottleReason() {
+        return execute(cpuThrottleReasonCmd);
+    }
 }

photon-core/src/main/java/org/photonvision/common/hardware/metrics/MetricsBase.java

@@ -26,7 +26,7 @@ import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.ShellExec;
 
 public abstract class MetricsBase {
-    private static final Logger logger = new Logger(MetricsBase.class, LogGroup.General);
+    static final Logger logger = new Logger(MetricsBase.class, LogGroup.General);
     // CPU
     public static String cpuMemoryCommand = "vcgencmd get_mem arm | grep -Eo '[0-9]+'";
     public static String cpuTemperatureCommand =
@@ -34,6 +34,15 @@ public abstract class MetricsBase {
     public static String cpuUtilizationCommand =
             "top -bn1 | grep \"Cpu(s)\" | sed \"s/.*, *\\([0-9.]*\\)%* id.*/\\1/\" | awk '{print 100 - $1}'";
 
+    public static String cpuThrottleReasonCmd =
+            "if ((  $(( $(vcgencmd get_throttled | grep -Eo 0x[0-9a-fA-F]*) & 0x01 )) != 0x00 )); then echo \"LOW VOLTAGE\"; "
+                    + "elif ((  $(( $(vcgencmd get_throttled | grep -Eo 0x[0-9a-fA-F]*) & 0x08 )) != 0x00 )); then echo \"HIGH TEMP\"; "
+                    + "elif ((  $(( $(vcgencmd get_throttled | grep -Eo 0x[0-9a-fA-F]*) & 0x10000 )) != 0x00 )); then echo \"Prev. Low Voltage\"; "
+                    + "elif ((  $(( $(vcgencmd get_throttled | grep -Eo 0x[0-9a-fA-F]*) & 0x80000 )) != 0x00 )); then echo \"Prev. High Temp\"; "
+                    + " else echo \"None\"; fi";
+
+    public static String cpuUptimeCommand = "uptime -p | cut -c 4-";
+
     // GPU
     public static String gpuMemoryCommand = "vcgencmd get_mem gpu | grep -Eo '[0-9]+'";
     public static String gpuMemUsageCommand = "vcgencmd get_mem malloc | grep -Eo '[0-9]+'";
@@ -51,6 +60,8 @@ public abstract class MetricsBase {
         cpuMemoryCommand = config.cpuMemoryCommand;
         cpuTemperatureCommand = config.cpuTempCommand;
         cpuUtilizationCommand = config.cpuUtilCommand;
+        cpuThrottleReasonCmd = config.cpuThrottleReasonCmd;
+        cpuUptimeCommand = config.cpuUptimeCommand;
 
         gpuMemoryCommand = config.gpuMemoryCommand;
         gpuMemUsageCommand = config.gpuMemUsageCommand;

photon-core/src/main/java/org/photonvision/common/hardware/metrics/MetricsPublisher.java

@@ -60,6 +60,8 @@ public class MetricsPublisher {
         metrics.put("cpuTemp", cpuMetrics.getTemp());
         metrics.put("cpuUtil", cpuMetrics.getUtilization());
         metrics.put("cpuMem", cpuMetrics.getMemory());
+        metrics.put("cpuThr", cpuMetrics.getThrottleReason());
+        metrics.put("cpuUptime", cpuMetrics.getUptime());
         metrics.put("gpuMem", gpuMetrics.getGPUMemorySplit());
         metrics.put("ramUtil", ramMetrics.getUsedRam());
         metrics.put("gpuMemUtil", gpuMetrics.getMallocedMemory());

photon-core/src/main/java/org/photonvision/common/networking/NetworkManager.java

@@ -46,7 +46,7 @@ public class NetworkManager {
 
         var config = ConfigManager.getInstance().getConfig().getNetworkConfig();
         logger.info("Setting " + config.connectionType + " with team team " + config.teamNumber);
-        if (Platform.isLinux()) {
+        if (Platform.isRaspberryPi()) {
             if (!Platform.isRoot) {
                 logger.error("Cannot manage network without root!");
                 return;

photon-core/src/main/java/org/photonvision/common/util/NativeLibHelper.java

@@ -0,0 +1,40 @@
+/*
+ * 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.util;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class NativeLibHelper {
+    private static NativeLibHelper INSTANCE;
+
+    public static NativeLibHelper getInstance() {
+        if (INSTANCE == null) {
+            INSTANCE = new NativeLibHelper();
+        }
+
+        return INSTANCE;
+    }
+
+    public final Path NativeLibPath;
+
+    private NativeLibHelper() {
+        String home = System.getProperty("user.home");
+        NativeLibPath = Paths.get(home, ".pvlibs", "nativecache");
+    }
+}

photon-core/src/main/java/org/photonvision/common/util/TestUtils.java

@@ -29,6 +29,15 @@ import org.opencv.highgui.HighGui;
 import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
 
 public class TestUtils {
+    public static void loadLibraries() {
+        try {
+            CameraServerCvJNI.forceLoad();
+            //        PicamJNI.forceLoad();
+        } catch (IOException ex) {
+            // ignored
+        }
+    }
+
     @SuppressWarnings("unused")
     public enum WPI2019Image {
         kCargoAngledDark48in(1.2192),
@@ -154,6 +163,23 @@ public class TestUtils {
         }
     }
 
+    public enum ApriltagTestImages {
+        kRobots,
+        kTag1_640_480;
+
+        public final Path path;
+
+        Path getPath() {
+            // Strip leading k
+            var filename = this.toString().substring(1).toLowerCase();
+            return Path.of("apriltag", filename + ".jpg");
+        }
+
+        ApriltagTestImages() {
+            this.path = getPath();
+        }
+    }
+
     private static Path getResourcesFolderPath(boolean testMode) {
         System.out.println("CWD: " + Path.of("").toAbsolutePath().toString());
         return Path.of("test-resources").toAbsolutePath();
@@ -168,7 +194,7 @@ public class TestUtils {
     public static Path getTestMode2020ImagePath() {
         return getResourcesFolderPath(true)
                 .resolve("testimages")
-                .resolve(WPI2020Image.kBlueGoal_108in_Center.path);
+                .resolve(WPI2020Image.kBlueGoal_156in_Left.path);
     }
 
     public static Path getTestMode2022ImagePath() {
@@ -177,6 +203,12 @@ public class TestUtils {
                 .resolve(WPI2022Image.kTerminal22ft6in.path);
     }
 
+    public static Path getTestModeApriltagPath() {
+        return getResourcesFolderPath(true)
+                .resolve("testimages")
+                .resolve(ApriltagTestImages.kRobots.path);
+    }
+
     public static Path getTestImagesPath(boolean testMode) {
         return getResourcesFolderPath(testMode).resolve("testimages");
     }
@@ -201,6 +233,10 @@ public class TestUtils {
         return getTestImagesPath(testMode).resolve(image.path);
     }
 
+    public static Path getApriltagImagePath(ApriltagTestImages image, boolean testMode) {
+        return getTestImagesPath(testMode).resolve(image.path);
+    }
+
     public static Path getPowercellImagePath(PowercellTestImages image, boolean testMode) {
         return getPowercellPath(testMode).resolve(image.path);
     }
@@ -243,12 +279,8 @@ public class TestUtils {
         return getCoeffs(LIFECAM_480P_CAL_FILE, testMode);
     }
 
-    public static void loadLibraries() {
-        try {
-            CameraServerCvJNI.forceLoad();
-        } catch (IOException e) {
-            // ignored
-        }
+    public static CameraCalibrationCoefficients getLaptop() {
+        return getCoeffs("laptop.json", true);
     }
 
     private static int DefaultTimeoutMillis = 5000;

photon-core/src/main/java/org/photonvision/common/util/math/MathUtils.java

@@ -17,9 +17,19 @@
 
 package org.photonvision.common.util.math;
 
+import edu.wpi.first.math.MatBuilder;
+import edu.wpi.first.math.Nat;
+import edu.wpi.first.math.VecBuilder;
+import edu.wpi.first.math.geometry.CoordinateSystem;
+import edu.wpi.first.math.geometry.Pose3d;
+import edu.wpi.first.math.geometry.Quaternion;
+import edu.wpi.first.math.geometry.Rotation3d;
+import edu.wpi.first.math.geometry.Transform3d;
+import edu.wpi.first.math.util.Units;
 import edu.wpi.first.util.WPIUtilJNI;
 import java.util.Arrays;
 import java.util.List;
+import org.opencv.core.Mat;
 
 public class MathUtils {
     MathUtils() {}
@@ -130,4 +140,65 @@ public class MathUtils {
     public static double lerp(double startValue, double endValue, double t) {
         return startValue + (endValue - startValue) * t;
     }
+
+    public static Pose3d EDNtoNWU(final Pose3d pose) {
+        // Change of basis matrix from EDN to NWU. Each column vector is one of the
+        // old basis vectors mapped to its representation in the new basis.
+        //
+        // E (+X) -> N (-Y), D (+Y) -> W (-Z), N (+Z) -> U (+X)
+        var R = new MatBuilder<>(Nat.N3(), Nat.N3()).fill(0, 0, 1, -1, 0, 0, 0, -1, 0);
+
+        // https://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
+        double w = Math.sqrt(1.0 + R.get(0, 0) + R.get(1, 1) + R.get(2, 2)) / 2.0;
+        double x = (R.get(2, 1) - R.get(1, 2)) / (4.0 * w);
+        double y = (R.get(0, 2) - R.get(2, 0)) / (4.0 * w);
+        double z = (R.get(1, 0) - R.get(0, 1)) / (4.0 * w);
+        var rotationQuat = new Rotation3d(new Quaternion(w, x, y, z));
+
+        return new Pose3d(
+                pose.getTranslation().rotateBy(rotationQuat), pose.getRotation().rotateBy(rotationQuat));
+    }
+
+    /**
+     * All our solvepnp code returns a tag with X left, Y up, and Z out of the tag To better match
+     * wpilib, we want to apply another rotation so that we get Z up, X out of the tag, and Y to the
+     * right. We apply the following change of basis: X -> Y Y -> Z Z -> X
+     */
+    private static final Rotation3d WPILIB_BASE_ROTATION =
+            new Rotation3d(new MatBuilder<>(Nat.N3(), Nat.N3()).fill(0, 1, 0, 0, 0, 1, 1, 0, 0));
+
+    public static Pose3d convertOpenCVtoPhotonPose(Transform3d cameraToTarget3d) {
+        // TODO: Refactor into new pipe?
+        // CameraToTarget _should_ be in opencv-land EDN
+        var nwu =
+                CoordinateSystem.convert(
+                        new Pose3d(cameraToTarget3d), CoordinateSystem.EDN(), CoordinateSystem.NWU());
+        return new Pose3d(nwu.getTranslation(), WPILIB_BASE_ROTATION.rotateBy(nwu.getRotation()));
+    }
+
+    /*
+     * The AprilTag pose rotation outputs are X left, Y down, Z away from the tag with the tag facing
+     * the camera upright and the camera facing the target parallel to the floor. But our OpenCV
+     * solvePNP code would have X left, Y up, Z towards the camera with the target facing the camera
+     * and both parallel to the floor. So we apply a base rotation to the rotation component of the
+     * apriltag pose to make it consistent with the EDN system that OpenCV uses, internally a 180
+     * rotation about the X axis
+     */
+    private static final Rotation3d APRILTAG_BASE_ROTATION =
+            new Rotation3d(VecBuilder.fill(1, 0, 0), Units.degreesToRadians(180));
+
+    /**
+     * Apply a 180 degree rotation about X to the rotation component of a given Apriltag pose. This
+     * aligns it with the OpenCV poses we use in other places.
+     */
+    public static Transform3d convertApriltagtoOpenCV(Transform3d pose) {
+        var ocvRotation = APRILTAG_BASE_ROTATION.rotateBy(pose.getRotation());
+        return new Transform3d(pose.getTranslation(), ocvRotation);
+    }
+
+    public static void rotationToOpencvRvec(Rotation3d rotation, Mat rvecOutput) {
+        var angle = rotation.getAngle();
+        var axis = rotation.getAxis().times(angle);
+        rvecOutput.put(0, 0, axis.getData());
+    }
 }

photon-core/src/main/java/org/photonvision/raspi/PicamJNI.java

@@ -30,6 +30,8 @@ import org.photonvision.common.logging.Logger;
 
 public class PicamJNI {
     private static boolean libraryLoaded = false;
+    private static boolean enabled =
+            false; // TODO once we've sorted out what apriltags needs to be doing, we can bring this back?
     private static Logger logger = new Logger(PicamJNI.class, LogGroup.Camera);
 
     public enum SensorModel {
@@ -86,6 +88,7 @@ public class PicamJNI {
 
     public static boolean isSupported() {
         return libraryLoaded
+                && enabled
                 && isVCSMSupported()
                 && getSensorModel() != SensorModel.Disconnected
                 && Platform.isRaspberryPi()

photon-core/src/main/java/org/photonvision/vision/apriltag/AprilTagDetector.java

@@ -0,0 +1,92 @@
+/*
+ * 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.apriltag;
+
+import org.opencv.core.Mat;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
+import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
+
+public class AprilTagDetector {
+    private static final Logger logger = new Logger(AprilTagDetector.class, LogGroup.VisionModule);
+    private long m_detectorPtr = 0;
+    private AprilTagDetectorParams m_detectorParams = AprilTagDetectorParams.DEFAULT_36H11;
+
+    public AprilTagDetector() {
+        updateDetector();
+    }
+
+    private void updateDetector() {
+        if (m_detectorPtr != 0) {
+            // TODO: in JNI
+            AprilTagJNI.AprilTag_Destroy(m_detectorPtr);
+            m_detectorPtr = 0;
+        }
+
+        logger.debug("Creating detector with params " + m_detectorParams);
+        m_detectorPtr =
+                AprilTagJNI.AprilTag_Create(
+                        m_detectorParams.tagFamily.getNativeName(),
+                        m_detectorParams.decimate,
+                        m_detectorParams.blur,
+                        m_detectorParams.threads,
+                        m_detectorParams.debug,
+                        m_detectorParams.refineEdges);
+    }
+
+    public void updateParams(AprilTagDetectorParams newParams) {
+        if (!m_detectorParams.equals(newParams)) {
+            m_detectorParams = newParams;
+            updateDetector();
+        }
+    }
+
+    public DetectionResult[] detect(
+            Mat grayscaleImg,
+            CameraCalibrationCoefficients coeffs,
+            boolean useNativePoseEst,
+            int numIterations,
+            double tagWidthMeters) {
+        if (m_detectorPtr == 0) {
+            // Detector not set up (JNI issue? or similar?)
+            // No detection is possible.
+            return new DetectionResult[] {};
+        }
+
+        var cx = 0.0;
+        var cy = 0.0;
+        var fx = 0.0;
+        var fy = 0.0;
+        var doPoseEst = false;
+
+        if (coeffs != null && useNativePoseEst) {
+            final Mat cameraMatrix = coeffs.getCameraIntrinsicsMat();
+            if (cameraMatrix != null) {
+                // Camera calibration has been done, we should be able to do pose estimation
+                cx = cameraMatrix.get(0, 2)[0];
+                cy = cameraMatrix.get(1, 2)[0];
+                fx = cameraMatrix.get(0, 0)[0];
+                fy = cameraMatrix.get(1, 1)[0];
+                doPoseEst = true;
+            }
+        }
+
+        return AprilTagJNI.AprilTag_Detect(
+                m_detectorPtr, grayscaleImg, doPoseEst, tagWidthMeters, fx, fy, cx, cy, numIterations);
+    }
+}

photon-core/src/main/java/org/photonvision/vision/apriltag/AprilTagDetectorParams.java

@@ -0,0 +1,78 @@
+/*
+ * 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.apriltag;
+
+import java.util.Objects;
+
+public class AprilTagDetectorParams {
+    public static AprilTagDetectorParams DEFAULT_36H11 =
+            new AprilTagDetectorParams(AprilTagFamily.kTag36h11, 1.0, 0.0, 4, false, false);
+
+    public final AprilTagFamily tagFamily;
+    public final double decimate;
+    public final double blur;
+    public final int threads;
+    public final boolean debug;
+    public final boolean refineEdges;
+
+    public AprilTagDetectorParams(
+            AprilTagFamily tagFamily,
+            double decimate,
+            double blur,
+            int threads,
+            boolean debug,
+            boolean refineEdges) {
+        this.tagFamily = tagFamily;
+        this.decimate = decimate;
+        this.blur = blur;
+        this.threads = threads;
+        this.debug = debug;
+        this.refineEdges = refineEdges;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        AprilTagDetectorParams that = (AprilTagDetectorParams) o;
+        return Objects.equals(tagFamily, that.tagFamily)
+                && Double.compare(decimate, that.decimate) == 0
+                && Double.compare(blur, that.blur) == 0
+                && threads == that.threads
+                && debug == that.debug
+                && refineEdges == that.refineEdges;
+    }
+
+    @Override
+    public String toString() {
+        return "AprilTagDetectorParams{"
+                + "tagFamily="
+                + tagFamily.getNativeName()
+                + ", decimate="
+                + decimate
+                + ", blur="
+                + blur
+                + ", threads="
+                + threads
+                + ", debug="
+                + debug
+                + ", refineEdges="
+                + refineEdges
+                + '}';
+    }
+}

photon-core/src/main/java/org/photonvision/vision/apriltag/AprilTagFamily.java

@@ -0,0 +1,34 @@
+/*
+ * 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.apriltag;
+
+public enum AprilTagFamily {
+    kTag36h11,
+    kTag25h9,
+    kTag16h5,
+    kTagCircle21h7,
+    kTagCircle49h12,
+    kTagStandard41h12,
+    kTagStandard52h13,
+    kTagCustom48h11;
+
+    public String getNativeName() {
+        // We wanna strip the leading kT and replace with "t"
+        return this.name().replaceFirst("kT", "t");
+    }
+}

photon-core/src/main/java/org/photonvision/vision/apriltag/AprilTagJNI.java

@@ -0,0 +1,182 @@
+/*
+ * 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.apriltag;
+
+import edu.wpi.first.util.RuntimeDetector;
+import edu.wpi.first.util.RuntimeLoader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.opencv.core.Mat;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
+
+public class AprilTagJNI {
+    static final boolean USE_DEBUG =
+            false; // Development flag - should be false on release, but flip to True to read in a debug
+    // version of the library
+    static final String NATIVE_DEBUG_LIBRARY_NAME = "apriltagd";
+    static final String NATIVE_RELEASE_LIBRARY_NAME = "apriltag";
+
+    static boolean s_libraryLoaded = false;
+    static RuntimeLoader<AprilTagJNI> s_loader = null;
+    private static Logger logger = new Logger(AprilTagJNI.class, LogGroup.VisionModule);
+
+    public static synchronized void forceLoad() throws IOException {
+        if (s_libraryLoaded) return;
+
+        try {
+            // Ensure the lib directory has been created to receive the unpacked shared object
+            File libDirectory = Path.of("lib/").toFile();
+            if (!libDirectory.exists()) {
+                Files.createDirectory(libDirectory.toPath()).toFile();
+            }
+
+            // Pick the proper library based on development flags
+            String libBaseName = USE_DEBUG ? NATIVE_DEBUG_LIBRARY_NAME : NATIVE_RELEASE_LIBRARY_NAME;
+            String libFileName = System.mapLibraryName(libBaseName);
+            File libFile = Path.of("lib/" + libFileName).toFile();
+
+            // Always extract the library fresh
+            // Yes, technically, a hashing strategy should speed this up, but it's only a
+            // one-time, at-startup time hit. And not very big.
+            URL resourceURL;
+
+            String subfolder;
+            // TODO 64-bit Pi support
+            if (RuntimeDetector.isAthena()) {
+                subfolder = "athena";
+            } else if (RuntimeDetector.isAarch64()) {
+                subfolder = "aarch64";
+            } else if (RuntimeDetector.isRaspbian()) {
+                subfolder = "raspbian";
+            } else if (RuntimeDetector.isWindows()) {
+                subfolder = "win64";
+            } else if (RuntimeDetector.isLinux()) {
+                subfolder = "linux64";
+            } else if (RuntimeDetector.isMac()) {
+                subfolder = "mac";
+            } // NOT m1, afaict, lol
+            else {
+                logger.error("Could not determine platform! Cannot load Apriltag JNI");
+                return;
+            }
+
+            resourceURL =
+                    AprilTagJNI.class.getResource(
+                            "/nativelibraries/apriltag/" + subfolder + "/" + libFileName);
+
+            try (InputStream in = resourceURL.openStream()) {
+                // Remove the file if it already exists
+                if (libFile.exists()) Files.delete(libFile.toPath());
+                // Copy in a fresh resource
+                Files.copy(in, libFile.toPath());
+            }
+
+            // Actually load the library
+            System.load(libFile.getAbsolutePath());
+
+            s_libraryLoaded = true;
+
+        } catch (UnsatisfiedLinkError e) {
+            logger.error("Couldn't load apriltag shared object");
+            e.printStackTrace();
+        } catch (IOException ioe) {
+            logger.error("IO exception copying apriltag shared object");
+            ioe.printStackTrace();
+        }
+
+        if (!s_libraryLoaded) {
+            logger.error("Failed to load AprilTag Native Library!");
+        } else {
+            logger.info("AprilTag Native Library loaded successfully");
+        }
+    }
+
+    // Returns a pointer to a apriltag_detector_t
+    public static native long AprilTag_Create(
+            String fam, double decimate, double blur, int threads, boolean debug, boolean refine_edges);
+
+    // Destroy and free a previously created detector.
+    public static native long AprilTag_Destroy(long detector);
+
+    private static native Object[] AprilTag_Detect(
+            long detector,
+            long imgAddr,
+            int rows,
+            int cols,
+            boolean doPoseEstimation,
+            double tagWidth,
+            double fx,
+            double fy,
+            double cx,
+            double cy,
+            int nIters);
+
+    // Detect targets given a GRAY frame. Returns a pointer toa zarray
+    public static DetectionResult[] AprilTag_Detect(
+            long detector,
+            Mat img,
+            boolean doPoseEstimation,
+            double tagWidth,
+            double fx,
+            double fy,
+            double cx,
+            double cy,
+            int nIters) {
+        return (DetectionResult[])
+                AprilTag_Detect(
+                        detector,
+                        img.dataAddr(),
+                        img.rows(),
+                        img.cols(),
+                        doPoseEstimation,
+                        tagWidth,
+                        fx,
+                        fy,
+                        cx,
+                        cy,
+                        nIters);
+    }
+
+    public static void main(String[] args) {
+        // System.loadLibrary("apriltag");
+
+        long detector = AprilTag_Create("tag36h11", 2, 2, 1, false, true);
+
+        // var buff = ByteBuffer.allocateDirect(1280 * 720);
+
+        // // try {
+        // //     CameraServerCvJNI.forceLoad();
+        // // } catch (IOException e) {
+        // //     // TODO Auto-generated catch block
+        // //     e.printStackTrace();
+        // // }
+        // // PicamJNI.forceLoad();
+        // // TestUtils.loadLibraries();
+        // var img = Imgcodecs.imread("~/Downloads/TagFams.jpg");
+
+        // var ret = AprilTag_Detect(detector, 0, 720, 1280);
+        // System.out.println(detector);
+        // System.out.println(ret);
+        // System.out.println(List.of(ret));
+    }
+}

photon-core/src/main/java/org/photonvision/vision/apriltag/DetectionResult.java

@@ -0,0 +1,179 @@
+/*
+ * 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.apriltag;
+
+import edu.wpi.first.math.MatBuilder;
+import edu.wpi.first.math.Nat;
+import edu.wpi.first.math.geometry.Rotation3d;
+import edu.wpi.first.math.geometry.Transform3d;
+import edu.wpi.first.math.geometry.Translation3d;
+import java.util.Arrays;
+
+public class DetectionResult {
+    public int getId() {
+        return id;
+    }
+
+    public int getHamming() {
+        return hamming;
+    }
+
+    public float getDecisionMargin() {
+        return decision_margin;
+    }
+
+    public void setDecisionMargin(float decision_margin) {
+        this.decision_margin = decision_margin;
+    }
+
+    public double[] getHomography() {
+        return homography;
+    }
+
+    public void setHomography(double[] homography) {
+        this.homography = homography;
+    }
+
+    public double getCenterX() {
+        return centerX;
+    }
+
+    public void setCenterX(double centerX) {
+        this.centerX = centerX;
+    }
+
+    public double getCenterY() {
+        return centerY;
+    }
+
+    public void setCenterY(double centerY) {
+        this.centerY = centerY;
+    }
+
+    public double[] getCorners() {
+        return corners;
+    }
+
+    public void setCorners(double[] corners) {
+        this.corners = corners;
+    }
+
+    public double getError1() {
+        return error1;
+    }
+
+    public double getError2() {
+        return error2;
+    }
+
+    public Transform3d getPoseResult1() {
+        return poseResult1;
+    }
+
+    public Transform3d getPoseResult2() {
+        return poseResult2;
+    }
+
+    int id;
+    int hamming;
+    float decision_margin;
+    double[] homography;
+    double centerX, centerY;
+    double[] corners;
+
+    Transform3d poseResult1;
+    double error1;
+    Transform3d poseResult2;
+    double error2;
+
+    public DetectionResult(
+            int id,
+            int hamming,
+            float decision_margin,
+            double[] homography,
+            double centerX,
+            double centerY,
+            double[] corners,
+            double[] pose1TransArr,
+            double[] pose1RotArr,
+            double err1,
+            double[] pose2TransArr,
+            double[] pose2RotArr,
+            double err2) {
+        this.id = id;
+        this.hamming = hamming;
+        this.decision_margin = decision_margin;
+        this.homography = homography;
+        this.centerX = centerX;
+        this.centerY = centerY;
+        this.corners = corners;
+
+        this.error1 = err1;
+        this.poseResult1 =
+                new Transform3d(
+                        new Translation3d(pose1TransArr[0], pose1TransArr[1], pose1TransArr[2]),
+                        new Rotation3d(new MatBuilder<>(Nat.N3(), Nat.N3()).fill(pose1RotArr)));
+        this.error2 = err2;
+        this.poseResult2 =
+                new Transform3d(
+                        new Translation3d(pose2TransArr[0], pose2TransArr[1], pose2TransArr[2]),
+                        new Rotation3d(new MatBuilder<>(Nat.N3(), Nat.N3()).fill(pose2RotArr)));
+    }
+
+    /**
+     * Get the ratio of pose reprojection errors, called ambiguity. Numbers above 0.2 are likely to be
+     * ambiguous.
+     */
+    public double getPoseAmbiguity() {
+        var min = Math.min(error1, error2);
+        var max = Math.max(error1, error2);
+
+        if (max > 0) {
+            return min / max;
+        } else {
+            return -1;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "DetectionResult [centerX="
+                + centerX
+                + ", centerY="
+                + centerY
+                + ", corners="
+                + Arrays.toString(corners)
+                + ", decision_margin="
+                + decision_margin
+                + ", error1="
+                + error1
+                + ", error2="
+                + error2
+                + ", hamming="
+                + hamming
+                + ", homography="
+                + Arrays.toString(homography)
+                + ", id="
+                + id
+                + ", poseResult1="
+                + poseResult1
+                + ", poseResult2="
+                + poseResult2
+                + "]";
+    }
+}

photon-core/src/main/java/org/photonvision/vision/camera/CameraQuirk.java

@@ -23,5 +23,11 @@ public enum CameraQuirk {
     /** For the Raspberry Pi Camera */
     PiCam,
     /** Cap at 100FPS for high-bandwidth cameras */
-    FPSCap100
+    FPSCap100,
+    /** Separate red/blue gain controls available */
+    AWBGain,
+    /** Will not work with photonvision - Logitec C270 at least */
+    CompletelyBroken,
+    /** Has adjustable focus and autofocus switch */
+    AdjustableFocus,
 }

photon-core/src/main/java/org/photonvision/vision/camera/FileVisionSource.java

@@ -43,7 +43,6 @@ public class FileVisionSource extends VisionSource {
                         Path.of(cameraConfiguration.path),
                         cameraConfiguration.FOV,
                         FileFrameProvider.MAX_FPS,
-                        cameraConfiguration.camPitch,
                         calibration);
         settables =
                 new FileSourceSettables(cameraConfiguration, frameProvider.get().frameStaticProperties);
@@ -92,6 +91,8 @@ public class FileVisionSource extends VisionSource {
         @Override
         public void setExposure(double exposure) {}
 
+        public void setAutoExposure(boolean cameraAutoExposure) {}
+
         @Override
         public void setBrightness(int brightness) {}
 

photon-core/src/main/java/org/photonvision/vision/camera/QuirkyCamera.java

@@ -24,8 +24,26 @@ import java.util.Objects;
 public class QuirkyCamera {
     private static final List<QuirkyCamera> quirkyCameras =
             List.of(
+                    new QuirkyCamera(
+                            0x9331,
+                            0x5A3,
+                            CameraQuirk.CompletelyBroken), // Chris's older generic "Logitec HD Webcam"
+                    new QuirkyCamera(0x825, 0x46D, CameraQuirk.CompletelyBroken), // Logitec C270
+                    new QuirkyCamera(
+                            0x0bda,
+                            0x5510,
+                            CameraQuirk.CompletelyBroken), // A laptop internal camera someone found broken
+                    new QuirkyCamera(
+                            -1, -1, "Snap Camera", CameraQuirk.CompletelyBroken), // SnapCamera on Windows
+                    new QuirkyCamera(
+                            -1,
+                            -1,
+                            "FaceTime HD Camera",
+                            CameraQuirk.CompletelyBroken), // Mac Facetime Camera shared into Windows in Bootcamp
                     new QuirkyCamera(0x2000, 0x1415, CameraQuirk.Gain, CameraQuirk.FPSCap100), // PS3Eye
-                    new QuirkyCamera(-1, -1, "mmal service 16.1", CameraQuirk.PiCam) // PiCam (via V4L2)
+                    new QuirkyCamera(
+                            -1, -1, "mmal service 16.1", CameraQuirk.PiCam), // PiCam (via V4L2, not zerocopy)
+                    new QuirkyCamera(0x85B, 0x46D, CameraQuirk.AdjustableFocus) // Logitech C925-e
                     );
 
     public static final QuirkyCamera DefaultCamera = new QuirkyCamera(0, 0, "");
@@ -35,7 +53,8 @@ public class QuirkyCamera {
                     -1,
                     "mmal service 16.1",
                     CameraQuirk.PiCam,
-                    CameraQuirk.Gain); // PiCam (special zerocopy version)
+                    CameraQuirk.Gain,
+                    CameraQuirk.AWBGain); // PiCam (special zerocopy version)
 
     public final String baseName;
     public final int usbVid;

photon-core/src/main/java/org/photonvision/vision/camera/USBCameraSource.java

@@ -18,10 +18,7 @@
 package org.photonvision.vision.camera;
 
 import edu.wpi.first.cameraserver.CameraServer;
-import edu.wpi.first.cscore.CvSink;
-import edu.wpi.first.cscore.UsbCamera;
-import edu.wpi.first.cscore.VideoException;
-import edu.wpi.first.cscore.VideoMode;
+import edu.wpi.first.cscore.*;
 import java.util.*;
 import java.util.stream.Collectors;
 import org.photonvision.common.configuration.CameraConfiguration;
@@ -44,6 +41,7 @@ public class USBCameraSource extends VisionSource {
 
     public USBCameraSource(CameraConfiguration config) {
         super(config);
+
         logger = new Logger(USBCameraSource.class, config.nickname, LogGroup.Camera);
         camera = new UsbCamera(config.nickname, config.path);
         cvSink = CameraServer.getInstance().getVideo(this.camera);
@@ -56,19 +54,34 @@ public class USBCameraSource extends VisionSource {
             logger.info("Quirky camera detected: " + cameraQuirks.baseName);
         }
 
-        usbCameraSettables = new USBCameraSettables(config);
-        usbFrameProvider = new USBFrameProvider(cvSink, usbCameraSettables);
+        if (cameraQuirks.hasQuirk(CameraQuirk.CompletelyBroken)) {
+            // set some defaults, as these should never be used.
+            logger.info("Camera " + cameraQuirks.baseName + " is not supported for PhotonVision");
+            usbCameraSettables = null;
+            usbFrameProvider = null;
+        } else {
+            // Normal init
+            // auto exposure/brightness/gain will be set by the visionmodule later
+            disableAutoFocus();
 
-        if (cameraQuirks.hasQuirk(CameraQuirk.PiCam)) {
-            // Pick a bunch of reasonable setting defaults for vision processing.
-            camera.getProperty("exposure_dynamic_framerate").set(0);
-            camera.getProperty("auto_exposure_bias").set(0);
-            camera.getProperty("image_stabilization").set(0);
-            camera.getProperty("iso_sensitivity").set(0);
-            camera.getProperty("iso_sensitivity_auto").set(0);
-            camera.getProperty("exposure_metering_mode").set(0);
-            camera.getProperty("scene_mode").set(0);
-            camera.getProperty("power_line_frequency").set(2);
+            usbCameraSettables = new USBCameraSettables(config);
+            if (usbCameraSettables.getAllVideoModes().isEmpty()) {
+                logger.info("Camera " + camera.getPath() + " has no video modes supported by PhotonVision");
+                usbFrameProvider = null;
+            } else {
+                usbFrameProvider = new USBFrameProvider(cvSink, usbCameraSettables);
+            }
+        }
+    }
+
+    void disableAutoFocus() {
+        if (cameraQuirks.hasQuirk(CameraQuirk.AdjustableFocus)) {
+            try {
+                camera.getProperty("focus_auto").set(0);
+                camera.getProperty("focus_absolute").set(0); // Focus into infinity
+            } catch (VideoException e) {
+                logger.error("Unable to disable autofocus!", e);
+            }
         }
     }
 
@@ -89,43 +102,98 @@ public class USBCameraSource extends VisionSource {
             setVideoMode(videoModes.get(0));
         }
 
-        private int timeToPiCamV2RawExposure(double time_us) {
+        public void setAutoExposure(boolean cameraAutoExposure) {
+            logger.debug("Setting auto exposure to " + cameraAutoExposure);
+
+            if (cameraQuirks.hasQuirk(CameraQuirk.PiCam)) {
+                // Case, we know this is a picam. Go through v4l2-ctl interface directly
+
+                // Common settings
+                camera
+                        .getProperty("image_stabilization")
+                        .set(0); // No image stabilization, as this will throw off odometry
+                camera.getProperty("power_line_frequency").set(2); // Assume 60Hz USA
+                camera.getProperty("scene_mode").set(0); // no presets
+                camera.getProperty("exposure_metering_mode").set(0);
+                camera.getProperty("exposure_dynamic_framerate").set(0);
+
+                if (!cameraAutoExposure) {
+                    // Pick a bunch of reasonable setting defaults for vision processing retroreflective
+                    camera.getProperty("auto_exposure_bias").set(0);
+                    camera.getProperty("iso_sensitivity_auto").set(0); // Disable auto ISO adjustement
+                    camera.getProperty("iso_sensitivity").set(0); // Manual ISO adjustement
+                    camera.getProperty("white_balance_auto_preset").set(2); // Auto white-balance disabled
+                    camera.getProperty("auto_exposure").set(1); // auto exposure disabled
+                } else {
+                    // Pick a bunch of reasonable setting defaults for driver, fiducials, or otherwise
+                    // nice-for-humans
+                    camera.getProperty("auto_exposure_bias").set(12);
+                    camera.getProperty("iso_sensitivity_auto").set(1);
+                    camera.getProperty("iso_sensitivity").set(1); // Manual ISO adjustement by default
+                    camera.getProperty("white_balance_auto_preset").set(1); // Auto white-balance enabled
+                    camera.getProperty("auto_exposure").set(0); // auto exposure enabled
+                }
+
+            } else {
+                // Case - this is some other USB cam. Default to wpilib's implementation
+
+                var canSetWhiteBalance = !cameraQuirks.hasQuirk(CameraQuirk.Gain);
+
+                if (!cameraAutoExposure) {
+                    // Pick a bunch of reasonable setting defaults for vision processing retroreflective
+                    if (canSetWhiteBalance) {
+                        camera.setWhiteBalanceManual(4000); // Auto white-balance disabled, 4000K preset
+                    }
+                } else {
+                    // Pick a bunch of reasonable setting defaults for driver, fiducials, or otherwise
+                    // nice-for-humans
+                    if (canSetWhiteBalance) {
+                        camera.setWhiteBalanceAuto(); // Auto white-balance enabled
+                    }
+                    camera.setExposureAuto(); // auto exposure enabled
+                }
+            }
+        }
+
+        private int timeToPiCamRawExposure(double time_us) {
             int retVal =
-                    (int) Math.round(time_us / 100.0); // PiCamV2 needs exposure time in units of 100us/bit
+                    (int)
+                            Math.round(
+                                    time_us / 100.0); // Pi Cam's (both v1 and v2) need exposure time in units of
+            // 100us/bit
             return Math.min(Math.max(retVal, 1), 10000); // Cap to allowable range for parameter
         }
 
         private double pctToExposureTimeUs(double pct_in) {
             // Mirror the photonvision raspicam driver's algorithm for picking an exposure time
             // from a 0-100% input
-            final double PADDING_LOW_US = 100;
-            final double PADDING_HIGH_US = 200;
+            final double PADDING_LOW_US = 10;
+            final double PADDING_HIGH_US = 10;
             return PADDING_LOW_US
                     + (pct_in / 100.0) * ((1e6 / (double) camera.getVideoMode().fps) - PADDING_HIGH_US);
         }
 
         @Override
         public void setExposure(double exposure) {
-            try {
-                int scaledExposure = 1;
-                if (cameraQuirks.hasQuirk(CameraQuirk.PiCam)) {
-                    camera.getProperty("white_balance_auto_preset").set(2); // Auto white-balance off
-                    camera.getProperty("auto_exposure").set(1); // auto exposure off
+            if (exposure >= 0.0) {
+                try {
+                    int scaledExposure = 1;
+                    if (cameraQuirks.hasQuirk(CameraQuirk.PiCam)) {
+                        scaledExposure =
+                                (int) Math.round(timeToPiCamRawExposure(pctToExposureTimeUs(exposure)));
+                        logger.debug("Setting camera raw exposure to " + Integer.toString(scaledExposure));
+                        camera.getProperty("raw_exposure_time_absolute").set(scaledExposure);
+                        camera.getProperty("raw_exposure_time_absolute").set(scaledExposure);
 
-                    scaledExposure =
-                            (int) Math.round(timeToPiCamV2RawExposure(pctToExposureTimeUs(exposure)));
-                    logger.debug("Setting camera raw exposure to " + Integer.toString(scaledExposure));
-                    camera.getProperty("raw_exposure_time_absolute").set(scaledExposure);
-                    camera.getProperty("raw_exposure_time_absolute").set(scaledExposure);
-
-                } else {
-                    scaledExposure = (int) Math.round(exposure);
-                    logger.debug("Setting camera exposure to " + Integer.toString(scaledExposure));
-                    camera.setExposureManual(scaledExposure);
-                    camera.setExposureManual(scaledExposure);
+                    } else {
+                        scaledExposure = (int) Math.round(exposure);
+                        logger.debug("Setting camera exposure to " + Integer.toString(scaledExposure));
+                        camera.setExposureManual(scaledExposure);
+                        camera.setExposureManual(scaledExposure);
+                    }
+                } catch (VideoException e) {
+                    logger.error("Failed to set camera exposure!", e);
                 }
-            } catch (VideoException e) {
-                logger.error("Failed to set camera exposure!", e);
             }
         }
 
@@ -180,8 +248,16 @@ public class USBCameraSource extends VisionSource {
                         modes =
                                 new VideoMode[] {
                                     new VideoMode(VideoMode.PixelFormat.kBGR, 320, 240, 90),
+                                    new VideoMode(VideoMode.PixelFormat.kBGR, 320, 240, 30),
+                                    new VideoMode(VideoMode.PixelFormat.kBGR, 320, 240, 15),
+                                    new VideoMode(VideoMode.PixelFormat.kBGR, 320, 240, 10),
                                     new VideoMode(VideoMode.PixelFormat.kBGR, 640, 480, 90),
+                                    new VideoMode(VideoMode.PixelFormat.kBGR, 640, 480, 45),
+                                    new VideoMode(VideoMode.PixelFormat.kBGR, 640, 480, 30),
+                                    new VideoMode(VideoMode.PixelFormat.kBGR, 640, 480, 15),
+                                    new VideoMode(VideoMode.PixelFormat.kBGR, 640, 480, 10),
                                     new VideoMode(VideoMode.PixelFormat.kBGR, 960, 720, 60),
+                                    new VideoMode(VideoMode.PixelFormat.kBGR, 960, 720, 10),
                                     new VideoMode(VideoMode.PixelFormat.kBGR, 1280, 720, 45),
                                     new VideoMode(VideoMode.PixelFormat.kBGR, 1920, 1080, 20),
                                 };
@@ -212,21 +288,24 @@ public class USBCameraSource extends VisionSource {
 
                         videoModesList.add(videoMode);
 
+                        // TODO - do we want to trim down FPS modes? in cases where the camera has no gain
+                        // control,
+                        // lower FPS might be needed to ensure total exposure is acceptable.
                         // We look for modes with the same height/width/pixelformat as this mode
                         // and remove all the ones that are slower. This is sorted low to high.
                         // So we remove the last element (the fastest FPS) from the duplicate list,
                         // and remove all remaining elements from the final list
-                        var duplicateModes =
-                                videoModesList.stream()
-                                        .filter(
-                                                it ->
-                                                        it.height == videoMode.height
-                                                                && it.width == videoMode.width
-                                                                && it.pixelFormat == videoMode.pixelFormat)
-                                        .sorted(Comparator.comparingDouble(it -> it.fps))
-                                        .collect(Collectors.toList());
-                        duplicateModes.remove(duplicateModes.size() - 1);
-                        videoModesList.removeAll(duplicateModes);
+                        // var duplicateModes =
+                        //         videoModesList.stream()
+                        //                 .filter(
+                        //                         it ->
+                        //                                 it.height == videoMode.height
+                        //                                         && it.width == videoMode.width
+                        //                                         && it.pixelFormat == videoMode.pixelFormat)
+                        //                 .sorted(Comparator.comparingDouble(it -> it.fps))
+                        //                 .collect(Collectors.toList());
+                        // duplicateModes.remove(duplicateModes.size() - 1);
+                        // videoModesList.removeAll(duplicateModes);
                     }
                 } catch (Exception e) {
                     logger.error("Exception while enumerating video modes!", e);

photon-core/src/main/java/org/photonvision/vision/camera/ZeroCopyPicamSource.java

@@ -87,6 +87,7 @@ public class ZeroCopyPicamSource extends VisionSource {
         private FPSRatedVideoMode currentVideoMode;
         private double lastExposure = 50;
         private int lastBrightness = 50;
+        private boolean lastExposureMode;
         private int lastGain = 50;
         private Pair<Integer, Integer> lastAwbGains = new Pair(18, 18);
 
@@ -101,10 +102,14 @@ public class ZeroCopyPicamSource extends VisionSource {
                 videoModes.put(
                         0, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 320, 240, 120, 120, .39));
                 videoModes.put(
-                        1, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 640, 480, 65, 90, .39));
+                        1, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 320, 240, 30, 30, .39));
+                videoModes.put(
+                        2, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 640, 480, 65, 90, .39));
+                videoModes.put(
+                        3, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 640, 480, 30, 30, .39));
                 // TODO: fix 1280x720 in the native code and re-add it
                 videoModes.put(
-                        3, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 1920, 1080, 15, 20, .53));
+                        4, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 1920, 1080, 15, 20, .53));
             } else {
                 if (sensorModel == PicamJNI.SensorModel.IMX477) {
                     logger.warn(
@@ -118,13 +123,17 @@ public class ZeroCopyPicamSource extends VisionSource {
                 videoModes.put(
                         0, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 320, 240, 90, 90, 1));
                 videoModes.put(
-                        1, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 640, 480, 85, 90, 1));
+                        1, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 320, 240, 30, 30, 1));
                 videoModes.put(
-                        2, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 960, 720, 45, 49, 0.74));
+                        2, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 640, 480, 85, 90, 1));
                 videoModes.put(
-                        3, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 1280, 720, 30, 45, 0.91));
+                        3, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 640, 480, 30, 30, 1));
                 videoModes.put(
-                        4, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 1920, 1080, 15, 20, 0.72));
+                        4, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 960, 720, 45, 49, 0.74));
+                videoModes.put(
+                        5, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 1280, 720, 30, 45, 0.91));
+                videoModes.put(
+                        6, new FPSRatedVideoMode(VideoMode.PixelFormat.kUnknown, 1920, 1080, 15, 20, 0.72));
             }
 
             currentVideoMode = (FPSRatedVideoMode) videoModes.get(0);
@@ -135,8 +144,19 @@ public class ZeroCopyPicamSource extends VisionSource {
             return getCurrentVideoMode().fovMultiplier * getConfiguration().FOV;
         }
 
+        @Override
+        public void setAutoExposure(boolean cameraAutoExposure) {
+            lastExposureMode = cameraAutoExposure;
+            // TODO (Matt) -- call PicamJNI's auto exposure function, when that exists
+        }
+
         @Override
         public void setExposure(double exposure) {
+            // Todo (Chris) - for now, handle auto exposure by using 100% exposure
+            if (exposure < 0.0) {
+                exposure = 100.0;
+            }
+
             lastExposure = exposure;
             var failure = PicamJNI.setExposure((int) Math.round(exposure));
             if (failure) logger.warn("Couldn't set Pi Camera exposure");
@@ -193,6 +213,7 @@ public class ZeroCopyPicamSource extends VisionSource {
             // We don't store last settings on the native side, and when you change video mode these get
             // reset on MMAL's end
             setExposure(lastExposure);
+            setAutoExposure(lastExposureMode);
             setBrightness(lastBrightness);
             setGain(lastGain);
             setAwbGain(lastAwbGains.getFirst(), lastAwbGains.getSecond());

photon-core/src/main/java/org/photonvision/vision/frame/Frame.java

@@ -17,7 +17,9 @@
 
 package org.photonvision.vision.frame;
 
-import edu.wpi.first.math.geometry.Rotation2d;
+import org.opencv.core.CvType;
+import org.opencv.core.Mat;
+import org.opencv.core.Size;
 import org.photonvision.common.util.math.MathUtils;
 import org.photonvision.vision.opencv.CVMat;
 import org.photonvision.vision.opencv.Releasable;
@@ -38,10 +40,14 @@ public class Frame implements Releasable {
     }
 
     public Frame() {
-        this(
-                new CVMat(),
+        this(new CVMat(), MathUtils.wpiNanoTime(), new FrameStaticProperties(0, 0, 0, null));
+    }
+
+    public static Frame emptyFrame(int width, int height) {
+        return new Frame(
+                new CVMat(Mat.zeros(new Size(width, height), CvType.CV_8UC3)),
                 MathUtils.wpiNanoTime(),
-                new FrameStaticProperties(0, 0, 0, new Rotation2d(), null));
+                new FrameStaticProperties(width, height, 0, null));
     }
 
     public void copyTo(Frame destFrame) {

photon-core/src/main/java/org/photonvision/vision/frame/FrameStaticProperties.java

@@ -18,7 +18,6 @@
 package org.photonvision.vision.frame;
 
 import edu.wpi.first.cscore.VideoMode;
-import edu.wpi.first.math.geometry.Rotation2d;
 import org.opencv.core.Point;
 import org.photonvision.common.util.numbers.DoubleCouple;
 import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
@@ -34,7 +33,6 @@ public class FrameStaticProperties {
     public final Point centerPoint;
     public final double horizontalFocalLength;
     public final double verticalFocalLength;
-    public final Rotation2d cameraPitch;
     public CameraCalibrationCoefficients cameraCalibration;
 
     /**
@@ -43,9 +41,8 @@ public class FrameStaticProperties {
      * @param mode The Video Mode of the camera.
      * @param fov The fov of the image.
      */
-    public FrameStaticProperties(
-            VideoMode mode, double fov, Rotation2d cameraPitch, CameraCalibrationCoefficients cal) {
-        this(mode != null ? mode.width : 1, mode != null ? mode.height : 1, fov, cameraPitch, cal);
+    public FrameStaticProperties(VideoMode mode, double fov, CameraCalibrationCoefficients cal) {
+        this(mode != null ? mode.width : 1, mode != null ? mode.height : 1, fov, cal);
     }
 
     /**
@@ -56,15 +53,10 @@ public class FrameStaticProperties {
      * @param fov The fov of the image.
      */
     public FrameStaticProperties(
-            int imageWidth,
-            int imageHeight,
-            double fov,
-            Rotation2d cameraPitch,
-            CameraCalibrationCoefficients cal) {
+            int imageWidth, int imageHeight, double fov, CameraCalibrationCoefficients cal) {
         this.imageWidth = imageWidth;
         this.imageHeight = imageHeight;
         this.fov = fov;
-        this.cameraPitch = cameraPitch;
         this.cameraCalibration = cal;
 
         imageArea = this.imageWidth * this.imageHeight;

photon-core/src/main/java/org/photonvision/vision/frame/provider/FileFrameProvider.java

@@ -17,7 +17,6 @@
 
 package org.photonvision.vision.frame.provider;
 
-import edu.wpi.first.math.geometry.Rotation2d;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -34,7 +33,7 @@ import org.photonvision.vision.opencv.CVMat;
  * path}.
  */
 public class FileFrameProvider implements FrameProvider {
-    public static final int MAX_FPS = 10;
+    public static final int MAX_FPS = 5;
     private static int count = 0;
 
     private final int thisIndex = count++;
@@ -54,20 +53,15 @@ public class FileFrameProvider implements FrameProvider {
      * @param maxFPS The max framerate to provide the image at.
      */
     public FileFrameProvider(Path path, double fov, int maxFPS) {
-        this(path, fov, maxFPS, null, null);
+        this(path, fov, maxFPS, null);
+    }
+
+    public FileFrameProvider(Path path, double fov, CameraCalibrationCoefficients calibration) {
+        this(path, fov, MAX_FPS, calibration);
     }
 
     public FileFrameProvider(
-            Path path, double fov, Rotation2d pitch, CameraCalibrationCoefficients calibration) {
-        this(path, fov, MAX_FPS, pitch, calibration);
-    }
-
-    public FileFrameProvider(
-            Path path,
-            double fov,
-            int maxFPS,
-            Rotation2d pitch,
-            CameraCalibrationCoefficients calibration) {
+            Path path, double fov, int maxFPS, CameraCalibrationCoefficients calibration) {
         if (!Files.exists(path))
             throw new RuntimeException("Invalid path for image: " + path.toAbsolutePath().toString());
         this.path = path;
@@ -75,8 +69,7 @@ public class FileFrameProvider implements FrameProvider {
 
         Mat rawImage = Imgcodecs.imread(path.toString());
         if (rawImage.cols() > 0 && rawImage.rows() > 0) {
-            properties =
-                    new FrameStaticProperties(rawImage.width(), rawImage.height(), fov, pitch, calibration);
+            properties = new FrameStaticProperties(rawImage.width(), rawImage.height(), fov, calibration);
             originalFrame = new Frame(new CVMat(rawImage), properties);
         } else {
             throw new RuntimeException("Image loading failed!");

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

@@ -0,0 +1,52 @@
+/*
+ * 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 org.opencv.core.Mat;
+import org.photonvision.vision.apriltag.AprilTagDetector;
+import org.photonvision.vision.apriltag.DetectionResult;
+import org.photonvision.vision.pipe.CVPipe;
+
+public class AprilTagDetectionPipe
+        extends CVPipe<Mat, List<DetectionResult>, AprilTagDetectionPipeParams> {
+    private final AprilTagDetector m_detector = new AprilTagDetector();
+
+    boolean useNativePoseEst;
+
+    @Override
+    protected List<DetectionResult> process(Mat in) {
+        return List.of(
+                m_detector.detect(
+                        in,
+                        params.cameraCalibrationCoefficients,
+                        useNativePoseEst,
+                        params.numIterations,
+                        params.tagWidthMeters));
+    }
+
+    @Override
+    public void setParams(AprilTagDetectionPipeParams params) {
+        super.setParams(params);
+        m_detector.updateParams(params.detectorParams);
+    }
+
+    public void setNativePoseEstimationEnabled(boolean enabled) {
+        this.useNativePoseEst = enabled;
+    }
+}

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

@@ -0,0 +1,77 @@
+/*
+ * 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.Objects;
+import org.photonvision.vision.apriltag.AprilTagDetectorParams;
+import org.photonvision.vision.apriltag.AprilTagFamily;
+import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
+
+public class AprilTagDetectionPipeParams {
+    public final AprilTagDetectorParams detectorParams;
+    public final CameraCalibrationCoefficients cameraCalibrationCoefficients;
+    public final int numIterations;
+    public final double tagWidthMeters;
+
+    public AprilTagDetectionPipeParams(
+            AprilTagFamily tagFamily,
+            double decimate,
+            double blur,
+            int threads,
+            boolean debug,
+            boolean refineEdges,
+            int numIters,
+            double tagWidthMeters,
+            CameraCalibrationCoefficients cameraCalibrationCoefficients) {
+        detectorParams =
+                new AprilTagDetectorParams(tagFamily, decimate, blur, threads, debug, refineEdges);
+        this.cameraCalibrationCoefficients = cameraCalibrationCoefficients;
+        this.numIterations = numIters;
+        this.tagWidthMeters = tagWidthMeters;
+    }
+
+    public AprilTagDetectionPipeParams(
+            AprilTagDetectorParams detectorParams,
+            CameraCalibrationCoefficients cameraCalibrationCoefficients,
+            int numIters,
+            double tagWidthMeters) {
+        this.detectorParams = detectorParams;
+        this.cameraCalibrationCoefficients = cameraCalibrationCoefficients;
+        this.numIterations = numIters;
+        this.tagWidthMeters = tagWidthMeters;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        AprilTagDetectionPipeParams that = (AprilTagDetectionPipeParams) o;
+        return Objects.equals(detectorParams, that.detectorParams)
+                && Objects.equals(cameraCalibrationCoefficients, that.cameraCalibrationCoefficients);
+    }
+
+    @Override
+    public String toString() {
+        return "AprilTagDetectionPipeParams{"
+                + "detectorParams="
+                + detectorParams
+                + ", cameraCalibrationCoefficients="
+                + cameraCalibrationCoefficients
+                + '}';
+    }
+}

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

@@ -0,0 +1,34 @@
+/*
+ * 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.*;
+import org.photonvision.vision.frame.FrameDivisor;
+
+public class Draw2dAprilTagsPipe extends Draw2dTargetsPipe {
+    public static class Draw2dAprilTagsParams extends Draw2dTargetsPipe.Draw2dTargetsParams {
+        public Draw2dAprilTagsParams(
+                boolean shouldDraw, boolean showMultipleTargets, FrameDivisor divisor) {
+            super(shouldDraw, showMultipleTargets, divisor);
+            // We want to show the polygon, not the rotated box
+            this.showRotatedBox = false;
+            this.showMaximumBox = false;
+            this.rotatedBoxColor = Color.RED;
+        }
+    }
+}

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

@@ -97,11 +97,15 @@ public class Draw2dTargetsPipe
                     if (poly == null && target.getShape() != null)
                         poly = target.getShape().getContour().getApproxPolyDp();
                     if (poly != null) {
-                        //                        divideMat2f(poly, pointMat);
                         var mat = new MatOfPoint();
                         mat.fromArray(poly.toArray());
+                        divideMat(mat, mat);
                         Imgproc.drawContours(
-                                in.getLeft(), List.of(mat), -1, ColorHelper.colorToScalar(Color.blue), 2);
+                                in.getLeft(),
+                                List.of(mat),
+                                -1,
+                                ColorHelper.colorToScalar(params.rotatedBoxColor),
+                                2);
                         mat.release();
                     }
                 }
@@ -134,9 +138,12 @@ public class Draw2dTargetsPipe
                                     center.y - params.kPixelsToOffset * imageSize);
                     dividePoint(textPos);
 
+                    int id = target.getFiducialId();
+                    var contourNumber = String.valueOf(id == -1 ? i : id);
+
                     Imgproc.putText(
                             in.getLeft(),
-                            String.valueOf(i),
+                            contourNumber,
                             textPos,
                             0,
                             textSize,
@@ -182,6 +189,14 @@ public class Draw2dTargetsPipe
         dst.fromArray(hull);
     }
 
+    private void divideMat(MatOfPoint2f src, MatOfPoint dst) {
+        var hull = src.toArray();
+        for (Point point : hull) {
+            dividePoint(point);
+        }
+        dst.fromArray(hull);
+    }
+
     /** Scale a given point list by the current frame divisor. the point list is mutated! */
     private void dividePointList(List<Point> points) {
         for (var p : points) {

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

@@ -0,0 +1,35 @@
+/*
+ * 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 org.photonvision.vision.calibration.CameraCalibrationCoefficients;
+import org.photonvision.vision.frame.FrameDivisor;
+import org.photonvision.vision.target.TargetModel;
+
+public class Draw3dAprilTagsPipe extends Draw3dTargetsPipe {
+    public static class Draw3dAprilTagsParams extends Draw3dContoursParams {
+        public Draw3dAprilTagsParams(
+                boolean shouldDraw,
+                CameraCalibrationCoefficients cameraCalibrationCoefficients,
+                TargetModel targetModel,
+                FrameDivisor divisor) {
+            super(shouldDraw, cameraCalibrationCoefficients, targetModel, divisor);
+            this.shouldDrawHull = false;
+        }
+    }
+}

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

@@ -18,13 +18,16 @@
 package org.photonvision.vision.pipe.impl;
 
 import java.awt.*;
+import java.util.ArrayList;
 import java.util.List;
 import org.apache.commons.lang3.tuple.Pair;
 import org.opencv.calib3d.Calib3d;
 import org.opencv.core.Mat;
 import org.opencv.core.MatOfPoint;
 import org.opencv.core.MatOfPoint2f;
+import org.opencv.core.MatOfPoint3f;
 import org.opencv.core.Point;
+import org.opencv.core.Point3;
 import org.opencv.imgproc.Imgproc;
 import org.photonvision.common.logging.LogGroup;
 import org.photonvision.common.logging.Logger;
@@ -42,34 +45,46 @@ public class Draw3dTargetsPipe
     @Override
     protected Void process(Pair<Mat, List<TrackedTarget>> in) {
         if (!params.shouldDraw) return null;
+        if (params.cameraCalibrationCoefficients == null
+                || params.cameraCalibrationCoefficients.getCameraIntrinsicsMat() == null
+                || params.cameraCalibrationCoefficients.getCameraExtrinsicsMat() == null) {
+            return null;
+        }
 
         for (var target : in.getRight()) {
             // draw convex hull
-            var pointMat = new MatOfPoint();
-            divideMat2f(target.m_mainContour.getConvexHull(), pointMat);
-            if (pointMat.size().empty()) {
-                logger.error("Convex hull is empty?");
-                logger.debug(
-                        "Orig. Convex Hull: " + target.m_mainContour.getConvexHull().size().toString());
-                continue;
-            }
-            Imgproc.drawContours(
-                    in.getLeft(), List.of(pointMat), -1, ColorHelper.colorToScalar(Color.green), 1);
-
-            // draw approximate polygon
-            var poly = target.getApproximateBoundingPolygon();
-            if (poly != null) {
-                divideMat2f(poly, pointMat);
+            if (params.shouldDrawHull(target)) {
+                var pointMat = new MatOfPoint();
+                divideMat2f(target.m_mainContour.getConvexHull(), pointMat);
+                if (pointMat.size().empty()) {
+                    logger.error("Convex hull is empty?");
+                    logger.debug(
+                            "Orig. Convex Hull: " + target.m_mainContour.getConvexHull().size().toString());
+                    continue;
+                }
                 Imgproc.drawContours(
-                        in.getLeft(), List.of(pointMat), -1, ColorHelper.colorToScalar(Color.blue), 2);
+                        in.getLeft(), List.of(pointMat), -1, ColorHelper.colorToScalar(Color.green), 1);
+
+                // draw approximate polygon
+                var poly = target.getApproximateBoundingPolygon();
+                if (poly != null) {
+                    divideMat2f(poly, pointMat);
+                    Imgproc.drawContours(
+                            in.getLeft(), List.of(pointMat), -1, ColorHelper.colorToScalar(Color.blue), 2);
+                }
+                pointMat.release();
             }
 
             // Draw floor and top
-            if (target.getCameraRelativeRvec() != null && target.getCameraRelativeTvec() != null) {
+            if (target.getCameraRelativeRvec() != null
+                    && target.getCameraRelativeTvec() != null
+                    && params.shouldDrawBox) {
                 var tempMat = new MatOfPoint2f();
+
                 var jac = new Mat();
                 var bottomModel = params.targetModel.getVisualizationBoxBottom();
                 var topModel = params.targetModel.getVisualizationBoxTop();
+
                 Calib3d.projectPoints(
                         bottomModel,
                         target.getCameraRelativeRvec(),
@@ -78,7 +93,9 @@ public class Draw3dTargetsPipe
                         params.cameraCalibrationCoefficients.getCameraExtrinsicsMat(),
                         tempMat,
                         jac);
+                // Distort the points so they match the image they're being overlaid on
                 var bottomPoints = tempMat.toList();
+
                 Calib3d.projectPoints(
                         topModel,
                         target.getCameraRelativeRvec(),
@@ -101,6 +118,54 @@ public class Draw3dTargetsPipe
                             ColorHelper.colorToScalar(Color.green),
                             3);
                 }
+
+                // Draw X, Y and Z axis
+                MatOfPoint3f pointMat = new MatOfPoint3f();
+                // Those points are in opencv-land, but we are in NWU
+                // NWU | EDN
+                // X: Z
+                // Y: -X
+                // Z: -Y
+                final double AXIS_LEN = 0.2;
+                var list =
+                        List.of(
+                                new Point3(0, 0, 0),
+                                new Point3(0, 0, AXIS_LEN),
+                                new Point3(AXIS_LEN, 0, 0),
+                                new Point3(0, AXIS_LEN, 0));
+                pointMat.fromList(list);
+
+                Calib3d.projectPoints(
+                        pointMat,
+                        target.getCameraRelativeRvec(),
+                        target.getCameraRelativeTvec(),
+                        params.cameraCalibrationCoefficients.getCameraIntrinsicsMat(),
+                        params.cameraCalibrationCoefficients.getCameraExtrinsicsMat(),
+                        tempMat,
+                        jac);
+                var axisPoints = tempMat.toList();
+                dividePointList(axisPoints);
+
+                // Red = x, green y, blue z
+                Imgproc.line(
+                        in.getLeft(),
+                        axisPoints.get(0),
+                        axisPoints.get(2),
+                        ColorHelper.colorToScalar(Color.GREEN),
+                        3);
+                Imgproc.line(
+                        in.getLeft(),
+                        axisPoints.get(0),
+                        axisPoints.get(3),
+                        ColorHelper.colorToScalar(Color.BLUE),
+                        3);
+                Imgproc.line(
+                        in.getLeft(),
+                        axisPoints.get(0),
+                        axisPoints.get(1),
+                        ColorHelper.colorToScalar(Color.RED),
+                        3);
+
                 for (int i = 0; i < bottomPoints.size(); i++) {
                     Imgproc.line(
                             in.getLeft(),
@@ -117,10 +182,11 @@ public class Draw3dTargetsPipe
                             ColorHelper.colorToScalar(Color.orange),
                             3);
                 }
+
                 tempMat.release();
                 jac.release();
+                pointMat.release();
             }
-            pointMat.release();
 
             // draw corners
             var corners = target.getTargetCorners();
@@ -142,6 +208,45 @@ public class Draw3dTargetsPipe
         return null;
     }
 
+    private void distortPoints(MatOfPoint2f src, MatOfPoint2f dst) {
+        var pointsList = src.toList();
+        var dstList = new ArrayList<Point>();
+        final Mat cameraMatrix = params.cameraCalibrationCoefficients.getCameraIntrinsicsMat();
+        // k1, k2, p1, p2, k3
+        final Mat distCoeffs = params.cameraCalibrationCoefficients.getCameraExtrinsicsMat();
+        var cx = cameraMatrix.get(0, 2)[0];
+        var cy = cameraMatrix.get(1, 2)[0];
+        var fx = cameraMatrix.get(0, 0)[0];
+        var fy = cameraMatrix.get(1, 1)[0];
+        var k1 = distCoeffs.get(0, 0)[0];
+        var k2 = distCoeffs.get(0, 1)[0];
+        var k3 = distCoeffs.get(0, 4)[0];
+        var p1 = distCoeffs.get(0, 2)[0];
+        var p2 = distCoeffs.get(0, 3)[0];
+
+        for (Point point : pointsList) {
+            // To relative coordinates <- this is the step you are missing.
+            double x = (point.x - cx) / fx; // cx, cy is the center of distortion
+            double y = (point.y - cy) / fy;
+
+            double r2 = x * x + y * y; // square of the radius from center
+
+            // Radial distorsion
+            double xDistort = x * (1 + k1 * r2 + k2 * r2 * r2 + k3 * r2 * r2 * r2);
+            double yDistort = y * (1 + k1 * r2 + k2 * r2 * r2 + k3 * r2 * r2 * r2);
+
+            // Tangential distorsion
+            xDistort = xDistort + (2 * p1 * x * y + p2 * (r2 + 2 * x * x));
+            yDistort = yDistort + (p1 * (r2 + 2 * y * y) + 2 * p2 * x * y);
+
+            // Back to absolute coordinates.
+            xDistort = xDistort * fx + cx;
+            yDistort = yDistort * fy + cy;
+            dstList.add(new Point(xDistort, yDistort));
+        }
+        dst.fromList(dstList);
+    }
+
     private void divideMat2f(MatOfPoint2f src, MatOfPoint dst) {
         var hull = src.toArray();
         var pointArray = new Point[hull.length];
@@ -154,6 +259,18 @@ public class Draw3dTargetsPipe
         dst.fromArray(pointArray);
     }
 
+    private void divideMat2f(MatOfPoint2f src, MatOfPoint2f dst) {
+        var hull = src.toArray();
+        var pointArray = new Point[hull.length];
+        for (int i = 0; i < hull.length; i++) {
+            var hullAtI = hull[i];
+            pointArray[i] =
+                    new Point(
+                            hullAtI.x / (double) params.divisor.value, hullAtI.y / (double) params.divisor.value);
+        }
+        dst.fromArray(pointArray);
+    }
+
     /** Scale a given point list by the current frame divisor. the point list is mutated! */
     private void dividePointList(List<Point> points) {
         for (var p : points) {
@@ -167,6 +284,8 @@ public class Draw3dTargetsPipe
         public Color color = Color.RED;
 
         public final boolean shouldDraw;
+        public boolean shouldDrawHull = true;
+        public boolean shouldDrawBox = true;
         public final TargetModel targetModel;
         public final CameraCalibrationCoefficients cameraCalibrationCoefficients;
         public final FrameDivisor divisor;
@@ -181,5 +300,9 @@ public class Draw3dTargetsPipe
             this.targetModel = targetModel;
             this.divisor = divisor;
         }
+
+        public boolean shouldDrawHull(TrackedTarget t) {
+            return !t.isFiducial() && this.shouldDrawHull;
+        }
     }
 }

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

@@ -0,0 +1,38 @@
+/*
+ * 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 org.opencv.core.Mat;
+import org.opencv.imgproc.Imgproc;
+import org.photonvision.vision.pipe.CVPipe;
+
+public class GrayscalePipe extends CVPipe<Mat, Mat, GrayscalePipe.GrayscaleParams> {
+    @Override
+    protected Mat process(Mat in) {
+        var outputMat = new Mat();
+        // We can save a copy here by sending the output of cvtcolor to outputMat directly
+        // rather than copying. Free performance!
+        Imgproc.cvtColor(in, outputMat, Imgproc.COLOR_BGR2GRAY, 3);
+
+        return outputMat;
+    }
+
+    public static class GrayscaleParams {
+        public GrayscaleParams() {}
+    }
+}

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

@@ -17,9 +17,11 @@
 
 package org.photonvision.vision.pipe.impl;
 
-import edu.wpi.first.math.geometry.Rotation2d;
-import edu.wpi.first.math.geometry.Transform2d;
-import edu.wpi.first.math.geometry.Translation2d;
+import edu.wpi.first.math.VecBuilder;
+import edu.wpi.first.math.geometry.Pose3d;
+import edu.wpi.first.math.geometry.Rotation3d;
+import edu.wpi.first.math.geometry.Transform3d;
+import edu.wpi.first.math.geometry.Translation3d;
 import java.util.List;
 import org.opencv.calib3d.Calib3d;
 import org.opencv.core.Core;
@@ -28,6 +30,7 @@ import org.opencv.core.MatOfPoint2f;
 import org.opencv.core.Scalar;
 import org.photonvision.common.logging.LogGroup;
 import org.photonvision.common.logging.Logger;
+import org.photonvision.common.util.math.MathUtils;
 import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
 import org.photonvision.vision.pipe.CVPipe;
 import org.photonvision.vision.target.TargetModel;
@@ -61,8 +64,6 @@ public class SolvePNPPipe
     }
 
     private void calculateTargetPose(TrackedTarget target) {
-        Transform2d targetPose;
-
         var corners = target.getTargetCorners();
         if (corners == null
                 || corners.isEmpty()
@@ -91,9 +92,17 @@ public class SolvePNPPipe
         target.setCameraRelativeTvec(tVec);
         target.setCameraRelativeRvec(rVec);
 
-        targetPose = correctLocationForCameraPitch(tVec, rVec, params.cameraPitchAngle);
+        Translation3d translation =
+                new Translation3d(tVec.get(0, 0)[0], tVec.get(1, 0)[0], tVec.get(2, 0)[0]);
+        Rotation3d rotation =
+                new Rotation3d(
+                        VecBuilder.fill(rVec.get(0, 0)[0], rVec.get(1, 0)[0], rVec.get(2, 0)[0]),
+                        Core.norm(rVec));
 
-        target.setCameraToTarget(targetPose);
+        Pose3d targetPose = MathUtils.convertOpenCVtoPhotonPose(new Transform3d(translation, rotation));
+        target.setBestCameraToTarget3d(
+                new Transform3d(targetPose.getTranslation(), targetPose.getRotation()));
+        target.setAltCameraToTarget3d(new Transform3d());
     }
 
     Mat rotationMatrix = new Mat();
@@ -102,43 +111,6 @@ public class SolvePNPPipe
     Mat kMat = new Mat();
     Mat scaledTvec;
 
-    @SuppressWarnings("DuplicatedCode") // yes I know we have another solvePNP pipe
-    private Transform2d correctLocationForCameraPitch(
-            Mat tVec, Mat rVec, Rotation2d cameraPitchAngle) {
-        // Algorithm from team 5190 Green Hope Falcons. Can also be found in Ligerbot's vision
-        // whitepaper
-        var tiltAngle = cameraPitchAngle.getRadians();
-
-        // the left/right distance to the target, unchanged by tilt.
-        var x = tVec.get(0, 0)[0];
-
-        // Z distance in the flat plane is given by
-        // Z_field = z cos theta + y sin theta.
-        // Z is the distance "out" of the camera (straight forward).
-        var zField = tVec.get(2, 0)[0] * Math.cos(tiltAngle) + tVec.get(1, 0)[0] * Math.sin(tiltAngle);
-
-        Calib3d.Rodrigues(rVec, rotationMatrix);
-        Core.transpose(rotationMatrix, inverseRotationMatrix);
-
-        scaledTvec = matScale(tVec, -1);
-
-        Core.gemm(inverseRotationMatrix, scaledTvec, 1, kMat, 0, pzeroWorld);
-        scaledTvec.release();
-
-        var angle2 = Math.atan2(pzeroWorld.get(0, 0)[0], pzeroWorld.get(2, 0)[0]);
-
-        // target rotation is the rotation of the target relative to straight ahead. this number
-        // should be unchanged if the robot purely translated left/right.
-        var targetRotation = -angle2; // radians
-
-        // We want a vector that is X forward and Y left.
-        // We have a Z_field (out of the camera projected onto the field), and an X left/right.
-        // so Z_field becomes X, and X becomes Y
-
-        var targetLocation = new Translation2d(zField, -x);
-        return new Transform2d(targetLocation, new Rotation2d(targetRotation));
-    }
-
     /**
      * Element-wise scale a matrix by a given factor
      *
@@ -156,15 +128,11 @@ public class SolvePNPPipe
 
     public static class SolvePNPPipeParams {
         private final CameraCalibrationCoefficients cameraCoefficients;
-        private final Rotation2d cameraPitchAngle;
         private final TargetModel targetModel;
 
         public SolvePNPPipeParams(
-                CameraCalibrationCoefficients cameraCoefficients,
-                Rotation2d cameraPitchAngle,
-                TargetModel targetModel) {
+                CameraCalibrationCoefficients cameraCoefficients, TargetModel targetModel) {
             this.cameraCoefficients = cameraCoefficients;
-            this.cameraPitchAngle = cameraPitchAngle;
             this.targetModel = targetModel;
         }
     }

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

@@ -0,0 +1,162 @@
+/*
+ * 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.pipeline;
+
+import edu.wpi.first.math.geometry.Transform3d;
+import edu.wpi.first.math.util.Units;
+import java.util.ArrayList;
+import java.util.List;
+import org.opencv.core.Mat;
+import org.photonvision.common.util.math.MathUtils;
+import org.photonvision.raspi.PicamJNI;
+import org.photonvision.vision.apriltag.AprilTagDetectorParams;
+import org.photonvision.vision.apriltag.DetectionResult;
+import org.photonvision.vision.camera.CameraQuirk;
+import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.pipe.CVPipe.CVPipeResult;
+import org.photonvision.vision.pipe.impl.*;
+import org.photonvision.vision.pipeline.result.CVPipelineResult;
+import org.photonvision.vision.target.TrackedTarget;
+import org.photonvision.vision.target.TrackedTarget.TargetCalculationParameters;
+
+@SuppressWarnings("DuplicatedCode")
+public class AprilTagPipeline extends CVPipeline<CVPipelineResult, AprilTagPipelineSettings> {
+    private final RotateImagePipe rotateImagePipe = new RotateImagePipe();
+    private final GrayscalePipe grayscalePipe = new GrayscalePipe();
+    private final AprilTagDetectionPipe aprilTagDetectionPipe = new AprilTagDetectionPipe();
+    private final CalculateFPSPipe calculateFPSPipe = new CalculateFPSPipe();
+
+    public AprilTagPipeline() {
+        settings = new AprilTagPipelineSettings();
+    }
+
+    public AprilTagPipeline(AprilTagPipelineSettings settings) {
+        this.settings = settings;
+    }
+
+    @Override
+    protected void setPipeParamsImpl() {
+        // Sanitize thread count - not supported to have fewer than 1 threads
+        settings.threads = Math.max(1, settings.threads);
+
+        RotateImagePipe.RotateImageParams rotateImageParams =
+                new RotateImagePipe.RotateImageParams(settings.inputImageRotationMode);
+        rotateImagePipe.setParams(rotateImageParams);
+
+        if (cameraQuirks.hasQuirk(CameraQuirk.PiCam) && PicamJNI.isSupported()) {
+            // TODO: Picam grayscale
+            PicamJNI.setRotation(settings.inputImageRotationMode.value);
+            PicamJNI.setShouldCopyColor(true); // need the color image to grayscale
+        }
+
+        AprilTagDetectorParams aprilTagDetectionParams =
+                new AprilTagDetectorParams(
+                        settings.tagFamily,
+                        settings.decimate,
+                        settings.blur,
+                        settings.threads,
+                        settings.debug,
+                        settings.refineEdges);
+
+        // TODO (HACK): tag width is Fun because it really belongs in the "target model"
+        // We need the tag width for the JNI to figure out target pose, but we need a
+        // target model for the draw 3d targets pipeline to work...
+
+        // for now, hard code tag width based on enum value
+        double tagWidth = 0.16; // guess at 200mm??
+        switch (settings.targetModel) {
+            case k200mmAprilTag:
+                {
+                    tagWidth = Units.inchesToMeters(3.25 * 2);
+                    break;
+                }
+            default:
+                {
+                    break;
+                }
+        }
+
+        aprilTagDetectionPipe.setParams(
+                new AprilTagDetectionPipeParams(
+                        aprilTagDetectionParams,
+                        frameStaticProperties.cameraCalibration,
+                        settings.numIterations,
+                        tagWidth));
+    }
+
+    @Override
+    protected CVPipelineResult process(Frame frame, AprilTagPipelineSettings settings) {
+        long sumPipeNanosElapsed = 0L;
+
+        CVPipeResult<Mat> grayscalePipeResult;
+        Mat rawInputMat;
+        boolean inputSingleChannel = frame.image.getMat().channels() == 1;
+
+        if (inputSingleChannel) {
+            rawInputMat = new Mat(PicamJNI.grabFrame(true));
+            frame.image.getMat().release(); // release the 8bit frame ASAP.
+        } else {
+            rawInputMat = frame.image.getMat();
+            var rotateImageResult = rotateImagePipe.run(rawInputMat);
+            sumPipeNanosElapsed += rotateImageResult.nanosElapsed;
+        }
+
+        var inputFrame = new Frame(new CVMat(rawInputMat), frameStaticProperties);
+
+        grayscalePipeResult = grayscalePipe.run(rawInputMat);
+        sumPipeNanosElapsed += grayscalePipeResult.nanosElapsed;
+
+        var outputFrame = new Frame(new CVMat(grayscalePipeResult.output), frameStaticProperties);
+
+        List<TrackedTarget> targetList;
+        CVPipeResult<List<DetectionResult>> tagDetectionPipeResult;
+
+        // Use the solvePNP Enabled flag to enable native pose estimation
+        aprilTagDetectionPipe.setNativePoseEstimationEnabled(settings.solvePNPEnabled);
+
+        tagDetectionPipeResult = aprilTagDetectionPipe.run(grayscalePipeResult.output);
+        sumPipeNanosElapsed += tagDetectionPipeResult.nanosElapsed;
+
+        targetList = new ArrayList<>();
+        for (DetectionResult detection : tagDetectionPipeResult.output) {
+            // populate the target list
+            // Challenge here is that TrackedTarget functions with OpenCV Contour
+            TrackedTarget target =
+                    new TrackedTarget(
+                            detection,
+                            new TargetCalculationParameters(
+                                    false, null, null, null, null, frameStaticProperties));
+
+            var correctedBestPose = MathUtils.convertOpenCVtoPhotonPose(target.getBestCameraToTarget3d());
+            var correctedAltPose = MathUtils.convertOpenCVtoPhotonPose(target.getAltCameraToTarget3d());
+
+            target.setBestCameraToTarget3d(
+                    new Transform3d(correctedBestPose.getTranslation(), correctedBestPose.getRotation()));
+            target.setAltCameraToTarget3d(
+                    new Transform3d(correctedAltPose.getTranslation(), correctedAltPose.getRotation()));
+
+            targetList.add(target);
+        }
+
+        var fpsResult = calculateFPSPipe.run(null);
+        var fps = fpsResult.output;
+
+        return new CVPipelineResult(sumPipeNanosElapsed, fps, targetList, outputFrame, inputFrame);
+    }
+}

photon-core/src/main/java/org/photonvision/vision/pipeline/AprilTagPipelineSettings.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.pipeline;
+
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import java.util.Objects;
+import org.photonvision.vision.apriltag.AprilTagFamily;
+import org.photonvision.vision.target.TargetModel;
+
+@JsonTypeName("AprilTagPipelineSettings")
+public class AprilTagPipelineSettings extends AdvancedPipelineSettings {
+    public AprilTagFamily tagFamily = AprilTagFamily.kTag36h11;
+    public double decimate = 1.0;
+    public double blur = 0;
+    public int threads = 1;
+    public boolean debug = false;
+    public boolean refineEdges = true;
+    public int numIterations = 200;
+
+    // 3d settings
+
+    public AprilTagPipelineSettings() {
+        super();
+        pipelineType = PipelineType.AprilTag;
+        outputShowMultipleTargets = true;
+        targetModel = TargetModel.k200mmAprilTag;
+        cameraExposure = -1;
+        cameraAutoExposure = true;
+        ledMode = false;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        if (!super.equals(o)) return false;
+        AprilTagPipelineSettings that = (AprilTagPipelineSettings) o;
+        return Objects.equals(tagFamily, that.tagFamily)
+                && Double.compare(decimate, that.decimate) == 0
+                && Double.compare(blur, that.blur) == 0
+                && threads == that.threads
+                && debug == that.debug
+                && refineEdges == that.refineEdges;
+    }
+}

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

@@ -31,7 +31,8 @@ import org.photonvision.vision.opencv.ImageRotationMode;
 @JsonSubTypes({
     @JsonSubTypes.Type(value = ColoredShapePipelineSettings.class),
     @JsonSubTypes.Type(value = ReflectivePipelineSettings.class),
-    @JsonSubTypes.Type(value = DriverModePipelineSettings.class)
+    @JsonSubTypes.Type(value = DriverModePipelineSettings.class),
+    @JsonSubTypes.Type(value = AprilTagPipelineSettings.class)
 })
 public class CVPipelineSettings implements Cloneable {
     public int pipelineIndex = 0;
@@ -39,14 +40,16 @@ public class CVPipelineSettings implements Cloneable {
     public ImageFlipMode inputImageFlipMode = ImageFlipMode.NONE;
     public ImageRotationMode inputImageRotationMode = ImageRotationMode.DEG_0;
     public String pipelineNickname = "New Pipeline";
-    public double cameraExposure = 50;
+    public boolean cameraAutoExposure = false;
+    // manual exposure only used if cameraAutoExposure if false
+    public double cameraExposure = 100;
     public int cameraBrightness = 50;
     // Currently only used by a few cameras (notably the zero-copy Pi Camera driver) with the Gain
     // quirk
     public int cameraGain = 50;
     // Currently only used by the zero-copy Pi Camera driver
-    public int cameraRedGain = 50;
-    public int cameraBlueGain = 50;
+    public int cameraRedGain = 18;
+    public int cameraBlueGain = 24;
     public int cameraVideoModeIndex = 0;
     public FrameDivisor streamingFrameDivisor = FrameDivisor.NONE;
     public boolean ledMode = false;

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

@@ -162,9 +162,7 @@ public class ColoredShapePipeline
 
         var solvePNPParams =
                 new SolvePNPPipe.SolvePNPPipeParams(
-                        frameStaticProperties.cameraCalibration,
-                        frameStaticProperties.cameraPitch,
-                        settings.targetModel);
+                        frameStaticProperties.cameraCalibration, settings.targetModel);
         solvePNPPipe.setParams(solvePNPParams);
 
         Draw2dTargetsPipe.Draw2dTargetsParams draw2DTargetsParams =

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

@@ -37,6 +37,8 @@ public class OutputStreamPipeline {
     private final Draw2dCrosshairPipe draw2dCrosshairPipe = new Draw2dCrosshairPipe();
     private final Draw2dTargetsPipe draw2dTargetsPipe = new Draw2dTargetsPipe();
     private final Draw3dTargetsPipe draw3dTargetsPipe = new Draw3dTargetsPipe();
+    private final Draw2dAprilTagsPipe draw2dAprilTagsPipe = new Draw2dAprilTagsPipe();
+    private final Draw3dAprilTagsPipe draw3dAprilTagsPipe = new Draw3dAprilTagsPipe();
     private final CalculateFPSPipe calculateFPSPipe = new CalculateFPSPipe();
     private final ResizeImagePipe resizeImagePipe = new ResizeImagePipe();
 
@@ -58,6 +60,13 @@ public class OutputStreamPipeline {
                         settings.streamingFrameDivisor);
         draw2dTargetsPipe.setParams(draw2DTargetsParams);
 
+        var draw2DAprilTagsParams =
+                new Draw2dAprilTagsPipe.Draw2dAprilTagsParams(
+                        settings.outputShouldDraw,
+                        settings.outputShowMultipleTargets,
+                        settings.streamingFrameDivisor);
+        draw2dAprilTagsPipe.setParams(draw2DAprilTagsParams);
+
         var draw2dCrosshairParams =
                 new Draw2dCrosshairPipe.Draw2dCrosshairParams(
                         settings.outputShouldDraw,
@@ -76,6 +85,14 @@ public class OutputStreamPipeline {
                         settings.streamingFrameDivisor);
         draw3dTargetsPipe.setParams(draw3dTargetsParams);
 
+        var draw3dAprilTagsParams =
+                new Draw3dAprilTagsPipe.Draw3dAprilTagsParams(
+                        settings.outputShouldDraw,
+                        frameStaticProperties.cameraCalibration,
+                        settings.targetModel,
+                        settings.streamingFrameDivisor);
+        draw3dAprilTagsPipe.setParams(draw3dAprilTagsParams);
+
         resizeImagePipe.setParams(
                 new ResizeImagePipe.ResizeImageParams(settings.streamingFrameDivisor));
     }
@@ -96,37 +113,67 @@ public class OutputStreamPipeline {
         sumPipeNanosElapsed += pipeProfileNanos[1] = resizeImagePipe.run(outMat).nanosElapsed;
 
         // Convert single-channel HSV output mat to 3-channel BGR in preparation for streaming
-        var outputMatPipeResult = outputMatPipe.run(outMat);
-        sumPipeNanosElapsed += pipeProfileNanos[2] = outputMatPipeResult.nanosElapsed;
-
-        // Draw 2D Crosshair on input and output
-        var draw2dCrosshairResultOnInput = draw2dCrosshairPipe.run(Pair.of(inMat, targetsToDraw));
-        sumPipeNanosElapsed += pipeProfileNanos[3] = draw2dCrosshairResultOnInput.nanosElapsed;
-
-        var draw2dCrosshairResultOnOutput = draw2dCrosshairPipe.run(Pair.of(outMat, targetsToDraw));
-        sumPipeNanosElapsed += pipeProfileNanos[4] = draw2dCrosshairResultOnOutput.nanosElapsed;
-
-        // Draw 3D Targets on input and output if necessary
-        if (settings.solvePNPEnabled
-                || (settings.solvePNPEnabled
-                        && settings instanceof ColoredShapePipelineSettings
-                        && ((ColoredShapePipelineSettings) settings).contourShape == ContourShape.Circle)) {
-            var drawOnInputResult = draw3dTargetsPipe.run(Pair.of(inMat, targetsToDraw));
-            sumPipeNanosElapsed += pipeProfileNanos[7] = drawOnInputResult.nanosElapsed;
-
-            var drawOnOutputResult = draw3dTargetsPipe.run(Pair.of(outMat, targetsToDraw));
-            sumPipeNanosElapsed += pipeProfileNanos[8] = drawOnOutputResult.nanosElapsed;
+        if (outMat.channels() == 1) {
+            var outputMatPipeResult = outputMatPipe.run(outMat);
+            sumPipeNanosElapsed += pipeProfileNanos[2] = outputMatPipeResult.nanosElapsed;
         } else {
-            pipeProfileNanos[7] = 0;
-            pipeProfileNanos[8] = 0;
+            pipeProfileNanos[2] = 0;
         }
 
-        // Draw 2D contours on input and output
-        var draw2dTargetsOnInput = draw2dTargetsPipe.run(Pair.of(inMat, targetsToDraw));
-        sumPipeNanosElapsed += pipeProfileNanos[5] = draw2dTargetsOnInput.nanosElapsed;
+        // Draw 2D Crosshair on output
+        var draw2dCrosshairResultOnInput = draw2dCrosshairPipe.run(Pair.of(outMat, targetsToDraw));
+        sumPipeNanosElapsed += pipeProfileNanos[3] = draw2dCrosshairResultOnInput.nanosElapsed;
 
-        var draw2dTargetsOnOutput = draw2dTargetsPipe.run(Pair.of(outMat, targetsToDraw));
-        sumPipeNanosElapsed += pipeProfileNanos[6] = draw2dTargetsOnOutput.nanosElapsed;
+        if (!(settings instanceof AprilTagPipelineSettings)) {
+            // If we're processing anything other than Apriltags...
+
+            var draw2dCrosshairResultOnOutput = draw2dCrosshairPipe.run(Pair.of(outMat, targetsToDraw));
+            sumPipeNanosElapsed += pipeProfileNanos[4] = draw2dCrosshairResultOnOutput.nanosElapsed;
+
+            if (settings.solvePNPEnabled
+                    || (settings.solvePNPEnabled
+                            && settings instanceof ColoredShapePipelineSettings
+                            && ((ColoredShapePipelineSettings) settings).contourShape == ContourShape.Circle)) {
+                // Draw 3D Targets on input and output if possible
+                pipeProfileNanos[5] = 0;
+                pipeProfileNanos[6] = 0;
+                pipeProfileNanos[7] = 0;
+
+                var drawOnOutputResult = draw3dTargetsPipe.run(Pair.of(outMat, targetsToDraw));
+                sumPipeNanosElapsed += pipeProfileNanos[8] = drawOnOutputResult.nanosElapsed;
+            } else {
+                // Only draw 2d targets
+                pipeProfileNanos[5] = 0;
+
+                var draw2dTargetsOnOutput = draw2dTargetsPipe.run(Pair.of(outMat, targetsToDraw));
+                sumPipeNanosElapsed += pipeProfileNanos[6] = draw2dTargetsOnOutput.nanosElapsed;
+
+                pipeProfileNanos[7] = 0;
+                pipeProfileNanos[8] = 0;
+            }
+
+        } else {
+            // If we are doing apriltags...
+            if (settings.solvePNPEnabled) {
+                // Draw 3d Apriltag markers (camera is calibrated and running in 3d mode)
+                pipeProfileNanos[5] = 0;
+                pipeProfileNanos[6] = 0;
+
+                var drawOnInputResult = draw3dAprilTagsPipe.run(Pair.of(outMat, targetsToDraw));
+                sumPipeNanosElapsed += pipeProfileNanos[7] = drawOnInputResult.nanosElapsed;
+
+                pipeProfileNanos[8] = 0;
+
+            } else {
+                // Draw 2d apriltag markers
+                var draw2dTargetsOnInput = draw2dAprilTagsPipe.run(Pair.of(outMat, targetsToDraw));
+                sumPipeNanosElapsed += pipeProfileNanos[5] = draw2dTargetsOnInput.nanosElapsed;
+
+                pipeProfileNanos[6] = 0;
+                pipeProfileNanos[7] = 0;
+                pipeProfileNanos[8] = 0;
+            }
+        }
 
         var fpsResult = calculateFPSPipe.run(null);
         var fps = fpsResult.output;

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

@@ -22,7 +22,8 @@ public enum PipelineType {
     Calib3d(-2, Calibrate3dPipeline.class),
     DriverMode(-1, DriverModePipeline.class),
     Reflective(0, ReflectivePipeline.class),
-    ColoredShape(1, ColoredShapePipeline.class);
+    ColoredShape(1, ColoredShapePipeline.class),
+    AprilTag(2, AprilTagPipeline.class);
 
     public final int baseIndex;
     public final Class clazz;

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

@@ -140,9 +140,7 @@ public class ReflectivePipeline extends CVPipeline<CVPipelineResult, ReflectiveP
 
         var solvePNPParams =
                 new SolvePNPPipe.SolvePNPPipeParams(
-                        frameStaticProperties.cameraCalibration,
-                        frameStaticProperties.cameraPitch,
-                        settings.targetModel);
+                        frameStaticProperties.cameraCalibration, settings.targetModel);
         solvePNPPipe.setParams(solvePNPParams);
     }
 

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

@@ -181,13 +181,23 @@ public class PipelineManager {
             var desiredPipelineSettings = userPipelineSettings.get(currentPipelineIndex);
             switch (desiredPipelineSettings.pipelineType) {
                 case Reflective:
+                    logger.debug("Creatig Reflective pipeline");
                     currentUserPipeline =
                             new ReflectivePipeline((ReflectivePipelineSettings) desiredPipelineSettings);
                     break;
                 case ColoredShape:
+                    logger.debug("Creatig ColoredShape pipeline");
                     currentUserPipeline =
                             new ColoredShapePipeline((ColoredShapePipelineSettings) desiredPipelineSettings);
                     break;
+                case AprilTag:
+                    logger.debug("Creatig AprilTag pipeline");
+                    currentUserPipeline =
+                            new AprilTagPipeline((AprilTagPipelineSettings) desiredPipelineSettings);
+                    break;
+                default:
+                    // Can be calib3d or drivermode, both of which are special cases
+                    break;
             }
         }
     }
@@ -269,6 +279,12 @@ public class PipelineManager {
                     added.pipelineNickname = nickname;
                     return added;
                 }
+            case AprilTag:
+                {
+                    var added = new AprilTagPipelineSettings();
+                    added.pipelineNickname = nickname;
+                    return added;
+                }
             default:
                 {
                     logger.error("Got invalid pipeline type: " + type.toString());
@@ -400,7 +416,9 @@ public class PipelineManager {
         }
 
         logger.info("Adding new pipe of type " + type.toString() + " at idx " + idx);
+        newSettings.pipelineIndex = idx;
         userPipelineSettings.set(idx, newSettings);
         setPipelineInternal(idx);
+        reassignIndexes();
     }
 }

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

@@ -17,7 +17,6 @@
 
 package org.photonvision.vision.processes;
 
-import edu.wpi.first.math.geometry.Rotation2d;
 import edu.wpi.first.math.util.Units;
 import io.javalin.websocket.WsContext;
 import java.util.*;
@@ -41,7 +40,6 @@ import org.photonvision.vision.camera.USBCameraSource;
 import org.photonvision.vision.camera.ZeroCopyPicamSource;
 import org.photonvision.vision.frame.Frame;
 import org.photonvision.vision.frame.consumer.FileSaveFrameConsumer;
-import org.photonvision.vision.frame.consumer.MJPGFrameConsumer;
 import org.photonvision.vision.pipeline.AdvancedPipelineSettings;
 import org.photonvision.vision.pipeline.OutputStreamPipeline;
 import org.photonvision.vision.pipeline.ReflectivePipelineSettings;
@@ -49,6 +47,8 @@ import org.photonvision.vision.pipeline.UICalibrationData;
 import org.photonvision.vision.pipeline.result.CVPipelineResult;
 import org.photonvision.vision.target.TargetModel;
 import org.photonvision.vision.target.TrackedTarget;
+import org.photonvision.vision.videoStream.SocketVideoStream;
+import org.photonvision.vision.videoStream.SocketVideoStreamManager;
 
 /**
  * This is the God Class
@@ -57,32 +57,31 @@ import org.photonvision.vision.target.TrackedTarget;
  * provide info on settings changes. VisionModuleManager holds a list of all current vision modules.
  */
 public class VisionModule {
-    private static final int streamFPSCap = 30;
-
     private final Logger logger;
     protected final PipelineManager pipelineManager;
     protected final VisionSource visionSource;
     private final VisionRunner visionRunner;
     private final StreamRunnable streamRunnable;
     private final LinkedList<CVPipelineResultConsumer> resultConsumers = new LinkedList<>();
-    private final LinkedList<CVPipelineResultConsumer> fpsLimitedResultConsumers = new LinkedList<>();
     // Raw result consumers run before any drawing has been done by the OutputStreamPipeline
-    private final LinkedList<TriConsumer<Frame, Frame, List<TrackedTarget>>> rawResultConsumers =
+    private final LinkedList<TriConsumer<Frame, Frame, List<TrackedTarget>>> streamResultConsumers =
             new LinkedList<>();
     private final NTDataPublisher ntConsumer;
     private final UIDataPublisher uiDataConsumer;
     protected final int moduleIndex;
     protected final QuirkyCamera cameraQuirks;
 
-    private long lastFrameConsumeMillis;
     protected TrackedTarget lastPipelineResultBestTarget;
 
-    MJPGFrameConsumer dashboardInputStreamer;
-    MJPGFrameConsumer dashboardOutputStreamer;
+    private int inputStreamPort = -1;
+    private int outputStreamPort = -1;
 
     FileSaveFrameConsumer inputFrameSaver;
     FileSaveFrameConsumer outputFrameSaver;
 
+    SocketVideoStream inputVideoStreamer;
+    SocketVideoStream outputVideoStreamer;
+
     public VisionModule(PipelineManager pipelineManager, VisionSource visionSource, int index) {
         logger =
                 new Logger(
@@ -107,7 +106,7 @@ public class VisionModule {
                         if (it.cameraGain == -1) it.cameraGain = 20; // Sane default
                     });
         }
-        if (cameraQuirks.hasQuirk(CameraQuirk.PiCam)) {
+        if (cameraQuirks.hasQuirk(CameraQuirk.AWBGain)) {
             pipelineManager.userPipelineSettings.forEach(
                     it -> {
                         if (it.cameraRedGain == -1) it.cameraRedGain = 16; // Sane defaults
@@ -130,7 +129,7 @@ public class VisionModule {
 
         createStreams();
 
-        recreateFpsLimitedResultConsumers();
+        recreateStreamResultConsumers();
 
         ntConsumer =
                 new NTDataPublisher(
@@ -167,49 +166,33 @@ public class VisionModule {
     }
 
     private void destroyStreams() {
-        dashboardInputStreamer.close();
-        dashboardOutputStreamer.close();
+        SocketVideoStreamManager.getInstance().removeStream(inputVideoStreamer);
+        SocketVideoStreamManager.getInstance().removeStream(outputVideoStreamer);
     }
 
     private void createStreams() {
         var camStreamIdx = visionSource.getSettables().getConfiguration().streamIndex;
         // If idx = 0, we want (1181, 1182)
-        var inputStreamPort = 1181 + (camStreamIdx * 2);
-        var outputStreamPort = 1181 + (camStreamIdx * 2) + 1;
-
-        dashboardOutputStreamer =
-                new MJPGFrameConsumer(
-                        visionSource.getSettables().getConfiguration().nickname + "-output", outputStreamPort);
-        dashboardInputStreamer =
-                new MJPGFrameConsumer(
-                        visionSource.getSettables().getConfiguration().uniqueName + "-input", inputStreamPort);
+        this.inputStreamPort = 1181 + (camStreamIdx * 2);
+        this.outputStreamPort = 1181 + (camStreamIdx * 2) + 1;
 
         inputFrameSaver =
                 new FileSaveFrameConsumer(visionSource.getSettables().getConfiguration().nickname, "input");
         outputFrameSaver =
                 new FileSaveFrameConsumer(
                         visionSource.getSettables().getConfiguration().nickname, "output");
+
+        inputVideoStreamer = new SocketVideoStream(this.inputStreamPort);
+        outputVideoStreamer = new SocketVideoStream(this.outputStreamPort);
+        SocketVideoStreamManager.getInstance().addStream(inputVideoStreamer);
+        SocketVideoStreamManager.getInstance().addStream(outputVideoStreamer);
     }
 
-    private void recreateFpsLimitedResultConsumers() {
-        // Important! These must come before the stream result consumers because the stream result
-        // consumers release the frame
-        rawResultConsumers.add((in, out, tgts) -> inputFrameSaver.accept(in));
-        fpsLimitedResultConsumers.add(result -> outputFrameSaver.accept(result.outputFrame));
-
-        fpsLimitedResultConsumers.add(
-                result -> {
-                    if (this.pipelineManager.getCurrentPipelineSettings().inputShouldShow)
-                        dashboardInputStreamer.accept(result.inputFrame);
-                    else dashboardInputStreamer.disabledTick();
-                });
-        fpsLimitedResultConsumers.add(
-                result -> {
-                    if (this.pipelineManager.getCurrentPipelineSettings().outputShouldShow)
-                        dashboardOutputStreamer.accept(result.outputFrame);
-                    else dashboardInputStreamer.disabledTick();
-                    ;
-                });
+    private void recreateStreamResultConsumers() {
+        streamResultConsumers.add((in, out, tgts) -> inputFrameSaver.accept(in));
+        streamResultConsumers.add((in, out, tgts) -> outputFrameSaver.accept(out));
+        streamResultConsumers.add((in, out, tgts) -> inputVideoStreamer.accept(in));
+        streamResultConsumers.add((in, out, tgts) -> outputVideoStreamer.accept(out));
     }
 
     private class StreamRunnable extends Thread {
@@ -271,10 +254,11 @@ public class VisionModule {
                     this.shouldRun = false;
                 }
                 if (shouldRun) {
-                    consumeRawResults(inputFrame, outputFrame, targets);
                     try {
-                        var osr = outputStreamPipeline.process(inputFrame, outputFrame, settings, targets);
-                        consumeFpsLimitedResult(osr);
+                        CVPipelineResult osr =
+                                outputStreamPipeline.process(inputFrame, outputFrame, settings, targets);
+                        consumeResults(inputFrame, osr.outputFrame, targets);
+
                     } catch (Exception e) {
                         // Never die
                         logger.error("Exception while running stream runnable!", e);
@@ -297,29 +281,14 @@ public class VisionModule {
         }
     }
 
-    void setDriverMode(boolean isDriverMode) {
-        pipelineManager.setDriverMode(isDriverMode);
-        setVisionLEDs(!isDriverMode);
-        saveAndBroadcastAll();
-    }
-
     public void start() {
         visionRunner.startProcess();
         streamRunnable.start();
     }
 
-    public void setFovAndPitch(double fov, Rotation2d pitch) {
+    public void setFov(double fov) {
         var settables = visionSource.getSettables();
-        logger.trace(
-                () ->
-                        "Setting "
-                                + settables.getConfiguration().nickname
-                                + ": pitch ("
-                                + pitch.getDegrees()
-                                + ") FOV ("
-                                + fov
-                                + ")");
-        settables.setCameraPitch(pitch);
+        logger.trace(() -> "Setting " + settables.getConfiguration().nickname + ") FOV (" + fov + ")");
 
         // Only set FOV if we have no vendor JSON and we aren't using a PiCAM
         if (isVendorCamera()) {
@@ -333,6 +302,22 @@ public class VisionModule {
         return visionSource.isVendorCamera();
     }
 
+    void changePipelineType(int newType) {
+        pipelineManager.changePipelineType(newType);
+        setPipeline(pipelineManager.getCurrentPipelineIndex());
+        saveAndBroadcastAll();
+    }
+
+    void setDriverMode(boolean isDriverMode) {
+        pipelineManager.setDriverMode(isDriverMode);
+        setVisionLEDs(!isDriverMode);
+        setPipeline(
+                isDriverMode
+                        ? PipelineManager.DRIVERMODE_INDEX
+                        : pipelineManager.getCurrentPipelineIndex());
+        saveAndBroadcastAll();
+    }
+
     public void startCalibration(UICalibrationData data) {
         var settings = pipelineManager.calibration3dPipeline.getSettings();
         pipelineManager.calibration3dPipeline.deleteSavedImages();
@@ -352,11 +337,13 @@ public class VisionModule {
         if (!cameraQuirks.hasQuirk(CameraQuirk.Gain)) {
             settings.cameraGain = -1;
         }
-        if (!cameraQuirks.hasQuirk(CameraQuirk.PiCam)) {
+        if (!cameraQuirks.hasQuirk(CameraQuirk.AWBGain)) {
             settings.cameraRedGain = -1;
             settings.cameraBlueGain = -1;
         }
 
+        settings.cameraAutoExposure = true;
+
         setPipeline(PipelineManager.CAL_3D_INDEX);
     }
 
@@ -383,37 +370,46 @@ public class VisionModule {
     void setPipeline(int index) {
         logger.info("Setting pipeline to " + index);
         pipelineManager.setIndex(index);
-        var config = pipelineManager.getPipelineSettings(index);
+        var pipelineSettings = pipelineManager.getPipelineSettings(index);
 
-        if (config == null) {
+        if (pipelineSettings == null) {
             logger.error("Config for index " + index + " was null!");
             return;
         }
 
-        visionSource.getSettables().setVideoModeInternal(config.cameraVideoModeIndex);
-        visionSource.getSettables().setBrightness(config.cameraBrightness);
-        visionSource.getSettables().setExposure(config.cameraExposure);
-        visionSource.getSettables().setGain(config.cameraGain);
+        visionSource.getSettables().setVideoModeInternal(pipelineSettings.cameraVideoModeIndex);
+        visionSource.getSettables().setBrightness(pipelineSettings.cameraBrightness);
+        visionSource.getSettables().setGain(pipelineSettings.cameraGain);
+
+        // If manual exposure, force exposure slider to be valid
+        if (!pipelineSettings.cameraAutoExposure) {
+            if (pipelineSettings.cameraExposure < 0)
+                pipelineSettings.cameraExposure = 10; // reasonable default
+        }
+
+        visionSource.getSettables().setExposure(pipelineSettings.cameraExposure);
+        visionSource.getSettables().setAutoExposure(pipelineSettings.cameraAutoExposure);
 
         if (cameraQuirks.hasQuirk(CameraQuirk.Gain)) {
             // If the gain is disabled for some reason, re-enable it
-            if (config.cameraGain == -1) config.cameraGain = 20;
-            visionSource.getSettables().setGain(Math.max(0, config.cameraGain));
+            if (pipelineSettings.cameraGain == -1) pipelineSettings.cameraGain = 20;
+            visionSource.getSettables().setGain(Math.max(0, pipelineSettings.cameraGain));
         } else {
-            config.cameraGain = -1;
-        }
-        if (cameraQuirks.hasQuirk(CameraQuirk.PiCam)) {
-            // If the AWB gains are disabled for some reason, re-enable it
-            if (config.cameraRedGain == -1) config.cameraRedGain = 16;
-            if (config.cameraBlueGain == -1) config.cameraBlueGain = 16;
-            visionSource.getSettables().setRedGain(Math.max(0, config.cameraRedGain));
-            visionSource.getSettables().setBlueGain(Math.max(0, config.cameraBlueGain));
-        } else {
-            config.cameraRedGain = -1;
-            config.cameraBlueGain = -1;
+            pipelineSettings.cameraGain = -1;
         }
 
-        setVisionLEDs(config.ledMode);
+        if (cameraQuirks.hasQuirk(CameraQuirk.AWBGain)) {
+            // If the AWB gains are disabled for some reason, re-enable it
+            if (pipelineSettings.cameraRedGain == -1) pipelineSettings.cameraRedGain = 16;
+            if (pipelineSettings.cameraBlueGain == -1) pipelineSettings.cameraBlueGain = 16;
+            visionSource.getSettables().setRedGain(Math.max(0, pipelineSettings.cameraRedGain));
+            visionSource.getSettables().setBlueGain(Math.max(0, pipelineSettings.cameraBlueGain));
+        } else {
+            pipelineSettings.cameraRedGain = -1;
+            pipelineSettings.cameraBlueGain = -1;
+        }
+
+        setVisionLEDs(pipelineSettings.ledMode);
 
         visionSource.getSettables().getConfiguration().currentPipelineIndex =
                 pipelineManager.getCurrentPipelineIndex();
@@ -460,14 +456,14 @@ public class VisionModule {
         outputFrameSaver.updateCameraNickname(newName);
 
         // Rename streams
-        fpsLimitedResultConsumers.clear();
+        streamResultConsumers.clear();
 
         // Teardown and recreate streams
         destroyStreams();
         createStreams();
 
         // Rebuild streamers
-        recreateFpsLimitedResultConsumers();
+        recreateStreamResultConsumers();
 
         // Push new data to the UI
         saveAndBroadcastAll();
@@ -477,7 +473,6 @@ public class VisionModule {
         var ret = new PhotonConfiguration.UICameraConfiguration();
 
         ret.fov = visionSource.getSettables().getFOV();
-        ret.tiltDegrees = this.visionSource.getSettables().getCameraPitch().getDegrees();
         ret.nickname = visionSource.getSettables().getConfiguration().nickname;
         ret.currentPipelineSettings =
                 SerializationUtils.objectToHashMap(pipelineManager.getCurrentPipelineSettings());
@@ -503,8 +498,8 @@ public class VisionModule {
             temp.put(k, internalMap);
         }
         ret.videoFormatList = temp;
-        ret.outputStreamPort = dashboardOutputStreamer.getCurrentStreamPort();
-        ret.inputStreamPort = dashboardInputStreamer.getCurrentStreamPort();
+        ret.outputStreamPort = this.outputStreamPort;
+        ret.inputStreamPort = this.inputStreamPort;
 
         var calList = new ArrayList<HashMap<String, Object>>();
         for (var c : visionSource.getSettables().getConfiguration().calibrations) {
@@ -554,7 +549,7 @@ public class VisionModule {
                     result.targets);
             // The streamRunnable manages releasing in this case
         } else {
-            consumeFpsLimitedResult(result);
+            consumeResults(result.inputFrame, result.outputFrame, result.targets);
 
             result.release();
             // In this case we don't bother with a separate streaming thread and we release
@@ -567,19 +562,9 @@ public class VisionModule {
         }
     }
 
-    private void consumeFpsLimitedResult(CVPipelineResult result) {
-        long dt = System.currentTimeMillis() - lastFrameConsumeMillis;
-        if (dt > 1000 / streamFPSCap) {
-            for (var c : fpsLimitedResultConsumers) {
-                c.accept(result);
-            }
-            lastFrameConsumeMillis = System.currentTimeMillis();
-        }
-    }
-
-    /** Consume results prior to drawing on them. */
-    private void consumeRawResults(Frame inputFrame, Frame outputFrame, List<TrackedTarget> targets) {
-        for (var c : rawResultConsumers) {
+    /** Consume stream/target results, no rate limiting applied */
+    private void consumeResults(Frame inputFrame, Frame outputFrame, List<TrackedTarget> targets) {
+        for (var c : streamResultConsumers) {
             c.accept(inputFrame, outputFrame, targets);
         }
     }

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

@@ -156,7 +156,7 @@ public class VisionModuleChangeSubscriber extends DataChangeSubscriber {
                         }
                         return;
                     case "changePipelineType":
-                        parentModule.pipelineManager.changePipelineType((Integer) newPropValue);
+                        parentModule.changePipelineType((Integer) newPropValue);
                         parentModule.saveAndBroadcastAll();
                         return;
                 }

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

@@ -31,6 +31,7 @@ import org.photonvision.common.logging.LogGroup;
 import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.TimedTaskManager;
 import org.photonvision.raspi.PicamJNI;
+import org.photonvision.vision.camera.CameraQuirk;
 import org.photonvision.vision.camera.CameraType;
 import org.photonvision.vision.camera.USBCameraSource;
 import org.photonvision.vision.camera.ZeroCopyPicamSource;
@@ -314,7 +315,13 @@ public class VisionSourceManager {
                 cameraSources.add(piCamSrc);
                 continue;
             }
-            cameraSources.add(new USBCameraSource(configuration));
+
+            var newCam = new USBCameraSource(configuration);
+
+            if (!newCam.cameraQuirks.hasQuirk(CameraQuirk.CompletelyBroken)
+                    && !newCam.getSettables().videoModes.isEmpty()) {
+                cameraSources.add(newCam);
+            }
         }
         return cameraSources;
     }

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

@@ -18,7 +18,6 @@
 package org.photonvision.vision.processes;
 
 import edu.wpi.first.cscore.VideoMode;
-import edu.wpi.first.math.geometry.Rotation2d;
 import java.util.HashMap;
 import org.photonvision.common.configuration.CameraConfiguration;
 import org.photonvision.common.logging.LogGroup;
@@ -45,6 +44,8 @@ public abstract class VisionSourceSettables {
 
     public abstract void setExposure(double exposure);
 
+    public abstract void setAutoExposure(boolean cameraAutoExposure);
+
     public abstract void setBrightness(int brightness);
 
     public abstract void setGain(int gain);
@@ -67,15 +68,6 @@ public abstract class VisionSourceSettables {
 
     protected abstract void setVideoModeInternal(VideoMode videoMode);
 
-    public void setCameraPitch(Rotation2d pitch) {
-        configuration.camPitch = pitch;
-        calculateFrameStaticProps();
-    }
-
-    public Rotation2d getCameraPitch() {
-        return configuration.camPitch;
-    }
-
     @SuppressWarnings("unused")
     public void setVideoModeIndex(int index) {
         setVideoMode(videoModes.get(index));
@@ -103,7 +95,6 @@ public abstract class VisionSourceSettables {
                 new FrameStaticProperties(
                         videoMode,
                         getFOV(),
-                        configuration.camPitch,
                         configuration.calibrations.stream()
                                 .filter(
                                         it ->

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

@@ -47,6 +47,7 @@ public enum TargetModel implements Releasable {
                             Units.inchesToMeters(2d * 12d + 5.25)),
                     new Point3(Units.inchesToMeters(19.625), 0, Units.inchesToMeters(2d * 12d + 5.25))),
             Units.inchesToMeters(12)),
+
     k2019DualTarget(
             List.of(
                     new Point3(Units.inchesToMeters(-5.936), Units.inchesToMeters(2.662), 0),
@@ -54,6 +55,7 @@ public enum TargetModel implements Releasable {
                     new Point3(Units.inchesToMeters(7.313), Units.inchesToMeters(-2.662), 0),
                     new Point3(Units.inchesToMeters(5.936), Units.inchesToMeters(2.662), 0)),
             0.1),
+
     kCircularPowerCell7in(
             List.of(
                     new Point3(
@@ -99,7 +101,14 @@ public enum TargetModel implements Releasable {
                     new Point3(Units.inchesToMeters(10), Units.inchesToMeters(0), 0),
                     new Point3(Units.inchesToMeters(10), Units.inchesToMeters(12), 0)),
             Units.inchesToMeters(6)),
-    ;
+    k200mmAprilTag( // Nominal edge length of 200 mm includes the white border, but solvePNP corners
+            // do not
+            List.of(
+                    new Point3(-Units.inchesToMeters(3.25), Units.inchesToMeters(3.25), 0),
+                    new Point3(Units.inchesToMeters(3.25), Units.inchesToMeters(3.25), 0),
+                    new Point3(Units.inchesToMeters(3.25), -Units.inchesToMeters(3.25), 0),
+                    new Point3(-Units.inchesToMeters(3.25), -Units.inchesToMeters(3.25), 0)),
+            Units.inchesToMeters(3.25 * 2));
 
     @JsonIgnore private MatOfPoint3f realWorldTargetCoordinates;
     @JsonIgnore private MatOfPoint3f visualizationBoxBottom = new MatOfPoint3f();

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

@@ -16,13 +16,17 @@
  */
 package org.photonvision.vision.target;
 
-import edu.wpi.first.math.geometry.Transform2d;
+import edu.wpi.first.math.geometry.Transform3d;
 import java.util.HashMap;
 import java.util.List;
+import org.opencv.core.CvType;
 import org.opencv.core.Mat;
+import org.opencv.core.MatOfPoint;
 import org.opencv.core.MatOfPoint2f;
 import org.opencv.core.Point;
 import org.opencv.core.RotatedRect;
+import org.photonvision.common.util.math.MathUtils;
+import org.photonvision.vision.apriltag.DetectionResult;
 import org.photonvision.vision.frame.FrameStaticProperties;
 import org.photonvision.vision.opencv.*;
 
@@ -42,10 +46,14 @@ public class TrackedTarget implements Releasable {
     private double m_area;
     private double m_skew;
 
-    private Transform2d m_cameraToTarget = new Transform2d();
+    private Transform3d m_bestCameraToTarget3d = new Transform3d();
+    private Transform3d m_altCameraToTarget3d = new Transform3d();
 
     private CVShape m_shape;
 
+    private int m_fiducialId = -1;
+    private double m_poseAmbiguity = -1;
+
     private Mat m_cameraRelativeTvec, m_cameraRelativeRvec;
 
     public TrackedTarget(
@@ -56,6 +64,86 @@ public class TrackedTarget implements Releasable {
         calculateValues(params);
     }
 
+    public TrackedTarget(DetectionResult result, TargetCalculationParameters params) {
+        m_targetOffsetPoint = new Point(result.getCenterX(), result.getCenterY());
+        m_robotOffsetPoint = new Point();
+
+        m_pitch =
+                TargetCalculations.calculatePitch(
+                        result.getCenterY(), params.cameraCenterPoint.y, params.verticalFocalLength);
+        m_yaw =
+                TargetCalculations.calculateYaw(
+                        result.getCenterX(), params.cameraCenterPoint.x, params.horizontalFocalLength);
+        var bestPose = new Transform3d();
+        var altPose = new Transform3d();
+        if (result.getError1() <= result.getError2()) {
+            bestPose = result.getPoseResult1();
+            altPose = result.getPoseResult2();
+        } else {
+            bestPose = result.getPoseResult2();
+            altPose = result.getPoseResult1();
+        }
+
+        bestPose = MathUtils.convertApriltagtoOpenCV(bestPose);
+        altPose = MathUtils.convertApriltagtoOpenCV(altPose);
+
+        m_bestCameraToTarget3d = bestPose;
+        m_altCameraToTarget3d = altPose;
+
+        double[] corners = result.getCorners();
+        Point[] cornerPoints =
+                new Point[] {
+                    new Point(corners[0], corners[1]),
+                    new Point(corners[2], corners[3]),
+                    new Point(corners[4], corners[5]),
+                    new Point(corners[6], corners[7])
+                };
+        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_fiducialId = result.getId();
+        m_shape = null;
+
+        // TODO implement skew? or just yeet
+        m_skew = 0;
+
+        var tvec = new Mat(3, 1, CvType.CV_64FC1);
+        tvec.put(
+                0,
+                0,
+                new double[] {
+                    bestPose.getTranslation().getX(),
+                    bestPose.getTranslation().getY(),
+                    bestPose.getTranslation().getZ()
+                });
+        setCameraRelativeTvec(tvec);
+
+        // Opencv expects a 3d vector with norm = angle and direction = axis
+        var rvec = new Mat(3, 1, CvType.CV_64FC1);
+        MathUtils.rotationToOpencvRvec(bestPose.getRotation(), rvec);
+        setCameraRelativeRvec(rvec);
+
+        m_poseAmbiguity = result.getPoseAmbiguity();
+    }
+
+    public void setFiducialId(int id) {
+        m_fiducialId = id;
+    }
+
+    public int getFiducialId() {
+        return m_fiducialId;
+    }
+
+    public void setPoseAmbiguity(double ambiguity) {
+        m_poseAmbiguity = ambiguity;
+    }
+
+    public double getPoseAmbiguity() {
+        return m_poseAmbiguity;
+    }
+
     /**
      * Set the approximate bouding polygon.
      *
@@ -125,8 +213,12 @@ public class TrackedTarget implements Releasable {
     @Override
     public void release() {
         m_mainContour.release();
-        for (var sc : m_subContours) {
-            sc.release();
+
+        // TODO how can this check fail?
+        if (m_subContours != null) {
+            for (var sc : m_subContours) {
+                sc.release();
+            }
         }
 
         if (m_cameraRelativeTvec != null) m_cameraRelativeTvec.release();
@@ -145,12 +237,20 @@ public class TrackedTarget implements Releasable {
         return !m_subContours.isEmpty();
     }
 
-    public Transform2d getCameraToTarget() {
-        return m_cameraToTarget;
+    public Transform3d getBestCameraToTarget3d() {
+        return m_bestCameraToTarget3d;
     }
 
-    public void setCameraToTarget(Transform2d pose) {
-        this.m_cameraToTarget = pose;
+    public Transform3d getAltCameraToTarget3d() {
+        return m_altCameraToTarget3d;
+    }
+
+    public void setBestCameraToTarget3d(Transform3d pose) {
+        this.m_bestCameraToTarget3d = pose;
+    }
+
+    public void setAltCameraToTarget3d(Transform3d pose) {
+        this.m_altCameraToTarget3d = pose;
     }
 
     public Mat getCameraRelativeTvec() {
@@ -185,20 +285,32 @@ public class TrackedTarget implements Releasable {
         ret.put("yaw", getYaw());
         ret.put("skew", getSkew());
         ret.put("area", getArea());
-        if (getCameraToTarget() != null) {
-            ret.put("pose", transformToMap(getCameraToTarget()));
+        ret.put("ambiguity", getPoseAmbiguity());
+        if (getBestCameraToTarget3d() != null) {
+            ret.put("pose", transformToMap(getBestCameraToTarget3d()));
         }
+        ret.put("fiducialId", getFiducialId());
         return ret;
     }
 
-    private static HashMap<String, Object> transformToMap(Transform2d transform) {
+    private static HashMap<String, Object> transformToMap(Transform3d transform) {
         var ret = new HashMap<String, Object>();
         ret.put("x", transform.getTranslation().getX());
         ret.put("y", transform.getTranslation().getY());
-        ret.put("rot", transform.getRotation().getDegrees());
+        ret.put("z", transform.getTranslation().getZ());
+        ret.put("qw", transform.getRotation().getQuaternion().getW());
+        ret.put("qx", transform.getRotation().getQuaternion().getX());
+        ret.put("qy", transform.getRotation().getQuaternion().getY());
+        ret.put("qz", transform.getRotation().getQuaternion().getZ());
+
+        ret.put("angle_z", transform.getRotation().getZ());
         return ret;
     }
 
+    public boolean isFiducial() {
+        return this.m_fiducialId >= 0;
+    }
+
     public static class TargetCalculationParameters {
         // TargetOffset calculation values
         final boolean isLandscape;

photon-core/src/main/java/org/photonvision/vision/videoStream/SocketVideoStream.java

@@ -0,0 +1,116 @@
+/*
+ * 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.videoStream;
+
+import java.nio.ByteBuffer;
+import java.util.Base64;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Consumer;
+import org.opencv.core.MatOfByte;
+import org.opencv.core.MatOfInt;
+import org.opencv.imgcodecs.Imgcodecs;
+import org.photonvision.vision.frame.Frame;
+import org.photonvision.vision.frame.consumer.MJPGFrameConsumer;
+
+public class SocketVideoStream implements Consumer<Frame> {
+    int portID = 0; // Align with cscore's port for unique identification of stream
+    MatOfByte jpegBytes = null;
+
+    // Gets set to true when another class reads out valid jpeg bytes at least once
+    // Set back to false when another frame is freshly converted
+    // Should eliminate synchronization issues of differeing rates of putting frames in
+    // and taking them back out
+    boolean frameWasConsumed = false;
+
+    // Synclock around manipulating the jpeg bytes from multiple threads
+    Lock jpegBytesLock = new ReentrantLock();
+
+    MJPGFrameConsumer oldSchoolServer;
+
+    private int userCount = 0;
+
+    public SocketVideoStream(int portID) {
+        this.portID = portID;
+        oldSchoolServer =
+                new MJPGFrameConsumer("Port_" + Integer.toString(portID) + "_MJPEG_Server", portID);
+    }
+
+    @Override
+    public void accept(Frame frame) {
+        if (userCount > 0) {
+            if (jpegBytesLock
+                    .tryLock()) { // we assume frames are coming in frequently. Just skip this frame if we're
+                // locked doing something else.
+                try {
+                    // Does a single-shot frame recieve and convert to JPEG for efficency
+                    // Will not capture/convert again until convertNextFrame() is called
+                    if (frame != null && !frame.image.getMat().empty() && jpegBytes == null) {
+                        frameWasConsumed = false;
+                        jpegBytes = new MatOfByte();
+                        Imgcodecs.imencode(
+                                ".jpg",
+                                frame.image.getMat(),
+                                jpegBytes,
+                                new MatOfInt(Imgcodecs.IMWRITE_JPEG_QUALITY, 75));
+                    }
+                } finally {
+                    jpegBytesLock.unlock();
+                }
+            }
+        }
+        oldSchoolServer.accept(frame);
+    }
+
+    public String getJPEGBase64EncodedStr() {
+        String sendStr = null;
+        jpegBytesLock.lock();
+        if (jpegBytes != null) {
+            sendStr = Base64.getEncoder().encodeToString(jpegBytes.toArray());
+        }
+        jpegBytesLock.unlock();
+        return sendStr;
+    }
+
+    public ByteBuffer getJPEGByteBuffer() {
+        ByteBuffer sendStr = null;
+        jpegBytesLock.lock();
+        if (jpegBytes != null) {
+            sendStr = ByteBuffer.wrap(jpegBytes.toArray());
+        }
+        jpegBytesLock.unlock();
+        return sendStr;
+    }
+
+    public void convertNextFrame() {
+        jpegBytesLock.lock();
+        if (jpegBytes != null) {
+            jpegBytes.release();
+            jpegBytes = null;
+        }
+        jpegBytesLock.unlock();
+    }
+
+    public void addUser() {
+        userCount++;
+    }
+
+    public void removeUser() {
+        userCount--;
+    }
+}

photon-core/src/main/java/org/photonvision/vision/videoStream/SocketVideoStreamManager.java

@@ -0,0 +1,97 @@
+/*
+ * 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.videoStream;
+
+import io.javalin.websocket.WsContext;
+import java.nio.ByteBuffer;
+import java.util.Hashtable;
+import java.util.Map;
+import org.photonvision.common.logging.LogGroup;
+import org.photonvision.common.logging.Logger;
+
+public class SocketVideoStreamManager {
+    private static final int NO_STREAM_PORT = -1;
+
+    private final Logger logger = new Logger(SocketVideoStreamManager.class, LogGroup.Camera);
+
+    private Map<Integer, SocketVideoStream> streams = new Hashtable<Integer, SocketVideoStream>();
+    private Map<WsContext, Integer> userSubscriptions = new Hashtable<WsContext, Integer>();
+
+    private static class ThreadSafeSingleton {
+        private static final SocketVideoStreamManager INSTANCE = new SocketVideoStreamManager();
+    }
+
+    public static SocketVideoStreamManager getInstance() {
+        return ThreadSafeSingleton.INSTANCE;
+    }
+
+    private SocketVideoStreamManager() {}
+
+    // Register a new available camera stream
+    public void addStream(SocketVideoStream newStream) {
+        streams.put(newStream.portID, newStream);
+        logger.debug("Added new stream for port " + Integer.toString(newStream.portID));
+    }
+
+    // Remove a previously-added camera stream, and unsubscribe all users
+    public void removeStream(SocketVideoStream oldStream) {
+        streams.remove(oldStream.portID);
+        logger.debug("Removed stream for port " + Integer.toString(oldStream.portID));
+    }
+
+    // Indicate a user would like to subscribe to a camera stream and get frames from it periodically
+    public void addSubscription(WsContext user, int streamPortID) {
+        var stream = streams.get(streamPortID);
+        if (stream != null) {
+            userSubscriptions.put(user, streamPortID);
+            stream.addUser();
+        } else {
+            logger.error(
+                    "User attempted to subscribe to non-existent port " + Integer.toString(streamPortID));
+        }
+    }
+
+    // Indicate a user would like to stop receiving one camera stream
+    public void removeSubscription(WsContext user) {
+        var port = userSubscriptions.get(user);
+        if (port != null) {
+            var stream = streams.get(port);
+            userSubscriptions.put(user, NO_STREAM_PORT);
+            stream.removeUser();
+        }
+    }
+
+    // For a given user, return the jpeg bytes (or null) for the most recent frame
+    public ByteBuffer getSendFrame(WsContext user) {
+        var port = userSubscriptions.get(user);
+        if (port != null && port != NO_STREAM_PORT) {
+            var stream = streams.get(port);
+            return stream.getJPEGByteBuffer();
+        } else {
+            return null;
+        }
+    }
+
+    // Causes all streams to "re-trigger" and recieve and convert their next mjpeg frame
+    // Only invoke this after all returned jpeg Strings have been used.
+    public void allStreamConvertNextFrame() {
+        for (SocketVideoStream stream : streams.values()) {
+            stream.convertNextFrame();
+        }
+    }
+}

photon-core/src/test/java/org/photonvision/common/configuration/ConfigTest.java

@@ -30,6 +30,7 @@ import org.photonvision.common.logging.LogLevel;
 import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.TestUtils;
 import org.photonvision.common.util.file.JacksonUtils;
+import org.photonvision.vision.pipeline.AprilTagPipelineSettings;
 import org.photonvision.vision.pipeline.ColoredShapePipelineSettings;
 import org.photonvision.vision.pipeline.ReflectivePipelineSettings;
 import org.photonvision.vision.target.TargetModel;
@@ -40,6 +41,7 @@ public class ConfigTest {
             new CameraConfiguration("TestCamera", "/dev/video420");
     private static ReflectivePipelineSettings REFLECTIVE_PIPELINE_SETTINGS;
     private static ColoredShapePipelineSettings COLORED_SHAPE_PIPELINE_SETTINGS;
+    private static AprilTagPipelineSettings APRIL_TAG_PIPELINE_SETTINGS;
 
     @BeforeAll
     public static void init() {
@@ -51,6 +53,7 @@ public class ConfigTest {
 
         REFLECTIVE_PIPELINE_SETTINGS = new ReflectivePipelineSettings();
         COLORED_SHAPE_PIPELINE_SETTINGS = new ColoredShapePipelineSettings();
+        APRIL_TAG_PIPELINE_SETTINGS = new AprilTagPipelineSettings();
 
         REFLECTIVE_PIPELINE_SETTINGS.pipelineNickname = "2019Tape";
         REFLECTIVE_PIPELINE_SETTINGS.targetModel = TargetModel.k2019DualTarget;
@@ -58,8 +61,12 @@ public class ConfigTest {
         COLORED_SHAPE_PIPELINE_SETTINGS.pipelineNickname = "2019Cargo";
         COLORED_SHAPE_PIPELINE_SETTINGS.pipelineIndex = 1;
 
+        APRIL_TAG_PIPELINE_SETTINGS.pipelineNickname = "apriltag";
+        APRIL_TAG_PIPELINE_SETTINGS.pipelineIndex = 2;
+
         cameraConfig.addPipelineSetting(REFLECTIVE_PIPELINE_SETTINGS);
         cameraConfig.addPipelineSetting(COLORED_SHAPE_PIPELINE_SETTINGS);
+        cameraConfig.addPipelineSetting(APRIL_TAG_PIPELINE_SETTINGS);
     }
 
     @Test
@@ -90,9 +97,12 @@ public class ConfigTest {
                 configMgr.getConfig().getCameraConfigurations().get("TestCamera").pipelineSettings.get(0);
         var coloredShapePipelineSettings =
                 configMgr.getConfig().getCameraConfigurations().get("TestCamera").pipelineSettings.get(1);
+        var apriltagPipelineSettings =
+                configMgr.getConfig().getCameraConfigurations().get("TestCamera").pipelineSettings.get(2);
 
         Assertions.assertEquals(REFLECTIVE_PIPELINE_SETTINGS, reflectivePipelineSettings);
         Assertions.assertEquals(COLORED_SHAPE_PIPELINE_SETTINGS, coloredShapePipelineSettings);
+        Assertions.assertEquals(APRIL_TAG_PIPELINE_SETTINGS, apriltagPipelineSettings);
 
         Assertions.assertTrue(
                 reflectivePipelineSettings instanceof ReflectivePipelineSettings,
@@ -100,6 +110,9 @@ public class ConfigTest {
         Assertions.assertTrue(
                 coloredShapePipelineSettings instanceof ColoredShapePipelineSettings,
                 "Conig loaded pipeline settings for index 1 not of expected type ColoredShapePipelineSettings!");
+        Assertions.assertTrue(
+                apriltagPipelineSettings instanceof AprilTagPipelineSettings,
+                "Conig loaded pipeline settings for index 2 not of expected type AprilTagPipelineSettings!");
     }
 
     @AfterAll

photon-core/src/test/java/org/photonvision/vision/pipeline/Calibrate3dPipeTest.java

@@ -19,7 +19,6 @@ package org.photonvision.vision.pipeline;
 
 import static org.junit.jupiter.api.Assertions.*;
 
-import edu.wpi.first.math.geometry.Rotation2d;
 import edu.wpi.first.math.util.Units;
 import java.io.File;
 import java.nio.file.Path;
@@ -104,7 +103,7 @@ public class Calibrate3dPipeTest {
             var frame =
                     new Frame(
                             new CVMat(Imgcodecs.imread(file.getAbsolutePath())),
-                            new FrameStaticProperties(640, 480, 60, new Rotation2d(), null));
+                            new FrameStaticProperties(640, 480, 60, null));
             var output = calibration3dPipeline.run(frame, QuirkyCamera.DefaultCamera);
             // TestUtils.showImage(output.outputFrame.image.getMat());
             output.release();
@@ -120,7 +119,7 @@ public class Calibrate3dPipeTest {
         var frame =
                 new Frame(
                         new CVMat(Imgcodecs.imread(directoryListing[0].getAbsolutePath())),
-                        new FrameStaticProperties(640, 480, 60, new Rotation2d(), null));
+                        new FrameStaticProperties(640, 480, 60, null));
         calibration3dPipeline.run(frame, QuirkyCamera.DefaultCamera).release();
         frame.release();
 
@@ -267,8 +266,7 @@ public class Calibrate3dPipeTest {
                 var frame =
                         new Frame(
                                 new CVMat(Imgcodecs.imread(file.getAbsolutePath())),
-                                new FrameStaticProperties(
-                                        (int) imgRes.width, (int) imgRes.height, 67, new Rotation2d(), null));
+                                new FrameStaticProperties((int) imgRes.width, (int) imgRes.height, 67, null));
                 var output = calibration3dPipeline.run(frame, QuirkyCamera.DefaultCamera);
 
                 // TestUtils.showImage(output.outputFrame.image.getMat(), file.getName(), 1);

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

@@ -19,7 +19,6 @@ package org.photonvision.vision.pipeline;
 
 import static org.junit.jupiter.api.Assertions.*;
 
-import edu.wpi.first.math.geometry.Rotation2d;
 import java.util.stream.Collectors;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -111,7 +110,6 @@ public class CirclePNPTest {
                 new FileFrameProvider(
                         TestUtils.getPowercellImagePath(TestUtils.PowercellTestImages.kPowercell_test_6, false),
                         TestUtils.WPI2020Image.FOV,
-                        new Rotation2d(),
                         TestUtils.get2020LifeCamCoeffs(true));
 
         CVPipelineResult pipelineResult = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
@@ -163,7 +161,7 @@ public class CirclePNPTest {
         System.out.println(
                 "Found targets at "
                         + pipelineResult.targets.stream()
-                                .map(TrackedTarget::getCameraToTarget)
+                                .map(TrackedTarget::getBestCameraToTarget3d)
                                 .collect(Collectors.toList()));
     }
 }

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

@@ -20,13 +20,12 @@ package org.photonvision.vision.pipeline;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
-import edu.wpi.first.math.geometry.Rotation2d;
+import edu.wpi.first.math.geometry.Translation3d;
 import edu.wpi.first.math.util.Units;
 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.opencv.imgcodecs.Imgcodecs;
 import org.photonvision.common.util.TestUtils;
 import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
 import org.photonvision.vision.camera.QuirkyCamera;
@@ -104,7 +103,6 @@ public class SolvePNPTest {
                 new FileFrameProvider(
                         TestUtils.getWPIImagePath(TestUtils.WPI2019Image.kCargoStraightDark48in, false),
                         TestUtils.WPI2019Image.FOV,
-                        new Rotation2d(),
                         TestUtils.get2019LifeCamCoeffs(false));
 
         CVPipelineResult pipelineResult;
@@ -113,12 +111,20 @@ public class SolvePNPTest {
         printTestResults(pipelineResult);
 
         // these numbers are not *accurate*, but they are known and expected
-        var pose = pipelineResult.targets.get(0).getCameraToTarget();
+        var pose = pipelineResult.targets.get(0).getBestCameraToTarget3d();
         Assertions.assertEquals(1.1, pose.getTranslation().getX(), 0.05);
         Assertions.assertEquals(0.0, pose.getTranslation().getY(), 0.05);
-        Assertions.assertEquals(1, pose.getRotation().getDegrees(), 1);
 
-        Imgcodecs.imwrite("D:\\out.jpg", pipelineResult.outputFrame.image.getMat());
+        // We expect the object X to be forward, or -X in world space
+        Assertions.assertEquals(
+                -1, new Translation3d(1, 0, 0).rotateBy(pose.getRotation()).getX(), 0.05);
+        // We expect the object Y axis to be right, or negative-Y in world space
+        Assertions.assertEquals(
+                -1, new Translation3d(0, 1, 0).rotateBy(pose.getRotation()).getY(), 0.05);
+        // We expect the object Z axis to be up, or +Z in world space
+        Assertions.assertEquals(
+                1, new Translation3d(0, 0, 1).rotateBy(pose.getRotation()).getZ(), 0.05);
+
         TestUtils.showImage(pipelineResult.outputFrame.image.getMat(), "Pipeline output", 999999);
     }
 
@@ -139,19 +145,27 @@ public class SolvePNPTest {
                 new FileFrameProvider(
                         TestUtils.getWPIImagePath(TestUtils.WPI2020Image.kBlueGoal_224in_Left, false),
                         TestUtils.WPI2020Image.FOV,
-                        new Rotation2d(),
                         TestUtils.get2020LifeCamCoeffs(false));
 
         CVPipelineResult pipelineResult = pipeline.run(frameProvider.get(), QuirkyCamera.DefaultCamera);
         printTestResults(pipelineResult);
 
+        // Draw on input
+        var outputPipe = new OutputStreamPipeline();
+        outputPipe.process(
+                pipelineResult.inputFrame,
+                pipelineResult.outputFrame,
+                pipeline.getSettings(),
+                pipelineResult.targets);
+
         // these numbers are not *accurate*, but they are known and expected
-        var pose = pipelineResult.targets.get(0).getCameraToTarget();
+        var pose = pipelineResult.targets.get(0).getBestCameraToTarget3d();
         Assertions.assertEquals(Units.inchesToMeters(240.26), pose.getTranslation().getX(), 0.05);
         Assertions.assertEquals(Units.inchesToMeters(35), pose.getTranslation().getY(), 0.05);
-        Assertions.assertEquals(42, pose.getRotation().getDegrees(), 1);
+        // Z rotation should be mostly facing us
+        Assertions.assertEquals(Units.degreesToRadians(-140), pose.getRotation().getZ(), 1);
 
-        TestUtils.showImage(pipelineResult.outputFrame.image.getMat(), "Pipeline output", 999999);
+        TestUtils.showImage(pipelineResult.inputFrame.image.getMat(), "Pipeline output", 999999);
     }
 
     private static void continuouslyRunPipeline(Frame frame, ReflectivePipelineSettings settings) {
@@ -197,7 +211,7 @@ public class SolvePNPTest {
         System.out.println(
                 "Found targets at "
                         + pipelineResult.targets.stream()
-                                .map(TrackedTarget::getCameraToTarget)
+                                .map(TrackedTarget::getBestCameraToTarget3d)
                                 .collect(Collectors.toList()));
     }
 }

photon-core/src/test/java/org/photonvision/vision/processes/VisionModuleManagerTest.java

@@ -20,7 +20,6 @@ package org.photonvision.vision.processes;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import edu.wpi.first.cscore.VideoMode;
-import edu.wpi.first.math.geometry.Rotation2d;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -86,8 +85,7 @@ public class VisionModuleManagerTest {
 
         @Override
         public void setVideoModeInternal(VideoMode videoMode) {
-            this.frameStaticProperties =
-                    new FrameStaticProperties(getCurrentVideoMode(), getFOV(), new Rotation2d(), null);
+            this.frameStaticProperties = new FrameStaticProperties(getCurrentVideoMode(), getFOV(), null);
         }
 
         @Override
@@ -96,6 +94,9 @@ public class VisionModuleManagerTest {
             ret.put(0, getCurrentVideoMode());
             return ret;
         }
+
+        @Override
+        public void setAutoExposure(boolean cameraAutoExposure) {}
     }
 
     private static class TestDataConsumer implements CVPipelineResultConsumer {

photon-core/src/test/java/org/photonvision/vision/target/TargetCalculationsTest.java

@@ -18,7 +18,6 @@ package org.photonvision.vision.target;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import edu.wpi.first.math.geometry.Rotation2d;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -37,8 +36,7 @@ public class TargetCalculationsTest {
     private static final double diagFOV = Math.toRadians(70.0);
 
     private static final FrameStaticProperties props =
-            new FrameStaticProperties(
-                    (int) imageSize.width, (int) imageSize.height, diagFOV, new Rotation2d(), null);
+            new FrameStaticProperties((int) imageSize.width, (int) imageSize.height, diagFOV, null);
     private static final TrackedTarget.TargetCalculationParameters params =
             new TrackedTarget.TargetCalculationParameters(
                     true,

photon-lib/build.gradle

@@ -24,6 +24,8 @@ dependencies {
     implementation "edu.wpi.first.wpimath:wpimath-java:$wpilibVersion"
     implementation "edu.wpi.first.thirdparty.frc2022.opencv:opencv-java:$opencvVersion"
 
+    implementation "org.ejml:ejml-simple:0.41"
+
     // NTCore
     implementation "edu.wpi.first.ntcore:ntcore-java:$wpilibVersion"
     jniPlatforms.each { implementation "edu.wpi.first.ntcore:ntcore-jni:$wpilibVersion:$it" }

photon-lib/src/main/java/org/photonvision/PhotonCamera.java

@@ -28,6 +28,7 @@ import edu.wpi.first.networktables.NetworkTable;
 import edu.wpi.first.networktables.NetworkTableEntry;
 import edu.wpi.first.networktables.NetworkTableInstance;
 import edu.wpi.first.wpilibj.DriverStation;
+import edu.wpi.first.wpilibj.Timer;
 import org.photonvision.common.dataflow.structures.Packet;
 import org.photonvision.common.hardware.VisionLEDMode;
 import org.photonvision.targeting.PhotonPipelineResult;
@@ -46,6 +47,8 @@ public class PhotonCamera {
     private final String path;
 
     private static boolean VERSION_CHECK_ENABLED = true;
+    private static long VERSION_CHECK_INTERVAL = 1;
+    private double lastVersionCheckTime = 0;
 
     public static void setVersionCheckEnabled(boolean enabled) {
         VERSION_CHECK_ENABLED = enabled;
@@ -207,6 +210,9 @@ public class PhotonCamera {
     private void verifyVersion() {
         if (!VERSION_CHECK_ENABLED) return;
 
+        if ((Timer.getFPGATimestamp() - lastVersionCheckTime) < VERSION_CHECK_INTERVAL) return;
+        lastVersionCheckTime = Timer.getFPGATimestamp();
+
         String versionString = versionEntry.getString("");
         if (versionString.equals("")) {
             DriverStation.reportError(

photon-lib/src/main/java/org/photonvision/SimPhotonCamera.java

@@ -144,9 +144,9 @@ public class SimPhotonCamera extends PhotonCamera {
             targetAreaEntry.setDouble(bestTarget.getArea());
             targetSkewEntry.setDouble(bestTarget.getSkew());
 
-            var transform = bestTarget.getCameraToTarget();
+            var transform = bestTarget.getBestCameraToTarget();
             double[] poseData = {
-                transform.getX(), transform.getY(), transform.getRotation().getDegrees()
+                transform.getX(), transform.getY(), transform.getRotation().toRotation2d().getDegrees()
             };
             targetPoseEntry.setDoubleArray(poseData);
         }

photon-lib/src/main/java/org/photonvision/SimVisionSystem.java

@@ -26,6 +26,7 @@ package org.photonvision;
 
 import edu.wpi.first.math.geometry.Pose2d;
 import edu.wpi.first.math.geometry.Transform2d;
+import edu.wpi.first.math.geometry.Transform3d;
 import edu.wpi.first.math.util.Units;
 import java.util.ArrayList;
 import java.util.List;
@@ -168,7 +169,10 @@ public class SimVisionSystem {
                                         pitchDegrees,
                                         area,
                                         0.0,
-                                        camToTargetTrans,
+                                        -1, // TODO fiducial ID
+                                        new Transform3d(),
+                                        new Transform3d(),
+                                        0.25,
                                         List.of(
                                                 new TargetCorner(0, 0), new TargetCorner(0, 0),
                                                 new TargetCorner(0, 0), new TargetCorner(0, 0))));

photon-lib/src/main/native/cpp/geometry/Pose3d.cpp

@@ -0,0 +1,159 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022 PhotonVision
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <cmath>
+
+#include <frc/geometry/Pose3d.h>
+
+using namespace frc;
+
+namespace {
+
+/**
+ * Applies the hat operator to a rotation vector.
+ *
+ * It takes a rotation vector and returns the corresponding matrix
+ * representation of the Lie algebra element (a 3x3 rotation matrix).
+ *
+ * @param rotation The rotation vector.
+ * @return The rotation vector as a 3x3 rotation matrix.
+ */
+Matrixd<3, 3> RotationVectorToMatrix(const Vectord<3>& rotation) {
+  // Given a rotation vector <a, b, c>,
+  //         [ 0 -c  b]
+  // Omega = [ c  0 -a]
+  //         [-b  a  0]
+  return Matrixd<3, 3>{{0.0, -rotation(2), rotation(1)},
+                       {rotation(2), 0.0, -rotation(0)},
+                       {-rotation(1), rotation(0), 0.0}};
+}
+}  // namespace
+
+Pose3d::Pose3d(Translation3d translation, Rotation3d rotation)
+    : m_translation(std::move(translation)), m_rotation(std::move(rotation)) {}
+
+Pose3d::Pose3d(units::meter_t x, units::meter_t y, units::meter_t z,
+               Rotation3d rotation)
+    : m_translation(x, y, z), m_rotation(std::move(rotation)) {}
+
+Pose3d Pose3d::operator+(const Transform3d& other) const {
+  return TransformBy(other);
+}
+
+Transform3d Pose3d::operator-(const Pose3d& other) const {
+  const auto pose = this->RelativeTo(other);
+  return Transform3d{pose.Translation(), pose.Rotation()};
+}
+
+bool Pose3d::operator==(const Pose3d& other) const {
+  return m_translation == other.m_translation && m_rotation == other.m_rotation;
+}
+
+bool Pose3d::operator!=(const Pose3d& other) const {
+  return !operator==(other);
+}
+
+Pose3d Pose3d::TransformBy(const Transform3d& other) const {
+  return {m_translation + (other.Translation().RotateBy(m_rotation)),
+          m_rotation + other.Rotation()};
+}
+
+Pose3d Pose3d::RelativeTo(const Pose3d& other) const {
+  const Transform3d transform{other, *this};
+  return {transform.Translation(), transform.Rotation()};
+}
+
+Pose3d Pose3d::Exp(const Twist3d& twist) const {
+  Matrixd<3, 3> Omega = RotationVectorToMatrix(
+      Vectord<3>{twist.rx.value(), twist.ry.value(), twist.rz.value()});
+  Matrixd<3, 3> OmegaSq = Omega * Omega;
+
+  double thetaSq =
+      (twist.rx * twist.rx + twist.ry * twist.ry + twist.rz * twist.rz).value();
+
+  // Get left Jacobian of SO3. See first line in right column of
+  // http://asrl.utias.utoronto.ca/~tdb/bib/barfoot_ser17_identities.pdf
+  Matrixd<3, 3> J;
+  if (thetaSq < 1E-9 * 1E-9) {
+    // V = I + 0.5ω
+    J = Matrixd<3, 3>::Identity() + 0.5 * Omega;
+  } else {
+    double theta = std::sqrt(thetaSq);
+    // J = I + (1 − std::cos(θ))/θ² ω + (θ − std::sin(θ))/θ³ ω²
+    J = Matrixd<3, 3>::Identity() + (1.0 - std::cos(theta)) / thetaSq * Omega +
+        (theta - std::sin(theta)) / (thetaSq * theta) * OmegaSq;
+  }
+
+  // Get translation component
+  Vectord<3> translation =
+      J * Vectord<3>{twist.dx.value(), twist.dy.value(), twist.dz.value()};
+
+  const Transform3d transform{Translation3d{units::meter_t{translation(0)},
+                                            units::meter_t{translation(1)},
+                                            units::meter_t{translation(2)}},
+                              Rotation3d{twist.rx, twist.ry, twist.rz}};
+
+  return *this + transform;
+}
+
+Twist3d Pose3d::Log(const Pose3d& end) const {
+  const auto transform = end.RelativeTo(*this);
+
+  Vectord<3> rotVec = transform.Rotation().GetQuaternion().ToRotationVector();
+
+  Matrixd<3, 3> Omega = RotationVectorToMatrix(rotVec);
+  Matrixd<3, 3> OmegaSq = Omega * Omega;
+
+  double thetaSq = rotVec.squaredNorm();
+
+  // Get left Jacobian inverse of SO3. See fourth line in right column of
+  // http://asrl.utias.utoronto.ca/~tdb/bib/barfoot_ser17_identities.pdf
+  Matrixd<3, 3> Jinv;
+  if (thetaSq < 1E-9 * 1E-9) {
+    // J⁻¹ = I − 0.5ω + 1/12 ω²
+    Jinv = Matrixd<3, 3>::Identity() - 0.5 * Omega + 1.0 / 12.0 * OmegaSq;
+  } else {
+    double theta = std::sqrt(thetaSq);
+    double halfTheta = 0.5 * theta;
+
+    // J⁻¹ = I − 0.5ω + (1 − 0.5θ std::cos(θ/2) / std::sin(θ/2))/θ² ω²
+    Jinv = Matrixd<3, 3>::Identity() - 0.5 * Omega +
+           (1.0 - 0.5 * theta * std::cos(halfTheta) / std::sin(halfTheta)) /
+               thetaSq * OmegaSq;
+  }
+
+  // Get dtranslation component
+  Vectord<3> dtranslation =
+      Jinv * Vectord<3>{transform.X().value(), transform.Y().value(),
+                        transform.Z().value()};
+
+  return Twist3d{
+      units::meter_t{dtranslation(0)}, units::meter_t{dtranslation(1)},
+      units::meter_t{dtranslation(2)}, units::radian_t{rotVec(0)},
+      units::radian_t{rotVec(1)},      units::radian_t{rotVec(2)}};
+}
+
+Pose2d Pose3d::ToPose2d() const {
+  return Pose2d{m_translation.X(), m_translation.Y(), m_rotation.Z()};
+}

photon-lib/src/main/native/cpp/geometry/Quaternion.cpp

@@ -0,0 +1,95 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022 PhotonVision
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <frc/geometry/Quaternion.h>
+
+using namespace frc;
+
+Quaternion::Quaternion(double w, double x, double y, double z)
+    : m_r{w}, m_v{x, y, z} {}
+
+Quaternion Quaternion::operator*(const Quaternion& other) const {
+  // https://en.wikipedia.org/wiki/Quaternion#Scalar_and_vector_parts
+  const auto& r1 = m_r;
+  const auto& v1 = m_v;
+  const auto& r2 = other.m_r;
+  const auto& v2 = other.m_v;
+
+  // v₁ x v₂
+  Eigen::Vector3d cross{v1(1) * v2(2) - v2(1) * v1(2),
+                        v2(0) * v1(2) - v1(0) * v2(2),
+                        v1(0) * v2(1) - v2(0) * v1(1)};
+
+  // v = r₁v₂ + r₂v₁ + v₁ x v₂
+  Eigen::Vector3d v = r1 * v2 + r2 * v1 + cross;
+
+  return Quaternion{r1 * r2 - v1.dot(v2), v(0), v(1), v(2)};
+}
+
+bool Quaternion::operator==(const Quaternion& other) const {
+  return std::abs(m_r * other.m_r + m_v.dot(other.m_v)) > 1.0 - 1E-9;
+}
+
+bool Quaternion::operator!=(const Quaternion& other) const {
+  return !operator==(other);
+}
+
+Quaternion Quaternion::Inverse() const {
+  return Quaternion{m_r, -m_v(0), -m_v(1), -m_v(2)};
+}
+
+Quaternion Quaternion::Normalize() const {
+  double norm = std::sqrt(W() * W() + X() * X() + Y() * Y() + Z() * Z());
+  if (norm == 0.0) {
+    return Quaternion{};
+  } else {
+    return Quaternion{W() / norm, X() / norm, Y() / norm, Z() / norm};
+  }
+}
+
+double Quaternion::W() const { return m_r; }
+
+double Quaternion::X() const { return m_v(0); }
+
+double Quaternion::Y() const { return m_v(1); }
+
+double Quaternion::Z() const { return m_v(2); }
+
+Eigen::Vector3d Quaternion::ToRotationVector() const {
+  // See equation (31) in "Integrating Generic Sensor Fusion Algorithms with
+  // Sound State Representation through Encapsulation of Manifolds"
+  //
+  // https://arxiv.org/pdf/1107.1119.pdf
+  double norm = m_v.norm();
+
+  if (norm < 1e-9) {
+    return (2.0 / W() - 2.0 / 3.0 * norm * norm / (W() * W() * W())) * m_v;
+  } else {
+    if (W() < 0.0) {
+      return 2.0 * std::atan2(-norm, -W()) / norm * m_v;
+    } else {
+      return 2.0 * std::atan2(norm, W()) / norm * m_v;
+    }
+  }
+}

photon-lib/src/main/native/cpp/geometry/Rotation3d.cpp

@@ -0,0 +1,248 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022 PhotonVision
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <cmath>
+
+#include <Eigen/Core>
+#include <Eigen/LU>
+#include <Eigen/QR>
+#include <frc/fmt/Eigen.h>
+#include <frc/geometry/Rotation3d.h>
+#include <units/math.h>
+#include <wpi/numbers>
+
+#include "wpimath/MathShared.h"
+
+using namespace frc;
+
+Rotation3d::Rotation3d(const Quaternion& q) { m_q = q.Normalize(); }
+
+Rotation3d::Rotation3d(units::radian_t roll, units::radian_t pitch,
+                       units::radian_t yaw) {
+  // https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles#Euler_angles_to_quaternion_conversion
+  double cr = units::math::cos(roll * 0.5);
+  double sr = units::math::sin(roll * 0.5);
+
+  double cp = units::math::cos(pitch * 0.5);
+  double sp = units::math::sin(pitch * 0.5);
+
+  double cy = units::math::cos(yaw * 0.5);
+  double sy = units::math::sin(yaw * 0.5);
+
+  m_q = Quaternion{cr * cp * cy + sr * sp * sy, sr * cp * cy - cr * sp * sy,
+                   cr * sp * cy + sr * cp * sy, cr * cp * sy - sr * sp * cy};
+}
+
+Rotation3d::Rotation3d(const Vectord<3>& axis, units::radian_t angle) {
+  double norm = axis.norm();
+  if (norm == 0.0) {
+    return;
+  }
+
+  // https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles#Definition
+  Vectord<3> v = axis / norm * units::math::sin(angle / 2.0);
+  m_q = Quaternion{units::math::cos(angle / 2.0), v(0), v(1), v(2)};
+}
+
+Rotation3d::Rotation3d(const Matrixd<3, 3>& rotationMatrix) {
+  const auto& R = rotationMatrix;
+
+  // Require that the rotation matrix is special orthogonal. This is true if the
+  // matrix is orthogonal (RRᵀ = I) and normalized (determinant is 1).
+  if (R * R.transpose() != Matrixd<3, 3>::Identity()) {
+    std::string msg =
+        fmt::format("Rotation matrix isn't orthogonal\n\nR =\n{}\n", R);
+
+    wpi::math::MathSharedStore::ReportError(msg);
+    throw std::domain_error(msg);
+  }
+  if (R.determinant() != 1.0) {
+    std::string msg = fmt::format(
+        "Rotation matrix is orthogonal but not special orthogonal\n\nR =\n{}\n",
+        R);
+
+    wpi::math::MathSharedStore::ReportError(msg);
+    throw std::domain_error(msg);
+  }
+
+  // Turn rotation matrix into a quaternion
+  // https://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/
+  double trace = R(0, 0) + R(1, 1) + R(2, 2);
+  double w;
+  double x;
+  double y;
+  double z;
+
+  if (trace > 0.0) {
+    double s = 0.5 / std::sqrt(trace + 1.0);
+    w = 0.25 / s;
+    x = (R(2, 1) - R(1, 2)) * s;
+    y = (R(0, 2) - R(2, 0)) * s;
+    z = (R(1, 0) - R(0, 1)) * s;
+  } else {
+    if (R(0, 0) > R(1, 1) && R(0, 0) > R(2, 2)) {
+      double s = 2.0 * std::sqrt(1.0 + R(0, 0) - R(1, 1) - R(2, 2));
+      w = (R(2, 1) - R(1, 2)) / s;
+      x = 0.25 * s;
+      y = (R(0, 1) + R(1, 0)) / s;
+      z = (R(0, 2) + R(2, 0)) / s;
+    } else if (R(1, 1) > R(2, 2)) {
+      double s = 2.0 * std::sqrt(1.0 + R(1, 1) - R(0, 0) - R(2, 2));
+      w = (R(0, 2) - R(2, 0)) / s;
+      x = (R(0, 1) + R(1, 0)) / s;
+      y = 0.25 * s;
+      z = (R(1, 2) + R(2, 1)) / s;
+    } else {
+      double s = 2.0 * std::sqrt(1.0 + R(2, 2) - R(0, 0) - R(1, 1));
+      w = (R(1, 0) - R(0, 1)) / s;
+      x = (R(0, 2) + R(2, 0)) / s;
+      y = (R(1, 2) + R(2, 1)) / s;
+      z = 0.25 * s;
+    }
+  }
+
+  m_q = Quaternion{w, x, y, z};
+}
+
+Rotation3d::Rotation3d(const Vectord<3>& initial, const Vectord<3>& final) {
+  double dot = initial.dot(final);
+  double normProduct = initial.norm() * final.norm();
+  double dotNorm = dot / normProduct;
+
+  if (dotNorm > 1.0 - 1E-9) {
+    // If the dot product is 1, the two vectors point in the same direction so
+    // there's no rotation. The default initialization of m_q will work.
+    return;
+  } else if (dotNorm < -1.0 + 1E-9) {
+    // If the dot product is -1, the two vectors point in opposite directions so
+    // a 180 degree rotation is required. Any orthogonal vector can be used for
+    // it. Q in the QR decomposition is an orthonormal basis, so it contains
+    // orthogonal unit vectors.
+    Eigen::Matrix<double, 3, 1> X = initial;
+    Eigen::HouseholderQR<decltype(X)> qr{X};
+    Eigen::Matrix<double, 3, 3> Q = qr.householderQ();
+
+    // w = std::cos(θ/2) = std::cos(90°) = 0
+    //
+    // For x, y, and z, we use the second column of Q because the first is
+    // parallel instead of orthogonal. The third column would also work.
+    m_q = Quaternion{0.0, Q(0, 1), Q(1, 1), Q(2, 1)};
+  } else {
+    // initial x final
+    Eigen::Vector3d axis{initial(1) * final(2) - final(1) * initial(2),
+                         final(0) * initial(2) - initial(0) * final(2),
+                         initial(0) * final(1) - final(0) * initial(1)};
+
+    // https://stackoverflow.com/a/11741520
+    m_q = Quaternion{normProduct + dot, axis(0), axis(1), axis(2)}.Normalize();
+  }
+}
+
+Rotation3d Rotation3d::operator+(const Rotation3d& other) const {
+  return RotateBy(other);
+}
+
+Rotation3d Rotation3d::operator-(const Rotation3d& other) const {
+  return *this + -other;
+}
+
+Rotation3d Rotation3d::operator-() const { return Rotation3d{m_q.Inverse()}; }
+
+Rotation3d Rotation3d::operator*(double scalar) const {
+  // https://en.wikipedia.org/wiki/Slerp#Quaternion_Slerp
+  if (m_q.W() >= 0.0) {
+    return Rotation3d{{m_q.X(), m_q.Y(), m_q.Z()},
+                      2.0 * units::radian_t{scalar * std::acos(m_q.W())}};
+  } else {
+    return Rotation3d{{-m_q.X(), -m_q.Y(), -m_q.Z()},
+                      2.0 * units::radian_t{scalar * std::acos(-m_q.W())}};
+  }
+}
+
+bool Rotation3d::operator==(const Rotation3d& other) const {
+  return m_q == other.m_q;
+}
+
+bool Rotation3d::operator!=(const Rotation3d& other) const {
+  return !operator==(other);
+}
+
+Rotation3d Rotation3d::RotateBy(const Rotation3d& other) const {
+  return Rotation3d{other.m_q * m_q};
+}
+
+const Quaternion& Rotation3d::GetQuaternion() const { return m_q; }
+
+units::radian_t Rotation3d::X() const {
+  double w = m_q.W();
+  double x = m_q.X();
+  double y = m_q.Y();
+  double z = m_q.Z();
+
+  // https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles#Quaternion_to_Euler_angles_conversion
+  return units::radian_t{
+      std::atan2(2.0 * (w * x + y * z), 1.0 - 2.0 * (x * x + y * y))};
+}
+
+units::radian_t Rotation3d::Y() const {
+  double w = m_q.W();
+  double x = m_q.X();
+  double y = m_q.Y();
+  double z = m_q.Z();
+
+  // https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles#Quaternion_to_Euler_angles_conversion
+  double ratio = 2.0 * (w * y - z * x);
+  if (std::abs(ratio) >= 1.0) {
+    return units::radian_t{std::copysign(wpi::numbers::pi / 2.0, ratio)};
+  } else {
+    return units::radian_t{std::asin(ratio)};
+  }
+}
+
+units::radian_t Rotation3d::Z() const {
+  double w = m_q.W();
+  double x = m_q.X();
+  double y = m_q.Y();
+  double z = m_q.Z();
+
+  // https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles#Quaternion_to_Euler_angles_conversion
+  return units::radian_t{
+      std::atan2(2.0 * (w * z + x * y), 1.0 - 2.0 * (y * y + z * z))};
+}
+
+Vectord<3> Rotation3d::Axis() const {
+  double norm = std::hypot(m_q.X(), m_q.Y(), m_q.Z());
+  if (norm == 0.0) {
+    return {0.0, 0.0, 0.0};
+  } else {
+    return {m_q.X() / norm, m_q.Y() / norm, m_q.Z() / norm};
+  }
+}
+
+units::radian_t Rotation3d::Angle() const {
+  double norm = std::hypot(m_q.X(), m_q.Y(), m_q.Z());
+  return units::radian_t{2.0 * std::atan2(norm, m_q.W())};
+}
+
+Rotation2d Rotation3d::ToRotation2d() const { return Rotation2d{Z()}; }

photon-lib/src/main/native/cpp/geometry/Transform3d.cpp

@@ -0,0 +1,60 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022 PhotonVision
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <frc/geometry/Pose3d.h>
+#include <frc/geometry/Transform3d.h>
+
+using namespace frc;
+
+Transform3d::Transform3d(Pose3d initial, Pose3d final) {
+  // We are rotating the difference between the translations
+  // using a clockwise rotation matrix. This transforms the global
+  // delta into a local delta (relative to the initial pose).
+  m_translation = (final.Translation() - initial.Translation())
+                      .RotateBy(-initial.Rotation());
+
+  m_rotation = final.Rotation() - initial.Rotation();
+}
+
+Transform3d::Transform3d(Translation3d translation, Rotation3d rotation)
+    : m_translation(std::move(translation)), m_rotation(std::move(rotation)) {}
+
+Transform3d Transform3d::Inverse() const {
+  // We are rotating the difference between the translations
+  // using a clockwise rotation matrix. This transforms the global
+  // delta into a local delta (relative to the initial pose).
+  return Transform3d{(-Translation()).RotateBy(-Rotation()), -Rotation()};
+}
+
+Transform3d Transform3d::operator+(const Transform3d& other) const {
+  return Transform3d{Pose3d{}, Pose3d{}.TransformBy(*this).TransformBy(other)};
+}
+
+bool Transform3d::operator==(const Transform3d& other) const {
+  return m_translation == other.m_translation && m_rotation == other.m_rotation;
+}
+
+bool Transform3d::operator!=(const Transform3d& other) const {
+  return !operator==(other);
+}

photon-lib/src/main/native/cpp/geometry/Translation3d.cpp

@@ -0,0 +1,88 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2022 PhotonVision
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <frc/geometry/Translation3d.h>
+#include <units/math.h>
+
+using namespace frc;
+
+Translation3d::Translation3d(units::meter_t x, units::meter_t y,
+                             units::meter_t z)
+    : m_x(x), m_y(y), m_z(z) {}
+
+Translation3d::Translation3d(units::meter_t distance, const Rotation3d& angle) {
+  auto rectangular = Translation3d{distance, 0_m, 0_m}.RotateBy(angle);
+  m_x = rectangular.X();
+  m_y = rectangular.Y();
+  m_z = rectangular.Z();
+}
+
+units::meter_t Translation3d::Distance(const Translation3d& other) const {
+  return units::math::sqrt(units::math::pow<2>(other.m_x - m_x) +
+                           units::math::pow<2>(other.m_y - m_y) +
+                           units::math::pow<2>(other.m_z - m_z));
+}
+
+units::meter_t Translation3d::Norm() const {
+  return units::math::sqrt(m_x * m_x + m_y * m_y + m_z * m_z);
+}
+
+Translation3d Translation3d::RotateBy(const Rotation3d& other) const {
+  Quaternion p{0.0, m_x.value(), m_y.value(), m_z.value()};
+  auto qprime = other.GetQuaternion() * p * other.GetQuaternion().Inverse();
+  return Translation3d{units::meter_t{qprime.X()}, units::meter_t{qprime.Y()},
+                       units::meter_t{qprime.Z()}};
+}
+
+Translation2d Translation3d::ToTranslation2d() const {
+  return Translation2d{m_x, m_y};
+}
+
+Translation3d Translation3d::operator+(const Translation3d& other) const {
+  return {X() + other.X(), Y() + other.Y(), Z() + other.Z()};
+}
+
+Translation3d Translation3d::operator-(const Translation3d& other) const {
+  return *this + -other;
+}
+
+Translation3d Translation3d::operator-() const { return {-m_x, -m_y, -m_z}; }
+
+Translation3d Translation3d::operator*(double scalar) const {
+  return {scalar * m_x, scalar * m_y, scalar * m_z};
+}
+
+Translation3d Translation3d::operator/(double scalar) const {
+  return *this * (1.0 / scalar);
+}
+
+bool Translation3d::operator==(const Translation3d& other) const {
+  return units::math::abs(m_x - other.m_x) < 1E-9_m &&
+         units::math::abs(m_y - other.m_y) < 1E-9_m &&
+         units::math::abs(m_z - other.m_z) < 1E-9_m;
+}
+
+bool Translation3d::operator!=(const Translation3d& other) const {
+  return !operator==(other);
+}

photon-lib/src/main/native/cpp/photonlib/PhotonCamera.cpp

@@ -25,11 +25,15 @@
 #include "photonlib/PhotonCamera.h"
 
 #include <frc/Errors.h>
+#include <frc/Timer.h>
 
 #include "PhotonVersion.h"
 #include "photonlib/Packet.h"
 
 namespace photonlib {
+
+constexpr const units::second_t VERSION_CHECK_INTERVAL = 5_s;
+
 PhotonCamera::PhotonCamera(std::shared_ptr<nt::NetworkTableInstance> instance,
                            const std::string& cameraName)
     : mainTable(instance->GetTable("photonvision")),
@@ -48,7 +52,7 @@ PhotonCamera::PhotonCamera(const std::string& cameraName)
                        nt::NetworkTableInstance::GetDefault()),
                    cameraName) {}
 
-PhotonPipelineResult PhotonCamera::GetLatestResult() const {
+PhotonPipelineResult PhotonCamera::GetLatestResult() {
   // Prints warning if not connected
   VerifyVersion();
 
@@ -99,9 +103,14 @@ void PhotonCamera::SetLEDMode(LEDMode mode) {
   ledModeEntry.SetDouble(static_cast<double>(static_cast<int>(mode)));
 }
 
-void PhotonCamera::VerifyVersion() const {
+void PhotonCamera::VerifyVersion() {
   if (!PhotonCamera::VERSION_CHECK_ENABLED) return;
 
+  if ((frc::Timer::GetFPGATimestamp() - lastVersionCheckTime) <
+      VERSION_CHECK_INTERVAL)
+    return;
+  this->lastVersionCheckTime = frc::Timer::GetFPGATimestamp();
+
   const std::string& versionString = versionEntry.GetString("");
   if (versionString.empty()) {
     std::string path_ = path;

photon-lib/src/main/native/cpp/photonlib/PhotonTrackedTarget.cpp

@@ -33,19 +33,20 @@
 namespace photonlib {
 
 PhotonTrackedTarget::PhotonTrackedTarget(
-    double yaw, double pitch, double area, double skew,
-    const frc::Transform2d& pose,
+    double yaw, double pitch, double area, double skew, int id,
+    const frc::Transform3d& pose,
     const wpi::SmallVector<std::pair<double, double>, 4> corners)
     : yaw(yaw),
       pitch(pitch),
       area(area),
       skew(skew),
-      cameraToTarget(pose),
+      fiducialId(id),
+      bestCameraToTarget(pose),
       corners(corners) {}
 
 bool PhotonTrackedTarget::operator==(const PhotonTrackedTarget& other) const {
   return other.yaw == yaw && other.pitch == pitch && other.area == area &&
-         other.skew == skew && other.cameraToTarget == cameraToTarget &&
+         other.skew == skew && other.bestCameraToTarget == bestCameraToTarget &&
          other.corners == corners;
 }
 
@@ -55,9 +56,22 @@ bool PhotonTrackedTarget::operator!=(const PhotonTrackedTarget& other) const {
 
 Packet& operator<<(Packet& packet, const PhotonTrackedTarget& target) {
   packet << target.yaw << target.pitch << target.area << target.skew
-         << target.cameraToTarget.Translation().X().value()
-         << target.cameraToTarget.Translation().Y().value()
-         << target.cameraToTarget.Rotation().Degrees().value();
+         << target.fiducialId
+         << target.bestCameraToTarget.Translation().X().value()
+         << target.bestCameraToTarget.Translation().Y().value()
+         << target.bestCameraToTarget.Translation().Z().value()
+         << target.bestCameraToTarget.Rotation().GetQuaternion().W()
+         << target.bestCameraToTarget.Rotation().GetQuaternion().X()
+         << target.bestCameraToTarget.Rotation().GetQuaternion().Y()
+         << target.bestCameraToTarget.Rotation().GetQuaternion().Z()
+         << target.altCameraToTarget.Translation().X().value()
+         << target.altCameraToTarget.Translation().Y().value()
+         << target.altCameraToTarget.Translation().Z().value()
+         << target.altCameraToTarget.Rotation().GetQuaternion().W()
+         << target.altCameraToTarget.Rotation().GetQuaternion().X()
+         << target.altCameraToTarget.Rotation().GetQuaternion().Y()
+         << target.altCameraToTarget.Rotation().GetQuaternion().Z()
+         << target.poseAmbiguity;
 
   for (int i = 0; i < 4; i++) {
     packet << target.corners[i].first << target.corners[i].second;
@@ -67,15 +81,32 @@ Packet& operator<<(Packet& packet, const PhotonTrackedTarget& target) {
 }
 
 Packet& operator>>(Packet& packet, PhotonTrackedTarget& target) {
-  packet >> target.yaw >> target.pitch >> target.area >> target.skew;
+  packet >> target.yaw >> target.pitch >> target.area >> target.skew >>
+      target.fiducialId;
+
+  // We use these for best and alt transforms below
   double x = 0;
   double y = 0;
-  double rot = 0;
-  packet >> x >> y >> rot;
+  double z = 0;
+  double w = 0;
 
-  target.cameraToTarget =
-      frc::Transform2d(frc::Translation2d(units::meter_t(x), units::meter_t(y)),
-                       units::degree_t(rot));
+  // First transform is the "best" pose
+  packet >> x >> y >> z;
+  const auto bestTranslation = frc::Translation3d(
+      units::meter_t(x), units::meter_t(y), units::meter_t(z));
+  packet >> w >> x >> y >> z;
+  const auto bestRotation = frc::Rotation3d(frc::Quaternion(w, x, y, z));
+  target.bestCameraToTarget = frc::Transform3d(bestTranslation, bestRotation);
+
+  // Second transform is the "alternate" pose
+  packet >> x >> y >> z;
+  const auto altTranslation = frc::Translation3d(
+      units::meter_t(x), units::meter_t(y), units::meter_t(z));
+  packet >> w >> x >> y >> z;
+  const auto altRotation = frc::Rotation3d(frc::Quaternion(w, x, y, z));
+  target.altCameraToTarget = frc::Transform3d(altTranslation, altRotation);
+
+  packet >> target.poseAmbiguity;
 
   target.corners.clear();
   for (int i = 0; i < 4; i++) {