diff --git a/photon-client/src/components/common/cv-range-slider.vue b/photon-client/src/components/common/cv-range-slider.vue
index f0f11398f..1d25962a2 100644
--- a/photon-client/src/components/common/cv-range-slider.vue
+++ b/photon-client/src/components/common/cv-range-slider.vue
@@ -15,6 +15,7 @@
           :value="localValue"
           :max="max"
           :min="min"
+          :disabled="disabled"
           hide-details
           class="align-center"
           dark
@@ -34,7 +35,7 @@
               hide-details
               single-line
               type="number"
-              style="width: 50px"
+              style="width: 60px"
               :step="step"
               @input="handleChange"
               @focus="prependFocused = true"
@@ -53,7 +54,7 @@
               hide-details
               single-line
               type="number"
-              style="width: 50px"
+              style="width: 60px"
               :step="step"
               @input="handleChange"
               @focus="appendFocused = true"
@@ -75,7 +76,7 @@ export default {
     TooltippedLabel,
   },
   // eslint-disable-next-line vue/require-prop-types
-  props: ["name", "min", "max", "value", "step", "tooltip"],
+  props: ["name", "min", "max", "value", "step", "tooltip", "disabled"],
   data() {
     return {
       prependFocused: false,
diff --git a/photon-client/src/components/pipeline/CameraAndPipelineSelect.vue b/photon-client/src/components/pipeline/CameraAndPipelineSelect.vue
index 865cad801..78e5b9553 100644
--- a/photon-client/src/components/pipeline/CameraAndPipelineSelect.vue
+++ b/photon-client/src/components/pipeline/CameraAndPipelineSelect.vue
@@ -88,7 +88,11 @@
               menu
             </v-icon>
           </template>
-          <v-list dense>
+          <v-list
+            dark
+            dense
+            color="primary"
+          >
             <v-list-item @click="toPipelineNameChange">
               <v-list-item-title>
                 <CVicon
@@ -119,7 +123,7 @@
                 />
               </v-list-item-title>
             </v-list-item>
-            <v-list-item @click="openDuplicateDialog">
+            <v-list-item @click="duplicatePipeline">
               <v-list-item-title>
                 <CVicon
                   color="#c5c5c5"
@@ -132,66 +136,51 @@
           </v-list>
         </v-menu>
       </v-col>
+      <v-col
+        v-if="currentPipelineType >= 0"
+        cols="10"
+        md="5"
+        lg="10"
+        class="pt-0 pb-0 pl-6 ml-16"
+      >
+        <CVselect
+          v-model="currentPipelineType"
+          name="Type"
+          :list="['Reflective', 'Shape']"
+          @input="e => showTypeDialog(e)"
+        />
+      </v-col>
     </v-row>
-    <!--pipeline duplicate dialog-->
-    <v-dialog
-      v-model="duplicateDialog"
-      dark
-      width="500"
-      height="357"
-    >
-      <v-card dark>
-        <v-card-title
-          class="headline"
-          primary-title
-        >
-          Duplicate Pipeline
-        </v-card-title>
-        <v-card-text>
-          <CVselect
-            v-model="pipeIndexToDuplicate"
-            name="Pipeline"
-            :list="$store.getters.pipelineList"
-          />
-        </v-card-text>
-        <v-divider />
-        <v-card-actions>
-          <v-spacer />
-          <v-btn
-            color="#ffd843"
-            @click="duplicatePipeline"
-          >
-            Duplicate
-          </v-btn>
-          <v-btn
-            color="error"
-            @click="closeDuplicateDialog"
-          >
-            Cancel
-          </v-btn>
-        </v-card-actions>
-      </v-card>
-    </v-dialog>
+
     <!--pipeline naming dialog-->
     <v-dialog
       v-model="namingDialog"
       dark
+      persistent
       width="500"
       height="357"
     >
-      <v-card dark>
+      <v-card
+        dark
+        color="primary"
+      >
         <v-card-title
           class="headline"
           primary-title
         >
-          Pipeline Name
+          {{ isPipelineNameEdit ? "Edit Pipeline Name" : "Create Pipeline" }}
         </v-card-title>
         <v-card-text>
           <CVinput
             v-model="newPipelineName"
             name="Pipeline"
             :error-message="checkPipelineName"
-            @Enter="savePipelineNameChange"
+          />
+          <CVselect
+            v-model="newPipelineType"
+            name="Pipeline Type"
+            :list="['Reflective', 'Shape']"
+            :disabled="isPipelineNameEdit"
           />
         </v-card-text>
         <v-divider />
@@ -213,161 +202,205 @@
         </v-card-actions>
       </v-card>
     </v-dialog>
+    <v-dialog
+      v-model="showPipeTypeDialog"
+      width="600"
+    >
+      <v-card
+        color="primary"
+        dark
+      >
+        <v-card-title>Change Pipeline Type</v-card-title>
+        <v-card-text>
+          Changing the type of this pipeline will erase the current pipeline's settings and replace it with a new {{ ['Reflective', 'Shape'][proposedPipelineType] }} pipeline. <b class="red--text format_bold">You will lose all settings for the pipeline
+            "{{ ($store.getters.isDriverMode ? ['Driver Mode'] : []).concat($store.getters.pipelineList)[currentPipelineIndex] }}."</b> Are you sure you want to do this?
+          <v-row
+            class="mt-6"
+            style="display: flex; align-items: center; justify-content: center"
+            align="center"
+          >
+            <v-btn
+              class="mr-3"
+              color="red"
+              width="250"
+              @click="e => changePipeType(true)"
+            >
+              Yes, replace this pipeline
+            </v-btn>
+            <v-btn
+              class="ml-10"
+              color="secondary"
+              width="250"
+              @click="e => changePipeType(false)"
+            >
+              No, take me back
+            </v-btn>
+          </v-row>
+        </v-card-text>
+      </v-card>
+    </v-dialog>
   </div>
 </template>
 
 <script>
-    import CVicon from '../common/cv-icon'
-    import CVselect from '../common/cv-select'
-    import CVinput from '../common/cv-input'
-
-    export default {
-        name: "CameraAndPipelineSelect",
-        components: {
-            CVicon,
-            CVselect,
-            CVinput
-        },
-        data: () => {
-            return {
-                re: RegExp("^[A-Za-z0-9 \\-)(]*[A-Za-z0-9][A-Za-z0-9 \\-)(.]*$"),
-                isCameraNameEdit: false,
-                newCameraName: "",
-                cameraNameError: "",
-                isPipelineNameEdit: false,
-                namingDialog: false,
-                newPipelineName: "",
-                duplicateDialog: false,
-                pipeIndexToDuplicate: undefined
-            }
-        },
-        computed: {
-            checkCameraName() {
-                if (this.newCameraName !== this.$store.getters.cameraList[this.currentCameraIndex]) {
-                    if (this.re.test(this.newCameraName)) {
-                        for (let cam in this.cameraList) {
-                            if (this.cameraList.hasOwnProperty(cam)) {
-                                if (this.newCameraName === this.cameraList[cam]) {
-                                    return "A camera by that name already Exists"
-                                }
-                            }
-                        }
-                    } else {
-                        return "A camera name can only contain letters, numbers and spaces"
-                    }
-                }
-                return "";
-            },
-            checkPipelineName() {
-                if (this.newPipelineName !== this.$store.getters.pipelineList[this.currentPipelineIndex - 1] || this.isPipelineNameEdit === false) {
-                    if (this.re.test(this.newPipelineName)) {
-                        for (let pipe in this.$store.getters.pipelineList) {
-                            if (this.$store.getters.pipelineList.hasOwnProperty(pipe)) {
-                                if (this.newPipelineName === this.$store.getters.pipelineList[pipe]) {
-                                    return "A pipeline with this name already exists"
-                                }
-                            }
-                        }
-                    } else {
-                        return "A pipeline name can only contain letters, numbers, and spaces"
-                    }
-                }
-                return ""
-            },
-            currentCameraIndex: {
-                get() {
-                    return this.$store.getters.currentCameraIndex;
-                },
-                set(value) {
-                    this.$store.commit('currentCameraIndex', value);
-                }
-            },
-            currentPipelineIndex: {
-                get() {
-                    return this.$store.getters.currentPipelineIndex + (this.$store.getters.isDriverMode ? 1 : 0);
-                },
-                set(value) {
-                    this.$store.commit('currentPipelineIndex', value - (this.$store.getters.isDriverMode ? 1 : 0));
-                }
-            }
-        },
-        methods: {
-            changeCameraName() {
-                this.newCameraName = this.$store.getters.cameraList[this.currentCameraIndex];
-                this.isCameraNameEdit = true;
-            },
-            saveCameraNameChange() {
-                if (this.checkCameraName === "") {
-                    // this.handleInputWithIndex("changeCameraName", this.newCameraName);
-                    this.axios.post('http://' + this.$address + '/api/setCameraNickname',
-                        {name: this.newCameraName, cameraIndex: this.$store.getters.currentCameraIndex})
-                        // eslint-disable-next-line
-                        .then(r => {
-                            this.$emit('camera-name-changed')
-                        })
-                        .catch(e => {
-                            console.log("HTTP error while changing camera name " + e);
-                            this.$emit('camera-name-changed')
-                        })
-                    this.discardCameraNameChange();
-                }
-            },
-            discardCameraNameChange() {
-                this.isCameraNameEdit = false;
-                this.newCameraName = "";
-            },
-            toPipelineNameChange() {
-                this.newPipelineName = this.$store.getters.pipelineList[this.currentPipelineIndex - 1];
-                this.isPipelineNameEdit = true;
-                this.namingDialog = true;
-            },
-            toCreatePipeline() {
-                this.newPipelineName = "New Pipeline";
-                this.isPipelineNameEdit = false;
-                this.namingDialog = true;
-            },
-            openDuplicateDialog() {
-                this.pipeIndexToDuplicate = this.currentPipelineIndex - 1;
-                this.duplicateDialog = true;
-            },
-            deleteCurrentPipeline() {
-                if (this.$store.getters.pipelineList.length > 1) {
-                    this.handleInputWithIndex('deleteCurrentPipeline', {});
-                } else {
-                    this.snackbar = true;
-                }
-            },
-            savePipelineNameChange() {
-                if (this.checkPipelineName === "") {
-                    if (this.isPipelineNameEdit) {
-                        this.handleInputWithIndex("changePipelineName", this.newPipelineName);
-                    } else {
-                        this.handleInputWithIndex("addNewPipeline", this.newPipelineName);
-                    }
-                    this.discardPipelineNameChange();
-                }
-            },
-            duplicatePipeline() {
-                // if (!this.anotherCamera) {
-                //     this.pipelineDuplicate.camera = -1
-                // }
-                this.handleInputWithIndex("duplicatePipeline", this.pipeIndexToDuplicate);
-                // this.axios.post("http://" + this.$address + "/api/vision/duplicate", this.pipeIndexToDuplicate);
-
-                this.closeDuplicateDialog();
-            },
-            closeDuplicateDialog() {
-                this.duplicateDialog = false;
-                this.pipeIndexToDuplicate = undefined;
-            },
-            discardPipelineNameChange() {
-                this.namingDialog = false;
-                this.isPipelineNameEdit = false;
-                this.newPipelineName = "";
-            },
-        }
+import CVicon from '../common/cv-icon'
+import CVselect from '../common/cv-select'
+import CVinput from '../common/cv-input'
 
+export default {
+  name: "CameraAndPipelineSelect",
+  components: {
+    CVicon,
+    CVselect,
+    CVinput
+  },
+  data: () => {
+    return {
+      re: RegExp("^[A-Za-z0-9 \\-)(]*[A-Za-z0-9][A-Za-z0-9 \\-)(.]*$"),
+      isCameraNameEdit: false,
+      newCameraName: "",
+      cameraNameError: "",
+      isPipelineNameEdit: false,
+      namingDialog: false,
+      newPipelineName: "",
+      newPipelineType: 0,
+      duplicateDialog: false,
+      showPipeTypeDialog: false,
+      proposedPipelineType : 0,
+      pipeIndexToDuplicate: undefined
     }
+  },
+  computed: {
+    checkCameraName() {
+      if (this.newCameraName !== this.$store.getters.cameraList[this.currentCameraIndex]) {
+        if (this.re.test(this.newCameraName)) {
+          for (let cam in this.cameraList) {
+            if (this.cameraList.hasOwnProperty(cam)) {
+              if (this.newCameraName === this.cameraList[cam]) {
+                return "A camera by that name already Exists"
+              }
+            }
+          }
+        } else {
+          return "A camera name can only contain letters, numbers and spaces"
+        }
+      }
+      return "";
+    },
+    checkPipelineName() {
+      if (this.newPipelineName !== this.$store.getters.pipelineList[this.currentPipelineIndex - 1] || this.isPipelineNameEdit === false) {
+        if (this.re.test(this.newPipelineName)) {
+          for (let pipe in this.$store.getters.pipelineList) {
+            if (this.$store.getters.pipelineList.hasOwnProperty(pipe)) {
+              if (this.newPipelineName === this.$store.getters.pipelineList[pipe]) {
+                return "A pipeline with this name already exists"
+              }
+            }
+          }
+        } else {
+          return "A pipeline name can only contain letters, numbers, and spaces"
+        }
+      }
+      return ""
+    },
+    currentCameraIndex: {
+      get() {
+        return this.$store.getters.currentCameraIndex;
+      },
+      set(value) {
+        this.$store.commit('currentCameraIndex', value);
+      }
+    },
+    currentPipelineIndex: {
+      get() {
+        return this.$store.getters.currentPipelineIndex + (this.$store.getters.isDriverMode ? 1 : 0);
+      },
+      set(value) {
+        this.$store.commit('currentPipelineIndex', value - (this.$store.getters.isDriverMode ? 1 : 0));
+      }
+    },
+    currentPipelineType: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.pipelineType - 2;
+      },
+      set(value) {
+        value; // nop, since we have the dialog for this
+      }
+    }
+  },
+  methods: {
+    showTypeDialog(idx) {
+      // Only show the dialog if it's a new type
+      this.showPipeTypeDialog = idx !== this.currentPipelineType;
+      this.proposedPipelineType = idx;
+    },
+    changePipeType(actuallyChange) {
+      const newIdx = actuallyChange ? this.proposedPipelineType : this.currentPipelineType
+      this.handleInputWithIndex('pipelineType', newIdx);
+      this.showPipeTypeDialog = false;
+    },
+    changeCameraName() {
+      this.newCameraName = this.$store.getters.cameraList[this.currentCameraIndex];
+      this.isCameraNameEdit = true;
+    },
+    saveCameraNameChange() {
+      if (this.checkCameraName === "") {
+        // this.handleInputWithIndex("changeCameraName", this.newCameraName);
+        this.axios.post('http://' + this.$address + '/api/setCameraNickname',
+            {name: this.newCameraName, cameraIndex: this.$store.getters.currentCameraIndex})
+            // eslint-disable-next-line
+            .then(r => {
+              this.$emit('camera-name-changed')
+            })
+            .catch(e => {
+              console.log("HTTP error while changing camera name " + e);
+              this.$emit('camera-name-changed')
+            })
+        this.discardCameraNameChange();
+      }
+    },
+    discardCameraNameChange() {
+      this.isCameraNameEdit = false;
+      this.newCameraName = "";
+    },
+    toPipelineNameChange() {
+      this.newPipelineName = this.$store.getters.pipelineList[this.currentPipelineIndex - 1];
+      this.isPipelineNameEdit = true;
+      this.namingDialog = true;
+    },
+    toCreatePipeline() {
+      this.newPipelineName = "New Pipeline";
+      this.isPipelineNameEdit = false;
+      this.namingDialog = true;
+    },
+    deleteCurrentPipeline() {
+      if (this.$store.getters.pipelineList.length > 1) {
+        this.handleInputWithIndex('deleteCurrentPipeline', {});
+      } else {
+        this.snackbar = true;
+      }
+    },
+    savePipelineNameChange() {
+      if (this.checkPipelineName === "") {
+        if (this.isPipelineNameEdit) {
+          this.handleInputWithIndex("changePipelineName", this.newPipelineName);
+        } else {
+          this.handleInputWithIndex("addNewPipeline", [this.newPipelineName, this.newPipelineType]); // 0 for reflective, 1 for colored shpae
+        }
+        this.discardPipelineNameChange();
+      }
+    },
+    duplicatePipeline() {
+      this.handleInputWithIndex("duplicatePipeline", this.currentPipelineIndex);
+    },
+    discardPipelineNameChange() {
+      this.namingDialog = false;
+      this.isPipelineNameEdit = false;
+      this.newPipelineName = "";
+    },
+  }
+
+}
 </script>
 
 <style scoped>
diff --git a/photon-client/src/main.js b/photon-client/src/main.js
index a95e93191..81248f7c7 100644
--- a/photon-client/src/main.js
+++ b/photon-client/src/main.js
@@ -29,9 +29,11 @@ Vue.use(VueAxios, axios);
 Vue.prototype.$msgPack = msgPack(true);
 
 import {dataHandleMixin} from './mixins/global/dataHandleMixin'
-
 Vue.mixin(dataHandleMixin);
 
+import {stateMixin} from './mixins/global/stateMixin'
+Vue.mixin(stateMixin);
+
 new Vue({
     router,
     store,
diff --git a/photon-client/src/mixins/global/stateMixin.js b/photon-client/src/mixins/global/stateMixin.js
new file mode 100644
index 000000000..4391e14a4
--- /dev/null
+++ b/photon-client/src/mixins/global/stateMixin.js
@@ -0,0 +1,10 @@
+export const stateMixin = {
+    methods: {
+        currentPipelineType() {
+            return this.$store.getters.pipelineType
+        },
+        currentPipelineSettings() {
+            return this.$store.getters.currentPipelineSettings
+        },
+    }
+};
diff --git a/photon-client/src/store/index.js b/photon-client/src/store/index.js
index a694dfbe8..efe859384 100644
--- a/photon-client/src/store/index.js
+++ b/photon-client/src/store/index.js
@@ -42,7 +42,7 @@ export default new Vuex.Store({
                 isFovConfigurable: true,
                 calibrated: false,
                 currentPipelineSettings: {
-                    pipelineType: 2, // One of "driver", "reflective", "shape"
+                    pipelineType: 2, // One of "calib", "driver", "reflective", "shape"
                     // 2 is reflective
 
                     // Settings that apply to all pipeline types
@@ -245,5 +245,6 @@ export default new Vuex.Store({
         },
         pipelineList: state => state.cameraSettings[state.currentCameraIndex].pipelineNicknames,
         calibrationList: state => state.cameraSettings[state.currentCameraIndex].calibrations,
+        pipelineType: state => state.cameraSettings[state.currentCameraIndex].currentPipelineSettings.pipelineType
     }
 })
\ No newline at end of file
diff --git a/photon-client/src/views/PipelineViews/ContoursTab.vue b/photon-client/src/views/PipelineViews/ContoursTab.vue
index f4feba0f4..eb3027f8e 100644
--- a/photon-client/src/views/PipelineViews/ContoursTab.vue
+++ b/photon-client/src/views/PipelineViews/ContoursTab.vue
@@ -1,160 +1,286 @@
 <template>
   <div>
     <CVrangeSlider
-      v-model="contourArea"
-      name="Area"
-      min="0"
-      max="100"
-      step="0.1"
-      @input="handlePipelineData('contourArea')"
-      @rollback="e=> rollback('contourArea',e)"
+        v-model="contourArea"
+        name="Area"
+        min="0"
+        max="100"
+        step="0.1"
+        @input="handlePipelineData('contourArea')"
     />
     <CVrangeSlider
-      v-model="contourRatio"
-      name="Ratio (W/H)"
-      tooltip="Min and max ratio between the width and height of a contour's bounding rectangle"
-      min="0"
-      max="100"
-      step="0.1"
-      @input="handlePipelineData('contourRatio')"
-      @rollback="e=> rollback('contourRatio',e)"
+        v-model="contourRatio"
+        v-if="currentPipelineType() !== 3"
+        name="Ratio (W/H)"
+        tooltip="Min and max ratio between the width and height of a contour's bounding rectangle"
+        min="0"
+        max="100"
+        step="0.1"
+        @input="handlePipelineData('contourRatio')"
     />
     <CVrangeSlider
-      v-model="contourFullness"
-      name="Fullness"
-      tooltip="Min and max ratio between a contour's area and its bounding rectangle"
-      min="0"
-      max="100"
-      @input="handlePipelineData('contourFullness')"
-      @rollback="e=> rollback('contourFullness',e)"
+        v-model="contourFullness"
+        v-if="currentPipelineType() !== 3"
+        name="Fullness"
+        tooltip="Min and max ratio between a contour's area and its bounding rectangle"
+        min="0"
+        max="100"
+        @input="handlePipelineData('contourFullness')"
+    />
+    <CVrangeSlider
+        v-model="contourPerimeter"
+        v-if="currentPipelineType() === 3"
+        name="Perimeter"
+        tooltip="Min and max perimeter of the shape, in pixels"
+        min="0"
+        max="4000"
+        @input="handlePipelineData('contourPerimeter')"
     />
     <CVslider
-      v-model="contourSpecklePercentage"
-      name="Speckle Rejection"
-      tooltip="Rejects contours whose average area is less than the given percentage of the average area of all the other contours"
-      min="0"
-      max="100"
-      :slider-cols="largeBox"
-      @input="handlePipelineData('contourSpecklePercentage')"
-      @rollback="e=> rollback('contourSpecklePercentage',e)"
+        v-model="contourSpecklePercentage"
+        name="Speckle Rejection"
+        tooltip="Rejects contours whose average area is less than the given percentage of the average area of all the other contours"
+        min="0"
+        max="100"
+        :slider-cols="largeBox"
+        @input="handlePipelineData('contourSpecklePercentage')"
     />
+    <template v-if="currentPipelineType() !== 3">
+      <CVselect
+          v-model="contourGroupingMode"
+          name="Target Grouping"
+          tooltip="Whether or not every two targets are paired with each other (good for e.g. 2019 targets)"
+          :select-cols="largeBox"
+          :list="['Single','Dual']"
+          @input="handlePipelineData('contourGroupingMode')"
+      />
+      <CVselect
+          v-model="contourIntersection"
+          name="Target Intersection"
+          tooltip="If target grouping is in dual mode it will use this dropdown to decide how targets are grouped with adjacent targets"
+          :select-cols="largeBox"
+          :list="['None','Up','Down','Left','Right']"
+          :disabled="contourGroupingMode === 0"
+          @input="handlePipelineData('contourIntersection')"
+      />
+    </template>
+    <!-- If we arent not a shape, we are a shape-->
+    <template v-else>
+      <v-divider class="mt-3"/>
+      <CVselect
+          v-model="contourShape"
+          name="Target Shape"
+          tooltip="The shape of targets to look for"
+          :select-cols="largeBox"
+          :list="['Circle', 'Polygon', 'Triangle', 'Quadrilateral']"
+          @input="handlePipelineData('contourShape')"
+      />
+
+      <!-- Accuracy % is only for polygons-->
+      <CVslider
+          v-model="accuracyPercentage"
+          :disabled="currentPipelineSettings().contourShape < 1"
+          name="Shape Simplification"
+          tooltip="How much we should simply the input contour before checking how many sides it has"
+          min="0"
+          max="100"
+          :slider-cols="largeBox"
+          @input="handlePipelineData('accuracyPercentage')"
+      />
+      <!-- Similarly, the threshold is only for circles -->
+      <CVslider
+          v-model="circleDetectThreshold"
+          :disabled="currentPipelineSettings().contourShape !== 0"
+          name="Circle match distance"
+          tooltip="How close the centroid of a contour must be to the center of a circle in order for them to be matched"
+          min="1"
+          max="100"
+          :slider-cols="largeBox"
+          @input="handlePipelineData('circleDetectThreshold')"
+      />
+      <CVrangeSlider
+          v-model="contourRadius"
+          :disabled="currentPipelineSettings().contourShape !== 0"
+          name="Radius"
+          min="0"
+          max="100"
+          step="1"
+          @input="handlePipelineData('contourRadius')"
+      />
+      <CVslider
+          v-model="maxCannyThresh"
+          :disabled="currentPipelineSettings().contourShape !== 0"
+          name="Max Canny Threshold"
+          min="1"
+          max="100"
+          :slider-cols="largeBox"
+          @input="handlePipelineData('maxCannyThresh')"
+      />
+      <CVslider
+          v-model="circleAccuracy"
+          :disabled="currentPipelineSettings().contourShape !== 0"
+          name="Circle Accuracy"
+          min="0"
+          max="100"
+          :slider-cols="largeBox"
+          @input="handlePipelineData('circleAccuracy')"
+      />
+      <v-divider class="mt-3"/>
+    </template>
     <CVselect
-      v-model="contourGroupingMode"
-      name="Target Grouping"
-      tooltip="Whether or not every two targets are paired with each other (good for e.g. 2019 targets)"
-      :select-cols="largeBox"
-      :list="['Single','Dual']"
-      @input="handlePipelineData('contourGroupingMode')"
-      @rollback="e=> rollback('contourGroupingMode',e)"
-    />
-    <CVselect
-      v-model="contourIntersection"
-      name="Target Intersection"
-      tooltip="If target grouping is in dual mode it will use this dropdown to decide how targets are grouped with adjacent targets"
-      :select-cols="largeBox"
-      :list="['None','Up','Down','Left','Right']"
-      :disabled="contourGroupingMode === 0"
-      @input="handlePipelineData('contourIntersection')"
-      @rollback="e=> rollback('contourIntersection',e)"
-    />
-    <CVselect
-      v-model="contourSortMode"
-      name="Target Sort"
-      tooltip="Chooses the sorting mode used to determine the 'best' targets to provide to user code"
-      :select-cols="largeBox"
-      :list="['Largest','Smallest','Highest','Lowest','Rightmost','Leftmost','Centermost']"
-      @input="handlePipelineData('contourSortMode')"
-      @rollback="e => rollback('contourSortMode', e)"
+        v-model="contourSortMode"
+        name="Target Sort"
+        tooltip="Chooses the sorting mode used to determine the 'best' targets to provide to user code"
+        :select-cols="largeBox"
+        :list="['Largest','Smallest','Highest','Lowest','Rightmost','Leftmost','Centermost']"
+        @input="handlePipelineData('contourSortMode')"
+        @rollback="e => rollback('contourSortMode', e)"
     />
   </div>
 </template>
 
 <script>
-    import CVrangeSlider from '../../components/common/cv-range-slider'
-    import CVselect from '../../components/common/cv-select'
-    import CVslider from '../../components/common/cv-slider'
+import CVrangeSlider from '../../components/common/cv-range-slider'
+import CVselect from '../../components/common/cv-select'
+import CVslider from '../../components/common/cv-slider'
 
-    export default {
-        name: 'Contours',
-        components: {
-            CVrangeSlider,
-            CVselect,
-            CVslider
-        },
-        // eslint-disable-next-line vue/require-prop-types
-        props: ['value'],
+export default {
+  name: 'Contours',
+  components: {
+    CVrangeSlider,
+    CVselect,
+    CVslider
+  },
+  // eslint-disable-next-line vue/require-prop-types
+  props: ['value'],
 
-        data() {
-            return {}
-        },
-        computed: {
-          largeBox: {
-            get() {
-              // Sliders and selectors should be fuller width if we're on screen size medium and
-              // up and either not in compact mode (because the tab will be 100% screen width),
-              // or in driver mode (where the card will also be 100% screen width).
-              return this.$vuetify.breakpoint.mdAndUp && (!this.$store.state.compactMode || this.$store.getters.isDriverMode) ? 10 : 8;
-            }
-          },
-            contourArea: {
-                get() {
-                    return this.$store.getters.currentPipelineSettings.contourArea
-                },
-                set(val) {
-                    this.$store.commit("mutatePipeline", {"contourArea": val});
-                }
-            },
-            contourRatio: {
-                get() {
-                    return this.$store.getters.currentPipelineSettings.contourRatio
-                },
-                set(val) {
-                    this.$store.commit("mutatePipeline", {"contourRatio": val});
-                }
-            },
-            contourFullness: {
-                get() {
-                    return this.$store.getters.currentPipelineSettings.contourFullness
-                },
-                set(val) {
-                    this.$store.commit("mutatePipeline", {"contourFullness": val});
-                }
-            },
-            contourSpecklePercentage: {
-                get() {
-                    return this.$store.getters.currentPipelineSettings.contourSpecklePercentage
-                },
-                set(val) {
-                    this.$store.commit("mutatePipeline", {"contourSpecklePercentage": val});
-                }
-            },
-            contourGroupingMode: {
-                get() {
-                    return this.$store.getters.currentPipelineSettings.contourGroupingMode
-                },
-                set(val) {
-                    this.$store.commit("mutatePipeline", {"contourGroupingMode": val});
-                }
-            },
-            contourSortMode: {
-              get() {
-                return this.$store.getters.currentPipelineSettings.contourSortMode
-              },
-              set(val) {
-                this.$store.commit("mutatePipeline", {"contourSortMode": val});
-              }
-            },
-            contourIntersection: {
-                get() {
-                    return this.$store.getters.currentPipelineSettings.contourIntersection
-                },
-                set(val) {
-                    this.$store.commit("mutatePipeline", {"contourIntersection": val});
-                }
-            }
-        },
-        methods: {},
-    }
+  data() {
+    return {}
+  },
+  computed: {
+    largeBox: {
+      get() {
+        // Sliders and selectors should be fuller width if we're on screen size medium and
+        // up and either not in compact mode (because the tab will be 100% screen width),
+        // or in driver mode (where the card will also be 100% screen width).
+        return this.$vuetify.breakpoint.mdAndUp && (!this.$store.state.compactMode || this.$store.getters.isDriverMode) ? 10 : 8;
+      }
+    },
+    contourArea: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourArea
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourArea": val});
+      }
+    },
+    contourRatio: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourRatio
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourRatio": val});
+      }
+    },
+    contourFullness: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourFullness
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourFullness": val});
+      }
+    },
+    contourPerimeter: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourPerimeter
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourPerimeter": val});
+      }
+    },
+    contourSpecklePercentage: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourSpecklePercentage
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourSpecklePercentage": val});
+      }
+    },
+    contourGroupingMode: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourGroupingMode
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourGroupingMode": val});
+      }
+    },
+    contourSortMode: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourSortMode
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourSortMode": val});
+      }
+    },
+    contourShape: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourShape
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourShape": val});
+      }
+    },
+    contourIntersection: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourIntersection
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourIntersection": val});
+      }
+    },
+    accuracyPercentage: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.accuracyPercentage
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"accuracyPercentage": val});
+      }
+    },
+    contourRadius: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.contourRadius
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"contourRadius": val});
+      }
+    },
+    circleDetectThreshold: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.circleDetectThreshold
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"circleDetectThreshold": val});
+      }
+    },
+    maxCannyThresh: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.maxCannyThresh
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"maxCannyThresh": val});
+      }
+    },
+    circleAccuracy: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.circleAccuracy
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"circleAccuracy": val});
+      }
+    },
+  },
+  methods: {},
+}
 </script>
 
 <style lang="" scoped>
diff --git a/photon-client/src/views/PipelineViews/ThresholdTab.vue b/photon-client/src/views/PipelineViews/ThresholdTab.vue
index 9dbbdab48..99853896d 100644
--- a/photon-client/src/views/PipelineViews/ThresholdTab.vue
+++ b/photon-client/src/views/PipelineViews/ThresholdTab.vue
@@ -1,48 +1,66 @@
 <template>
   <div>
     <CVrangeSlider
-      v-model="hsvHue"
-      name="Hue"
-      tooltip="Describes color"
-      :min="0"
-      :max="180"
-      @input="handlePipelineData('hsvHue')"
-      @rollback="e => rollback('hue',e)"
+        v-model="hsvHue"
+        name="Hue"
+        tooltip="Describes color"
+        :min="0"
+        :max="180"
+        @input="handlePipelineData('hsvHue')"
+        @rollback="e => rollback('hue',e)"
     />
     <CVrangeSlider
-      v-model="hsvSaturation"
-      name="Saturation"
-      tooltip="Describes colorfulness; the smaller this value the 'whiter' the color becomes"
-      :min="0"
-      :max="255"
-      @input="handlePipelineData('hsvSaturation')"
-      @rollback="e => rollback('saturation',e)"
+        v-model="hsvSaturation"
+        name="Saturation"
+        tooltip="Describes colorfulness; the smaller this value the 'whiter' the color becomes"
+        :min="0"
+        :max="255"
+        @input="handlePipelineData('hsvSaturation')"
+        @rollback="e => rollback('saturation',e)"
     />
     <CVrangeSlider
-      v-model="hsvValue"
-      name="Value"
-      tooltip="Describes lightness; the smaller this value the 'blacker' the color becomes"
-      :min="0"
-      :max="255"
-      @input="handlePipelineData('hsvValue')"
-      @rollback="e => rollback('value',e)"
+        v-model="hsvValue"
+        name="Value"
+        tooltip="Describes lightness; the smaller this value the 'blacker' the color becomes"
+        :min="0"
+        :max="255"
+        @input="handlePipelineData('hsvValue')"
+        @rollback="e => rollback('value',e)"
     />
+    <template v-if="this.currentPipelineType() === 3">
+      <CVSwitch
+          v-model="erode"
+          name="Erode"
+          tooltip="Removes pixels around the edges of white areas in the thresholded image"
+          @input="handlePipelineData('erode')"
+          @rollback="e => rollback('erode',e)"
+      />
+      <CVSwitch
+          v-model="dilate"
+          class="mb-0"
+          name="Dilate"
+          tooltip="Adds pixels around the edges of white areas in the thresholded image"
+          @input="handlePipelineData('dilate')"
+          @rollback="e => rollback('dilate',e)"
+      />
+    </template>
+    <v-divider class="mb-3 mt-3"/>
     <div class="pt-3 white--text">
       Color Picker
     </div>
     <v-divider
-      class="mt-3"
+        class="mt-3"
     />
     <v-row
-      justify="center"
-      class="mt-3 mb-3"
+        justify="center"
+        class="mt-3 mb-3"
     >
       <template v-if="!$store.state.colorPicking">
         <v-btn
-          color="accent"
-          class="ma-2 black--text"
-          small
-          @click="setFunction(3)"
+            color="accent"
+            class="ma-2 black--text"
+            small
+            @click="setFunction(3)"
         >
           <v-icon left>
             mdi-minus
@@ -50,10 +68,10 @@
           Shrink Range
         </v-btn>
         <v-btn
-          color="accent"
-          class="ma-2 black--text"
-          small
-          @click="setFunction(1)"
+            color="accent"
+            class="ma-2 black--text"
+            small
+            @click="setFunction(1)"
         >
           <v-icon left>
             mdi-plus-minus
@@ -61,10 +79,10 @@
           Set To Average
         </v-btn>
         <v-btn
-          color="accent"
-          class="ma-2 black--text"
-          small
-          @click="setFunction(2)"
+            color="accent"
+            class="ma-2 black--text"
+            small
+            @click="setFunction(2)"
         >
           <v-icon left>
             mdi-plus
@@ -74,11 +92,11 @@
       </template>
       <template v-else>
         <v-btn
-          color="accent"
-          class="ma-2 black--text"
-          style="width: 30%;"
-          small
-          @click="setFunction(0)"
+            color="accent"
+            class="ma-2 black--text"
+            style="width: 30%;"
+            small
+            @click="setFunction(0)"
         >
           Cancel
         </v-btn>
@@ -88,112 +106,130 @@
 </template>
 
 <script>
-    import CVrangeSlider from '../../components/common/cv-range-slider'
-    
-    export default {
-        name: 'Threshold',
-        components: {
-            CVrangeSlider
-        },
-        // eslint-disable-next-line vue/require-prop-types
-        props: ['value'],
-        data() {
-            return {
-                currentFunction: undefined,
-                colorPicker: undefined,
-                showThresholdState: 0
-            }
-        },
-        computed: {
-            hsvHue: {
-                get() {
-                    return this.$store.getters.currentPipelineSettings.hsvHue
-                },
-                set(val) {
-                    this.$store.commit("mutatePipeline", {"hsvHue": val})
-                }
-            },
-            hsvSaturation: {
-                get() {
-                    return this.$store.getters.currentPipelineSettings.hsvSaturation
-                },
-                set(val) {
-                    this.$store.commit("mutatePipeline", {"hsvSaturation": val})
-                }
-            },
-            hsvValue: {
-                get() {
-                    return this.$store.getters.currentPipelineSettings.hsvValue
-                },
-                set(val) {
-                    this.$store.commit("mutatePipeline", {"hsvValue": val})
-                }
-            }
-        },
-        mounted: function () {
-            const self = this;
-            this.colorPicker = require('../../plugins/ColorPicker').default;
-            this.$nextTick(() => {
-                self.colorPicker.initColorPicker();
-            });
-        },
-        methods: {
-            onClick(event) {
-                if (this.currentFunction !== undefined) {
-                    this.colorPicker.initColorPicker();
+import CVrangeSlider from '../../components/common/cv-range-slider'
+import CVSwitch from "@/components/common/cv-switch";
 
-                    let s = this.$store.getters.currentPipelineSettings;
-                    let hsvArray = this.colorPicker.colorPickerClick(event, this.currentFunction,
-                        [
-                                [s.hsvHue[0], s.hsvSaturation[0], s.hsvValue[0]],
-                                [s.hsvHue[1], s.hsvSaturation[1], s.hsvValue[1]]
-                        ].map(hsv => hsv.map(it => it || 0)));
-                    // That `map` calls are to make sure that we don't let any undefined/null values slip in
-                    this.currentFunction = undefined;
-                    this.$store.state.colorPicking = false;
-                    this.handlePipelineUpdate("outputShouldDraw", true);
-
-                    s.hsvHue = [hsvArray[0][0], hsvArray[1][0]];
-                    s.hsvSaturation = [hsvArray[0][1], hsvArray[1][1]];
-                    s.hsvValue = [hsvArray[0][2], hsvArray[1][2]];
-
-                    let msg = this.$msgPack.encode({
-                        "changePipelineSetting": {
-                            'hsvHue': s.hsvHue,
-                            'hsvSaturation': s.hsvSaturation,
-                            'hsvValue': s.hsvValue,
-                            'cameraIndex': this.$store.state.currentCameraIndex
-                        }
-                    });
-                    this.$socket.send(msg);
-                    this.$emit('update');
-                }
-            },
-            setFunction(index) {
-                switch (index) {
-                    case 0:
-                        this.currentFunction = undefined;
-                        this.$store.state.colorPicking = false;
-
-                        this.handlePipelineUpdate("outputShouldDraw", true);
-                        return;
-                    case 1:
-                        this.currentFunction = this.colorPicker.eyeDrop;
-                        break;
-                    case 2:
-                        this.currentFunction = this.colorPicker.expand;
-                        break;
-                    case 3:
-                        this.currentFunction = this.colorPicker.shrink;
-                        break;
-                }
-                this.$store.state.colorPicking = true;
-
-                this.handlePipelineUpdate("outputShouldDraw", false);
-                this.$store.commit("mutatePipeline", {"inputShouldShow": true});
-                this.handlePipelineUpdate("inputShouldShow", true);
-            }
-        }
+export default {
+  name: 'Threshold',
+  components: {
+    CVSwitch,
+    CVrangeSlider
+  },
+  // eslint-disable-next-line vue/require-prop-types
+  props: ['value'],
+  data() {
+    return {
+      currentFunction: undefined,
+      colorPicker: undefined,
+      showThresholdState: 0
     }
+  },
+  computed: {
+    hsvHue: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.hsvHue
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"hsvHue": val})
+      }
+    },
+    hsvSaturation: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.hsvSaturation
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"hsvSaturation": val})
+      }
+    },
+    hsvValue: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.hsvValue
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"hsvValue": val})
+      }
+    },
+    erode: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.erode
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"erode": val});
+      }
+    },
+    dilate: {
+      get() {
+        return this.$store.getters.currentPipelineSettings.dilate
+      },
+      set(val) {
+        this.$store.commit("mutatePipeline", {"dilate": val});
+      }
+    },
+  },
+  mounted: function () {
+    const self = this;
+    this.colorPicker = require('../../plugins/ColorPicker').default;
+    this.$nextTick(() => {
+      self.colorPicker.initColorPicker();
+    });
+  },
+  methods: {
+    onClick(event) {
+      if (this.currentFunction !== undefined) {
+        this.colorPicker.initColorPicker();
+
+        let s = this.$store.getters.currentPipelineSettings;
+        let hsvArray = this.colorPicker.colorPickerClick(event, this.currentFunction,
+            [
+              [s.hsvHue[0], s.hsvSaturation[0], s.hsvValue[0]],
+              [s.hsvHue[1], s.hsvSaturation[1], s.hsvValue[1]]
+            ].map(hsv => hsv.map(it => it || 0)));
+        // That `map` calls are to make sure that we don't let any undefined/null values slip in
+        this.currentFunction = undefined;
+        this.$store.state.colorPicking = false;
+        this.handlePipelineUpdate("outputShouldDraw", true);
+
+        s.hsvHue = [hsvArray[0][0], hsvArray[1][0]];
+        s.hsvSaturation = [hsvArray[0][1], hsvArray[1][1]];
+        s.hsvValue = [hsvArray[0][2], hsvArray[1][2]];
+
+        let msg = this.$msgPack.encode({
+          "changePipelineSetting": {
+            'hsvHue': s.hsvHue,
+            'hsvSaturation': s.hsvSaturation,
+            'hsvValue': s.hsvValue,
+            'cameraIndex': this.$store.state.currentCameraIndex
+          }
+        });
+        this.$socket.send(msg);
+        this.$emit('update');
+      }
+    },
+    setFunction(index) {
+      switch (index) {
+        case 0:
+          this.currentFunction = undefined;
+          this.$store.state.colorPicking = false;
+
+          this.handlePipelineUpdate("outputShouldDraw", true);
+          return;
+        case 1:
+          this.currentFunction = this.colorPicker.eyeDrop;
+          break;
+        case 2:
+          this.currentFunction = this.colorPicker.expand;
+          break;
+        case 3:
+          this.currentFunction = this.colorPicker.shrink;
+          break;
+      }
+      this.$store.state.colorPicking = true;
+
+      this.handlePipelineUpdate("outputShouldDraw", false);
+      this.$store.commit("mutatePipeline", {"inputShouldShow": true});
+      this.handlePipelineUpdate("inputShouldShow", true);
+    }
+  }
+}
 
 </script>
\ No newline at end of file
diff --git a/photon-core/src/main/java/org/photonvision/vision/camera/FileVisionSource.java b/photon-core/src/main/java/org/photonvision/vision/camera/FileVisionSource.java
index 25b874551..e089083fc 100644
--- a/photon-core/src/main/java/org/photonvision/vision/camera/FileVisionSource.java
+++ b/photon-core/src/main/java/org/photonvision/vision/camera/FileVisionSource.java
@@ -35,13 +35,17 @@ public class FileVisionSource extends VisionSource {
 
     public FileVisionSource(CameraConfiguration cameraConfiguration) {
         super(cameraConfiguration);
+        var calibration =
+                cameraConfiguration.calibrations.size() > 0
+                        ? cameraConfiguration.calibrations.get(0)
+                        : null;
         frameProvider =
                 new FileFrameProvider(
                         Path.of(cameraConfiguration.path),
                         cameraConfiguration.FOV,
                         FileFrameProvider.MAX_FPS,
                         cameraConfiguration.camPitch,
-                        cameraConfiguration.calibrations.get(0));
+                        calibration);
         settables =
                 new FileSourceSettables(cameraConfiguration, frameProvider.get().frameStaticProperties);
     }
diff --git a/photon-core/src/main/java/org/photonvision/vision/opencv/CVMat.java b/photon-core/src/main/java/org/photonvision/vision/opencv/CVMat.java
index be9103f1c..e58f0d11d 100644
--- a/photon-core/src/main/java/org/photonvision/vision/opencv/CVMat.java
+++ b/photon-core/src/main/java/org/photonvision/vision/opencv/CVMat.java
@@ -47,7 +47,7 @@ public class CVMat implements Releasable {
     private StringBuilder getStackTraceBuilder() {
         var trace = Thread.currentThread().getStackTrace();
 
-        final int STACK_FRAMES_TO_SKIP = 4;
+        final int STACK_FRAMES_TO_SKIP = 3;
         final var traceStr = new StringBuilder();
         for (int idx = STACK_FRAMES_TO_SKIP; idx < trace.length; idx++) {
             traceStr.append("\t\n").append(trace[idx]);
diff --git a/photon-core/src/main/java/org/photonvision/vision/opencv/CVShape.java b/photon-core/src/main/java/org/photonvision/vision/opencv/CVShape.java
index 2f04e946b..71f21cc1d 100644
--- a/photon-core/src/main/java/org/photonvision/vision/opencv/CVShape.java
+++ b/photon-core/src/main/java/org/photonvision/vision/opencv/CVShape.java
@@ -17,13 +17,18 @@
 
 package org.photonvision.vision.opencv;
 
+import org.jetbrains.annotations.Nullable;
 import org.opencv.core.MatOfPoint2f;
 import org.opencv.core.MatOfPoint3f;
-import org.opencv.imgproc.Imgproc;
+import org.opencv.core.Point;
 
-public class CVShape {
+public class CVShape implements Releasable {
     public final Contour contour;
-    public final ContourShape shape;
+
+    @Nullable public final ContourShape shape;
+
+    public double radius = 0;
+    public Point center = null;
 
     private MatOfPoint3f customTarget = null;
 
@@ -34,6 +39,12 @@ public class CVShape {
         this.shape = shape;
     }
 
+    public CVShape(Contour contour, Point center, double radius) {
+        this(contour, ContourShape.Circle);
+        this.radius = radius;
+        this.center = center;
+    }
+
     public CVShape(Contour contour, MatOfPoint3f targetPoints) {
         this.contour = contour;
         this.shape = ContourShape.Custom;
@@ -44,36 +55,10 @@ public class CVShape {
         return contour;
     }
 
-    public MatOfPoint2f getApproxPolyDp(double epsilon, boolean closed) {
+    @Override
+    public void release() {
+        if (customTarget != null) customTarget.release();
         approxCurve.release();
-        approxCurve = new MatOfPoint2f();
-
-        Imgproc.approxPolyDP(contour.getMat2f(), approxCurve, epsilon, closed);
-        return approxCurve;
-    }
-
-    public MatOfPoint2f getApproxPolyDpConvex(double epsilon, boolean closed) {
-        approxCurve.release();
-        approxCurve = new MatOfPoint2f();
-
-        Imgproc.approxPolyDP(contour.getConvexHull(), approxCurve, epsilon, closed);
-        return approxCurve;
-    }
-
-    boolean approxPolyMatchesShape() {
-        var pointList = approxCurve.toList();
-
-        // TODO: @Matt
-        switch (shape) {
-            case Custom:
-                break;
-            case Circle:
-                break;
-            case Triangle:
-                break;
-            case Quadrilateral:
-                break;
-        }
-        return true;
+        contour.release();
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/opencv/Contour.java b/photon-core/src/main/java/org/photonvision/vision/opencv/Contour.java
index edc0366f1..398e3c34d 100644
--- a/photon-core/src/main/java/org/photonvision/vision/opencv/Contour.java
+++ b/photon-core/src/main/java/org/photonvision/vision/opencv/Contour.java
@@ -18,6 +18,7 @@
 package org.photonvision.vision.opencv;
 
 import java.util.Comparator;
+import org.jetbrains.annotations.Nullable;
 import org.opencv.core.CvType;
 import org.opencv.core.MatOfInt;
 import org.opencv.core.MatOfPoint;
@@ -45,6 +46,7 @@ public class Contour implements Releasable {
     private Moments moments = null;
 
     private MatOfPoint2f convexHull = null;
+    private MatOfPoint2f approxPolyDp = null;
 
     public Contour(MatOfPoint mat) {
         this.mat = mat;
@@ -68,6 +70,19 @@ public class Contour implements Releasable {
         return convexHull;
     }
 
+    public MatOfPoint2f getApproxPolyDp(double epsilon, boolean closed) {
+        if (this.approxPolyDp == null) {
+            approxPolyDp = new MatOfPoint2f();
+            Imgproc.approxPolyDP(getConvexHull(), approxPolyDp, epsilon, closed);
+        }
+        return approxPolyDp;
+    }
+
+    @Nullable
+    public MatOfPoint2f getApproxPolyDp() {
+        return this.approxPolyDp;
+    }
+
     public double getArea() {
         if (Double.isNaN(area)) {
             area = Imgproc.contourArea(mat);
@@ -197,6 +212,7 @@ public class Contour implements Releasable {
         if (mat != null) mat.release();
         if (mat2f != null) mat2f.release();
         if (convexHull != null) convexHull.release();
+        if (approxPolyDp != null) approxPolyDp.release();
     }
 
     public static MatOfPoint2f convertIndexesToPoints(MatOfPoint contour, MatOfInt indexes) {
diff --git a/photon-core/src/main/java/org/photonvision/vision/opencv/ContourShape.java b/photon-core/src/main/java/org/photonvision/vision/opencv/ContourShape.java
index bb7d095f4..4eac4d847 100644
--- a/photon-core/src/main/java/org/photonvision/vision/opencv/ContourShape.java
+++ b/photon-core/src/main/java/org/photonvision/vision/opencv/ContourShape.java
@@ -21,8 +21,8 @@ import java.util.EnumSet;
 import java.util.HashMap;
 
 public enum ContourShape {
-    Custom(-1),
     Circle(0),
+    Custom(-1),
     Triangle(3),
     Quadrilateral(4);
 
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Collect2dTargetsPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Collect2dTargetsPipe.java
index 4d36cad58..19129d1eb 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Collect2dTargetsPipe.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Collect2dTargetsPipe.java
@@ -50,7 +50,7 @@ public class Collect2dTargetsPipe
                         params.frameStaticProperties);
 
         for (PotentialTarget target : in) {
-            targets.add(new TrackedTarget(target, calculationParams));
+            targets.add(new TrackedTarget(target, calculationParams, target.shape));
         }
 
         return targets;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dTargetsPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dTargetsPipe.java
index 5ed192846..cc8b79ec7 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dTargetsPipe.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/Draw2dTargetsPipe.java
@@ -27,6 +27,8 @@ import org.photonvision.common.logging.LogGroup;
 import org.photonvision.common.logging.Logger;
 import org.photonvision.common.util.ColorHelper;
 import org.photonvision.vision.frame.FrameDivisor;
+import org.photonvision.vision.opencv.CVShape;
+import org.photonvision.vision.opencv.ContourShape;
 import org.photonvision.vision.pipe.MutatingPipe;
 import org.photonvision.vision.target.TrackedTarget;
 
@@ -53,6 +55,7 @@ public class Draw2dTargetsPipe
             var centroidColour = ColorHelper.colorToScalar(params.centroidColor);
             var maximumBoxColour = ColorHelper.colorToScalar(params.maximumBoxColor);
             var rotatedBoxColour = ColorHelper.colorToScalar(params.rotatedBoxColor);
+            var circleColor = ColorHelper.colorToScalar(params.circleColor);
             var shapeColour = ColorHelper.colorToScalar(params.shapeOutlineColour);
 
             for (int i = 0; i < (params.showMultipleTargets ? in.getRight().size() : 1); i++) {
@@ -72,13 +75,35 @@ public class Draw2dTargetsPipe
                 dividePointArray(vertices);
                 contour.fromArray(vertices);
 
-                if (params.showRotatedBox) {
+                if (params.shouldShowRotatedBox(target.getShape())) {
                     Imgproc.drawContours(
                             in.getLeft(),
                             List.of(contour),
                             0,
                             rotatedBoxColour,
                             (int) Math.ceil(imageSize * params.kPixelsToBoxThickness));
+                } else if (params.shouldShowCircle(target.getShape())) {
+                    Imgproc.circle(
+                            in.getLeft(),
+                            target.getShape().center,
+                            (int) target.getShape().radius,
+                            circleColor,
+                            (int) Math.ceil(imageSize * params.kPixelsToBoxThickness));
+                } else {
+                    // draw approximate polygon
+                    var poly = target.getApproximateBoundingPolygon();
+
+                    // fall back on the shape's approx poly dp
+                    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());
+                        Imgproc.drawContours(
+                                in.getLeft(), List.of(mat), -1, ColorHelper.colorToScalar(Color.blue), 2);
+                        mat.release();
+                    }
                 }
 
                 if (params.showMaximumBox) {
@@ -193,12 +218,21 @@ public class Draw2dTargetsPipe
         public Color maximumBoxColor = Color.RED;
         public Color shapeOutlineColour = Color.MAGENTA;
         public Color textColor = Color.GREEN;
+        public Color circleColor = Color.RED;
 
         public final boolean showMultipleTargets;
         public final boolean shouldDraw;
 
         public final FrameDivisor divisor;
 
+        public boolean shouldShowRotatedBox(CVShape shape) {
+            return showRotatedBox && (shape == null || shape.shape.equals(ContourShape.Quadrilateral));
+        }
+
+        public boolean shouldShowCircle(CVShape shape) {
+            return shape != null && shape.shape.equals(ContourShape.Circle);
+        }
+
         public Draw2dTargetsParams(
                 boolean shouldDraw, boolean showMultipleTargets, FrameDivisor divisor) {
             this.shouldDraw = shouldDraw;
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FilterShapesPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FilterShapesPipe.java
index 8b779ccd6..651b93984 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FilterShapesPipe.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FilterShapesPipe.java
@@ -17,13 +17,18 @@
 
 package org.photonvision.vision.pipe.impl;
 
+import java.util.ArrayList;
 import java.util.List;
+import org.photonvision.vision.frame.FrameStaticProperties;
 import org.photonvision.vision.opencv.CVShape;
 import org.photonvision.vision.opencv.ContourShape;
 import org.photonvision.vision.pipe.CVPipe;
 
 public class FilterShapesPipe
         extends CVPipe<List<CVShape>, List<CVShape>, FilterShapesPipe.FilterShapesPipeParams> {
+
+    List<CVShape> outputList = new ArrayList<>();
+
     /**
     * Runs the process for the pipe.
     *
@@ -32,30 +37,50 @@ public class FilterShapesPipe
     */
     @Override
     protected List<CVShape> process(List<CVShape> in) {
-        in.removeIf(
-                shape ->
-                        shape.shape != params.desiredShape
-                                || shape.contour.getArea() > params.maxArea
-                                || shape.contour.getArea() < params.minArea
-                                || shape.contour.getPerimeter() > params.maxPeri
-                                || shape.contour.getPerimeter() < params.minPeri);
-        return in;
+        outputList.forEach(CVShape::release);
+        outputList.clear();
+        outputList = new ArrayList<>();
+
+        for (var shape : in) {
+            if (!shouldRemove(shape)) outputList.add(shape);
+        }
+
+        return outputList;
+    }
+
+    private boolean shouldRemove(CVShape shape) {
+        return shape.shape != params.desiredShape
+                || shape.contour.getArea() / params.getFrameStaticProperties().imageArea > params.maxArea
+                || shape.contour.getArea() / params.getFrameStaticProperties().imageArea < params.minArea
+                || shape.contour.getPerimeter() > params.maxPeri
+                || shape.contour.getPerimeter() < params.minPeri;
     }
 
     public static class FilterShapesPipeParams {
         private final ContourShape desiredShape;
+        private final FrameStaticProperties frameStaticProperties;
         private final double minArea;
         private final double maxArea;
         private final double minPeri;
         private final double maxPeri;
 
         public FilterShapesPipeParams(
-                ContourShape desiredShape, double minArea, double maxArea, double minPeri, double maxPeri) {
+                ContourShape desiredShape,
+                double minArea,
+                double maxArea,
+                double minPeri,
+                double maxPeri,
+                FrameStaticProperties frameStaticProperties) {
             this.desiredShape = desiredShape;
             this.minArea = minArea;
             this.maxArea = maxArea;
             this.minPeri = minPeri;
             this.maxPeri = maxPeri;
+            this.frameStaticProperties = frameStaticProperties;
+        }
+
+        public FrameStaticProperties getFrameStaticProperties() {
+            return frameStaticProperties;
         }
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FindCirclesPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FindCirclesPipe.java
index 7b60e6d62..1779e689f 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FindCirclesPipe.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FindCirclesPipe.java
@@ -21,11 +21,11 @@ import java.util.ArrayList;
 import java.util.List;
 import org.apache.commons.lang3.tuple.Pair;
 import org.opencv.core.Mat;
+import org.opencv.core.Point;
 import org.opencv.imgproc.Imgproc;
 import org.opencv.imgproc.Moments;
 import org.photonvision.vision.opencv.CVShape;
 import org.photonvision.vision.opencv.Contour;
-import org.photonvision.vision.opencv.ContourShape;
 import org.photonvision.vision.pipe.CVPipe;
 
 public class FindCirclesPipe
@@ -49,6 +49,10 @@ public class FindCirclesPipe
         circles.release();
         List<CVShape> output = new ArrayList<>();
 
+        var diag = params.diagonalLengthPx;
+        var minRadius = (int) (params.minRadius * diag / 100.0);
+        var maxRadius = (int) (params.maxRadius * diag / 100.0);
+
         Imgproc.HoughCircles(
                 in.getLeft(),
                 circles,
@@ -64,10 +68,15 @@ public class FindCirclesPipe
                 params.minDist,
                 params.maxCannyThresh,
                 params.accuracy,
-                params.minRadius,
-                params.maxRadius);
+                minRadius,
+                maxRadius);
         // Great, we now found the center point of the circle and it's radius, but we have no idea what
         // contour it corresponds to
+        // Each contour can only match to one circle, so we keep a list of unmatched contours around and
+        // only match against them
+        // This does mean that contours closer than allowableThreshold aren't matched to anything if
+        // there's a 'better' option
+        var unmatchedContours = in.getRight();
         for (int x = 0; x < circles.cols(); x++) {
             // Grab the current circle we are looking at
             double[] c = circles.get(0, x);
@@ -75,17 +84,26 @@ public class FindCirclesPipe
             double x_center = c[0];
             double y_center = c[1];
 
-            for (Contour contour : in.getRight()) {
+            for (Contour contour : unmatchedContours) {
                 // Grab the moments of the current contour
                 Moments mu = contour.getMoments();
                 // Determine if the contour is within the threshold of the detected circle
+                // NOTE: This means that the centroid of the contour must be within the "allowable
+                // threshold"
+                // of the center of the circle
                 if (Math.abs(x_center - (mu.m10 / mu.m00)) <= params.allowableThreshold
                         && Math.abs(y_center - (mu.m01 / mu.m00)) <= params.allowableThreshold) {
                     // If it is, then add it to the output array
-                    output.add(new CVShape(contour, ContourShape.Circle));
+                    output.add(new CVShape(contour, new Point(c[0], c[1]), c[2]));
+                    unmatchedContours.remove(contour);
+                    break;
                 }
             }
         }
+
+        // Release everything we don't use
+        for (var c : unmatchedContours) c.release();
+
         return output;
     }
 
@@ -96,6 +114,7 @@ public class FindCirclesPipe
         private final int minDist;
         private final int maxCannyThresh;
         private final int accuracy;
+        private final double diagonalLengthPx;
 
         /*
         * @params minDist - Minimum distance between the centers of the detected circles.
@@ -114,13 +133,15 @@ public class FindCirclesPipe
                 int minDist,
                 int maxRadius,
                 int maxCannyThresh,
-                int accuracy) {
+                int accuracy,
+                double diagonalLengthPx) {
             this.allowableThreshold = allowableThreshold;
             this.minRadius = minRadius;
             this.maxRadius = maxRadius;
             this.minDist = minDist;
             this.maxCannyThresh = maxCannyThresh;
             this.accuracy = accuracy;
+            this.diagonalLengthPx = diagonalLengthPx;
         }
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FindPolygonPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FindPolygonPipe.java
index d073b384c..4929ee5b6 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FindPolygonPipe.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/FindPolygonPipe.java
@@ -28,7 +28,7 @@ import org.photonvision.vision.pipe.CVPipe;
 
 public class FindPolygonPipe
         extends CVPipe<List<Contour>, List<CVShape>, FindPolygonPipe.FindPolygonPipeParams> {
-    private final MatOfPoint2f approx = new MatOfPoint2f();
+    List<CVShape> shapeList = new ArrayList<>();
 
     /*
     * Runs the process for the pipe.
@@ -38,18 +38,20 @@ public class FindPolygonPipe
     */
     @Override
     protected List<CVShape> process(List<Contour> in) {
-        // List containing all the output shapes
-        List<CVShape> output = new ArrayList<>();
+        shapeList.forEach(CVShape::release);
+        shapeList.clear();
+        shapeList = new ArrayList<>();
 
-        for (Contour contour : in) output.add(getShape(contour));
+        for (Contour contour : in) {
+            shapeList.add(getShape(contour));
+        }
 
-        return output;
+        return shapeList;
     }
 
     private CVShape getShape(Contour in) {
 
         int corners = getCorners(in);
-        corners = getCorners(in);
 
         /*The contourShape enum has predefined shapes for Circles, Triangles, and Quads
         meaning any shape not fitting in those predefined shapes must be a custom shape.
@@ -70,14 +72,11 @@ public class FindPolygonPipe
     }
 
     private int getCorners(Contour contour) {
-        // Release previous approx
-        approx.release();
-        Imgproc.approxPolyDP(
-                contour.getMat2f(),
-                approx,
-                // Converts an accuracy percentage between 1-100 to an epsilon
-                params.accuracyPercentage / 600.0 * Imgproc.arcLength(contour.getMat2f(), true),
-                true);
+        var approx =
+                contour.getApproxPolyDp(
+                        (100 - params.accuracyPercentage) / 100.0 * Imgproc.arcLength(contour.getMat2f(), true),
+                        true);
+
         // The height of the resultant approximation is the number of vertices
         return (int) approx.size().height;
     }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/SpeckleRejectPipe.java b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/SpeckleRejectPipe.java
index ec40610c8..c08a2cb8e 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipe/impl/SpeckleRejectPipe.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipe/impl/SpeckleRejectPipe.java
@@ -45,6 +45,8 @@ public class SpeckleRejectPipe
             for (Contour c : in) {
                 if (c.getArea() >= minAllowedArea) {
                     m_despeckledContours.add(c);
+                } else {
+                    c.release();
                 }
             }
         }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipeline.java
index 2401e364a..cdda47c43 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipeline.java
@@ -23,6 +23,8 @@ import java.util.stream.Collectors;
 import org.apache.commons.lang3.tuple.Pair;
 import org.opencv.core.Mat;
 import org.opencv.core.Point;
+import org.photonvision.common.util.math.MathUtils;
+import org.photonvision.raspi.PicamJNI;
 import org.photonvision.vision.frame.Frame;
 import org.photonvision.vision.opencv.*;
 import org.photonvision.vision.pipe.CVPipe.CVPipeResult;
@@ -38,13 +40,11 @@ public class ColoredShapePipeline
     private final RotateImagePipe rotateImagePipe = new RotateImagePipe();
     private final ErodeDilatePipe erodeDilatePipe = new ErodeDilatePipe();
     private final HSVPipe hsvPipe = new HSVPipe();
-    private final OutputMatPipe outputMatPipe = new OutputMatPipe();
     private final SpeckleRejectPipe speckleRejectPipe = new SpeckleRejectPipe();
     private final FindContoursPipe findContoursPipe = new FindContoursPipe();
     private final FindPolygonPipe findPolygonPipe = new FindPolygonPipe();
     private final FindCirclesPipe findCirclesPipe = new FindCirclesPipe();
     private final FilterShapesPipe filterShapesPipe = new FilterShapesPipe();
-    private final GroupContoursPipe groupContoursPipe = new GroupContoursPipe();
     private final SortContoursPipe sortContoursPipe = new SortContoursPipe();
     private final Collect2dTargetsPipe collect2dTargetsPipe = new Collect2dTargetsPipe();
     private final CornerDetectionPipe cornerDetectionPipe = new CornerDetectionPipe();
@@ -54,7 +54,6 @@ public class ColoredShapePipeline
     private final Draw3dTargetsPipe draw3dTargetsPipe = new Draw3dTargetsPipe();
     private final CalculateFPSPipe calculateFPSPipe = new CalculateFPSPipe();
 
-    private final Mat rawInputMat = new Mat();
     private final Point[] rectPoints = new Point[4];
 
     public ColoredShapePipeline() {
@@ -88,9 +87,6 @@ public class ColoredShapePipeline
                 new HSVPipe.HSVParams(settings.hsvHue, settings.hsvSaturation, settings.hsvValue);
         hsvPipe.setParams(hsvParams);
 
-        OutputMatPipe.OutputMatParams outputMatParams = new OutputMatPipe.OutputMatParams();
-        outputMatPipe.setParams(outputMatParams);
-
         SpeckleRejectPipe.SpeckleRejectParams speckleRejectParams =
                 new SpeckleRejectPipe.SpeckleRejectParams(settings.contourSpecklePercentage);
         speckleRejectPipe.setParams(speckleRejectParams);
@@ -105,28 +101,25 @@ public class ColoredShapePipeline
 
         FindCirclesPipe.FindCirclePipeParams findCirclePipeParams =
                 new FindCirclesPipe.FindCirclePipeParams(
-                        settings.allowableThreshold,
-                        settings.minRadius,
+                        settings.circleDetectThreshold,
+                        settings.contourRadius.getFirst(),
                         settings.minDist,
-                        settings.maxRadius,
+                        settings.contourRadius.getSecond(),
                         settings.maxCannyThresh,
-                        settings.accuracy);
+                        settings.circleAccuracy,
+                        Math.hypot(frameStaticProperties.imageWidth, frameStaticProperties.imageHeight));
         findCirclesPipe.setParams(findCirclePipeParams);
 
         FilterShapesPipe.FilterShapesPipeParams filterShapesPipeParams =
                 new FilterShapesPipe.FilterShapesPipeParams(
-                        settings.desiredShape,
-                        settings.minArea,
-                        settings.maxArea,
-                        settings.minPeri,
-                        settings.maxPeri);
+                        settings.contourShape,
+                        settings.contourArea.getFirst(),
+                        settings.contourArea.getSecond(),
+                        settings.contourPerimeter.getFirst(),
+                        settings.contourPerimeter.getSecond(),
+                        frameStaticProperties);
         filterShapesPipe.setParams(filterShapesPipeParams);
 
-        GroupContoursPipe.GroupContoursParams groupContoursParams =
-                new GroupContoursPipe.GroupContoursParams(
-                        settings.contourGroupingMode, settings.contourIntersection);
-        groupContoursPipe.setParams(groupContoursParams);
-
         SortContoursPipe.SortContoursParams sortContoursParams =
                 new SortContoursPipe.SortContoursParams(
                         settings.contourSortMode,
@@ -193,17 +186,41 @@ public class ColoredShapePipeline
     protected CVPipelineResult process(Frame frame, ColoredShapePipelineSettings settings) {
         long sumPipeNanosElapsed = 0L;
 
-        var rotateImageResult = rotateImagePipe.run(frame.image.getMat());
-        sumPipeNanosElapsed += rotateImageResult.nanosElapsed;
+        CVPipeResult<Mat> hsvPipeResult;
+        Mat rawInputMat;
+        if (frame.image.getMat().channels() != 1) {
+            var rotateImageResult = rotateImagePipe.run(frame.image.getMat());
+            sumPipeNanosElapsed = rotateImageResult.nanosElapsed;
 
-        rawInputMat.release();
-        frame.image.getMat().copyTo(rawInputMat);
+            rawInputMat = frame.image.getMat();
 
-        var erodeDilateResult = erodeDilatePipe.run(rawInputMat);
-        sumPipeNanosElapsed += erodeDilateResult.nanosElapsed;
+            hsvPipeResult = hsvPipe.run(rawInputMat);
+            sumPipeNanosElapsed += hsvPipeResult.nanosElapsed;
+        } else {
+            // Try to copy the color frame.
+            long inputMatPtr = PicamJNI.grabFrame(true);
+            if (inputMatPtr != 0) {
+                // If we grabbed it (in color copy mode), make a new Mat of it
+                rawInputMat = new Mat(inputMatPtr);
+            } else {
+                // Otherwise, the input mat is frame we got from the camera
+                rawInputMat = frame.image.getMat();
+            }
 
-        CVPipeResult<Mat> hsvPipeResult = hsvPipe.run(rawInputMat);
-        sumPipeNanosElapsed += hsvPipeResult.nanosElapsed;
+            // We can skip a few steps if the image is single channel because we've already done them on
+            // the GPU
+            hsvPipeResult = new CVPipeResult<>();
+            hsvPipeResult.output = frame.image.getMat();
+            hsvPipeResult.nanosElapsed = MathUtils.wpiNanoTime() - frame.timestampNanos;
+
+            sumPipeNanosElapsed += hsvPipeResult.nanosElapsed;
+        }
+
+        //        var erodeDilateResult = erodeDilatePipe.run(rawInputMat);
+        //        sumPipeNanosElapsed += erodeDilateResult.nanosElapsed;
+        //
+        //        CVPipeResult<Mat> hsvPipeResult = hsvPipe.run(rawInputMat);
+        //        sumPipeNanosElapsed += hsvPipeResult.nanosElapsed;
 
         CVPipeResult<List<Contour>> findContoursResult = findContoursPipe.run(hsvPipeResult.output);
         sumPipeNanosElapsed += findContoursResult.nanosElapsed;
@@ -212,8 +229,8 @@ public class ColoredShapePipeline
                 speckleRejectPipe.run(findContoursResult.output);
         sumPipeNanosElapsed += speckleRejectResult.nanosElapsed;
 
-        List<CVShape> shapes;
-        if (settings.desiredShape == ContourShape.Circle) {
+        List<CVShape> shapes = null;
+        if (settings.contourShape == ContourShape.Circle) {
             CVPipeResult<List<CVShape>> findCirclesResult =
                     findCirclesPipe.run(Pair.of(hsvPipeResult.output, speckleRejectResult.output));
             sumPipeNanosElapsed += findCirclesResult.nanosElapsed;
@@ -228,15 +245,11 @@ public class ColoredShapePipeline
         CVPipeResult<List<CVShape>> filterShapeResult = filterShapesPipe.run(shapes);
         sumPipeNanosElapsed += filterShapeResult.nanosElapsed;
 
-        CVPipeResult<List<PotentialTarget>> groupContoursResult =
-                groupContoursPipe.run(
-                        filterShapeResult.output.stream()
-                                .map(CVShape::getContour)
-                                .collect(Collectors.toList()));
-        sumPipeNanosElapsed += groupContoursResult.nanosElapsed;
-
         CVPipeResult<List<PotentialTarget>> sortContoursResult =
-                sortContoursPipe.run(groupContoursResult.output);
+                sortContoursPipe.run(
+                        filterShapeResult.output.stream()
+                                .map(shape -> new PotentialTarget(shape.getContour(), shape))
+                                .collect(Collectors.toList()));
         sumPipeNanosElapsed += sortContoursResult.nanosElapsed;
 
         CVPipeResult<List<TrackedTarget>> collect2dTargetsResult =
@@ -245,7 +258,7 @@ public class ColoredShapePipeline
 
         List<TrackedTarget> targetList;
 
-        if (settings.solvePNPEnabled && settings.desiredShape == ContourShape.Circle) {
+        if (settings.solvePNPEnabled && settings.contourShape == ContourShape.Circle) {
             var cornerDetectionResult = cornerDetectionPipe.run(collect2dTargetsResult.output);
             collect2dTargetsResult.output.forEach(
                     shape -> {
@@ -262,37 +275,6 @@ public class ColoredShapePipeline
             targetList = collect2dTargetsResult.output;
         }
 
-        // Draw 2D Crosshair on input and output
-        var draw2dCrosshairResultOnInput = draw2dCrosshairPipe.run(Pair.of(rawInputMat, targetList));
-        sumPipeNanosElapsed += draw2dCrosshairResultOnInput.nanosElapsed;
-
-        var draw2dCrosshairResultOnOutput =
-                draw2dCrosshairPipe.run(Pair.of(hsvPipeResult.output, targetList));
-        sumPipeNanosElapsed += draw2dCrosshairResultOnOutput.nanosElapsed;
-
-        // Draw 2D contours on input and output
-        var draw2dContoursResultOnInput =
-                draw2DTargetsPipe.run(Pair.of(rawInputMat, collect2dTargetsResult.output));
-        sumPipeNanosElapsed += draw2dContoursResultOnInput.nanosElapsed;
-
-        var draw2dContoursResultOnOutput =
-                draw2DTargetsPipe.run(Pair.of(hsvPipeResult.output, collect2dTargetsResult.output));
-        sumPipeNanosElapsed += draw2dContoursResultOnOutput.nanosElapsed;
-
-        if (settings.solvePNPEnabled && settings.desiredShape == ContourShape.Circle) {
-            var drawOnInputResult =
-                    draw3dTargetsPipe.run(Pair.of(rawInputMat, collect2dTargetsResult.output));
-            sumPipeNanosElapsed += drawOnInputResult.nanosElapsed;
-
-            var drawOnOutputResult =
-                    draw3dTargetsPipe.run(Pair.of(hsvPipeResult.output, collect2dTargetsResult.output));
-            sumPipeNanosElapsed += drawOnOutputResult.nanosElapsed;
-        }
-
-        // Convert single-channel HSV output mat to 3-channel BGR in preparation for streaming
-        var outputMatPipeResult = outputMatPipe.run(hsvPipeResult.output);
-        sumPipeNanosElapsed += outputMatPipeResult.nanosElapsed;
-
         var fpsResult = calculateFPSPipe.run(null);
         var fps = fpsResult.output;
 
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipelineSettings.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipelineSettings.java
index a8b816312..c1568f0f7 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipelineSettings.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/ColoredShapePipelineSettings.java
@@ -19,6 +19,8 @@ package org.photonvision.vision.pipeline;
 
 import com.fasterxml.jackson.annotation.JsonTypeName;
 import java.util.Objects;
+import org.photonvision.common.util.numbers.DoubleCouple;
+import org.photonvision.common.util.numbers.IntegerCouple;
 import org.photonvision.vision.calibration.CameraCalibrationCoefficients;
 import org.photonvision.vision.opencv.ContourGroupingMode;
 import org.photonvision.vision.opencv.ContourIntersectionDirection;
@@ -27,19 +29,15 @@ import org.photonvision.vision.pipe.impl.CornerDetectionPipe;
 
 @JsonTypeName("ColoredShapePipelineSettings")
 public class ColoredShapePipelineSettings extends AdvancedPipelineSettings {
-    public ContourShape desiredShape = ContourShape.Triangle;
-    public double minArea = Integer.MIN_VALUE;
-    public double maxArea = Integer.MAX_VALUE;
-    public double minPeri = Integer.MIN_VALUE;
-    public double maxPeri = Integer.MAX_VALUE;
+    public ContourShape contourShape = ContourShape.Triangle;
+    public DoubleCouple contourPerimeter = new DoubleCouple(0, Double.MAX_VALUE);
     public double accuracyPercentage = 10.0;
     // Circle detection
-    public int allowableThreshold = 5;
-    public int minRadius = 0;
-    public int maxRadius = 0;
-    public int minDist = 10;
+    public int circleDetectThreshold = 5;
+    public IntegerCouple contourRadius = new IntegerCouple(0, 100);
+    public int minDist = 20;
     public int maxCannyThresh = 90;
-    public int accuracy = 20;
+    public int circleAccuracy = 20;
     // how many contours to attempt to group (Single, Dual)
     public ContourGroupingMode contourGroupingMode = ContourGroupingMode.Single;
 
@@ -71,61 +69,50 @@ public class ColoredShapePipelineSettings extends AdvancedPipelineSettings {
         if (o == null || getClass() != o.getClass()) return false;
         if (!super.equals(o)) return false;
         ColoredShapePipelineSettings that = (ColoredShapePipelineSettings) o;
-        return Double.compare(that.minArea, minArea) == 0
-                && Double.compare(that.maxArea, maxArea) == 0
-                && Double.compare(that.minPeri, minPeri) == 0
-                && Double.compare(that.maxPeri, maxPeri) == 0
-                && Double.compare(that.accuracyPercentage, accuracyPercentage) == 0
-                && allowableThreshold == that.allowableThreshold
-                && minRadius == that.minRadius
-                && maxRadius == that.maxRadius
+        return Double.compare(that.accuracyPercentage, accuracyPercentage) == 0
+                && circleDetectThreshold == that.circleDetectThreshold
                 && minDist == that.minDist
                 && maxCannyThresh == that.maxCannyThresh
-                && accuracy == that.accuracy
-                && solvePNPEnabled == that.solvePNPEnabled
+                && circleAccuracy == that.circleAccuracy
                 && cornerDetectionUseConvexHulls == that.cornerDetectionUseConvexHulls
                 && cornerDetectionExactSideCount == that.cornerDetectionExactSideCount
                 && cornerDetectionSideCount == that.cornerDetectionSideCount
                 && Double.compare(that.cornerDetectionAccuracyPercentage, cornerDetectionAccuracyPercentage)
                         == 0
-                && desiredShape == that.desiredShape
+                && erode == that.erode
+                && dilate == that.dilate
+                && contourShape == that.contourShape
+                && Objects.equals(contourArea, that.contourArea)
+                && Objects.equals(contourPerimeter, that.contourPerimeter)
+                && Objects.equals(contourRadius, that.contourRadius)
                 && contourGroupingMode == that.contourGroupingMode
                 && contourIntersection == that.contourIntersection
                 && Objects.equals(cameraCalibration, that.cameraCalibration)
-                && Objects.equals(targetModel, that.targetModel)
-                && cornerDetectionStrategy == that.cornerDetectionStrategy
-                && erode == that.erode
-                && dilate == that.dilate;
+                && cornerDetectionStrategy == that.cornerDetectionStrategy;
     }
 
     @Override
     public int hashCode() {
         return Objects.hash(
                 super.hashCode(),
-                desiredShape,
-                minArea,
-                maxArea,
-                minPeri,
-                maxPeri,
+                contourShape,
+                contourArea,
+                contourPerimeter,
                 accuracyPercentage,
-                allowableThreshold,
-                minRadius,
-                maxRadius,
+                circleDetectThreshold,
+                contourRadius,
                 minDist,
                 maxCannyThresh,
-                accuracy,
+                circleAccuracy,
                 contourGroupingMode,
                 contourIntersection,
-                solvePNPEnabled,
                 cameraCalibration,
-                targetModel,
                 cornerDetectionStrategy,
                 cornerDetectionUseConvexHulls,
                 cornerDetectionExactSideCount,
                 cornerDetectionSideCount,
                 cornerDetectionAccuracyPercentage,
                 erode,
-                dilate,
-                accuracy);
+                dilate);
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/DriverModePipelineSettings.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/DriverModePipelineSettings.java
index 1adb89371..25911458e 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/DriverModePipelineSettings.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/DriverModePipelineSettings.java
@@ -20,11 +20,9 @@ package org.photonvision.vision.pipeline;
 import com.fasterxml.jackson.annotation.JsonTypeName;
 import org.photonvision.common.util.numbers.DoubleCouple;
 import org.photonvision.vision.processes.PipelineManager;
-import org.photonvision.vision.target.RobotOffsetPointMode;
 
 @JsonTypeName("DriverModePipelineSettings")
 public class DriverModePipelineSettings extends CVPipelineSettings {
-    public RobotOffsetPointMode offsetPointMode = RobotOffsetPointMode.None;
     public DoubleCouple offsetPoint = new DoubleCouple();
 
     public DriverModePipelineSettings() {
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java
index 780f673d6..6c5b92259 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/OutputStreamPipeline.java
@@ -22,6 +22,7 @@ import org.apache.commons.lang3.tuple.Pair;
 import org.photonvision.vision.frame.Frame;
 import org.photonvision.vision.frame.FrameStaticProperties;
 import org.photonvision.vision.opencv.CVMat;
+import org.photonvision.vision.opencv.ContourShape;
 import org.photonvision.vision.opencv.DualOffsetValues;
 import org.photonvision.vision.pipe.impl.*;
 import org.photonvision.vision.pipeline.result.CVPipelineResult;
@@ -108,7 +109,10 @@ public class OutputStreamPipeline {
         sumPipeNanosElapsed += pipeProfileNanos[4] = draw2dCrosshairResultOnOutput.nanosElapsed;
 
         // Draw 3D Targets on input and output if necessary
-        if (settings.solvePNPEnabled) {
+        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;
 
diff --git a/photon-core/src/main/java/org/photonvision/vision/pipeline/PipelineType.java b/photon-core/src/main/java/org/photonvision/vision/pipeline/PipelineType.java
index 6036b8404..28e497a1b 100644
--- a/photon-core/src/main/java/org/photonvision/vision/pipeline/PipelineType.java
+++ b/photon-core/src/main/java/org/photonvision/vision/pipeline/PipelineType.java
@@ -22,7 +22,7 @@ public enum PipelineType {
     Calib3d(-2, Calibrate3dPipeline.class),
     DriverMode(-1, DriverModePipeline.class),
     Reflective(0, ReflectivePipeline.class),
-    ColoredShape(0, ColoredShapePipeline.class);
+    ColoredShape(1, ColoredShapePipeline.class);
 
     public final int baseIndex;
     public final Class clazz;
diff --git a/photon-core/src/main/java/org/photonvision/vision/processes/PipelineManager.java b/photon-core/src/main/java/org/photonvision/vision/processes/PipelineManager.java
index 1644d25e4..3fe138f8b 100644
--- a/photon-core/src/main/java/org/photonvision/vision/processes/PipelineManager.java
+++ b/photon-core/src/main/java/org/photonvision/vision/processes/PipelineManager.java
@@ -18,6 +18,7 @@
 package org.photonvision.vision.processes;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
 import org.photonvision.common.configuration.CameraConfiguration;
@@ -243,23 +244,37 @@ public class PipelineManager {
     }
 
     public CVPipelineSettings addPipeline(PipelineType type, String nickname) {
+        var added = createSettingsForType(type, nickname);
+        if (added == null) {
+            logger.error("Cannot add null pipeline!");
+            return null;
+        }
+        addPipelineInternal(added);
+        reassignIndexes();
+        return added;
+    }
+
+    private CVPipelineSettings createSettingsForType(PipelineType type, String nickname) {
+        CVPipelineSettings newSettings;
         switch (type) {
             case Reflective:
                 {
                     var added = new ReflectivePipelineSettings();
                     added.pipelineNickname = nickname;
-                    addPipelineInternal(added);
                     return added;
                 }
             case ColoredShape:
                 {
                     var added = new ColoredShapePipelineSettings();
-                    addPipelineInternal(added);
+                    added.pipelineNickname = nickname;
                     return added;
                 }
+            default:
+                {
+                    logger.error("Got invalid pipeline type: " + type.toString());
+                    return null;
+                }
         }
-        reassignIndexes();
-        return null;
     }
 
     private void addPipelineInternal(CVPipelineSettings settings) {
@@ -268,30 +283,41 @@ public class PipelineManager {
         reassignIndexes();
     }
 
-    private void removePipelineInternal(int index) {
+    /**
+    * Remove a pipeline settings at the given index and return the new current index
+    *
+    * @param index The idx to remove
+    */
+    private int removePipelineInternal(int index) {
         userPipelineSettings.remove(index);
         currentPipelineIndex = Math.min(index, userPipelineSettings.size() - 1);
         reassignIndexes();
+        return currentPipelineIndex;
     }
 
     public void setIndex(int index) {
         this.setPipelineInternal(index);
     }
 
-    public void removePipeline(int index) {
+    public int removePipeline(int index) {
         if (index < 0) {
-            return;
+            return currentPipelineIndex;
         }
         // TODO should we block/lock on a mutex?
-        removePipelineInternal(index);
-        setIndex(currentPipelineIndex);
+        return removePipelineInternal(index);
     }
 
     public void renameCurrentPipeline(String newName) {
         getCurrentPipelineSettings().pipelineNickname = newName;
     }
 
-    public void duplicatePipeline(int index) {
+    /**
+    * Duplicate a pipeline at a given index
+    *
+    * @param index the index of the target pipeline
+    * @return The new index
+    */
+    public int duplicatePipeline(int index) {
         var settings = userPipelineSettings.get(index);
         var newSettings = settings.clone();
         newSettings.pipelineNickname =
@@ -300,24 +326,81 @@ public class PipelineManager {
         logger.debug("Duplicating pipe " + index + " to " + newSettings.pipelineNickname);
         userPipelineSettings.add(newSettings);
         reassignIndexes();
+
+        // Now we look for the index of the new pipeline and return it
+        return userPipelineSettings.indexOf(newSettings);
     }
 
     private static String createUniqueName(
             String nickname, List<CVPipelineSettings> existingSettings) {
-        int index = 0;
         String uniqueName = nickname;
         while (true) {
-            String finalUniqueName = uniqueName;
+            String finalUniqueName = uniqueName; // To get around lambda capture
             var conflictingName =
                     existingSettings.stream().anyMatch(it -> it.pipelineNickname.equals(finalUniqueName));
-            if (!conflictingName) return uniqueName;
-            index++;
-            uniqueName = nickname + " (" + index + ")";
 
-            if (index == 6
-                    && existingSettings.stream()
-                            .noneMatch(it -> it.pipelineNickname.equals(nickname + "( dQw4w9WgXcQ )")))
-                return nickname + "( dQw4w9WgXcQ )";
+            if (!conflictingName) {
+                // If no conflict, we're done
+                return uniqueName;
+            } else {
+                // Otherwise, we need to add a suffix to the name
+                // If the string doesn't already end in "([0-9]*)", we'll add it
+                // If it does, we'll increment the number in the suffix
+
+                if (uniqueName.matches(".*\\([0-9]*\\)")) {
+                    // Because java strings are immutable, we have to do this curstedness
+                    // This is like doing "New pipeline (" + 2 + ")"
+
+                    var parenStart = uniqueName.lastIndexOf('(');
+                    var parenEnd = uniqueName.length() - 1;
+                    var number = Integer.parseInt(uniqueName.substring(parenStart + 1, parenEnd)) + 1;
+
+                    uniqueName = uniqueName.substring(0, parenStart + 1) + number + ")";
+                } else {
+                    uniqueName += " (1)";
+                }
+            }
         }
     }
+
+    public void changePipelineType(int newType) {
+        // Find the PipelineType proposed
+        // To do this we look at all the PipelineType entries and look for one with matching
+        // base indexes
+        PipelineType type =
+                Arrays.stream(PipelineType.values())
+                        .filter(it -> it.baseIndex == newType)
+                        .findAny()
+                        .orElse(null);
+        if (type == null) {
+            logger.error("Could not match type " + newType + " to a PipelineType!");
+            return;
+        }
+
+        if (type.baseIndex == getCurrentPipelineSettings().pipelineType.baseIndex) {
+            logger.debug(
+                    "Not changing settings as "
+                            + type
+                            + " and "
+                            + getCurrentPipelineSettings().pipelineType
+                            + " are identical!");
+            return;
+        }
+
+        // Our new settings will be totally nuked, but that's ok
+        // We *could* set things in common between the two, if we want
+        // But they're different enough it shouldn't be an issue
+        var name = getCurrentPipelineSettings().pipelineNickname;
+        var newSettings = createSettingsForType(type, name);
+
+        var idx = currentPipelineIndex;
+        if (idx < 0) {
+            logger.error("Cannot replace non-user pipeline!");
+            return;
+        }
+
+        logger.info("Adding new pipe of type " + type.toString() + " at idx " + idx);
+        userPipelineSettings.set(idx, newSettings);
+        setPipelineInternal(idx);
+    }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java b/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java
index a0142dd84..803f2f460 100644
--- a/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java
+++ b/photon-core/src/main/java/org/photonvision/vision/processes/VisionModule.java
@@ -257,11 +257,15 @@ public class VisionModule {
                     try {
                         var osr = outputStreamPipeline.process(inputFrame, outputFrame, settings, targets);
                         consumeFpsLimitedResult(osr);
+                    } catch (Exception e) {
+                        // Never die
+                        logger.error("Exception while running stream runnable!", e);
+                    }
+                    try {
                         inputFrame.release();
                         outputFrame.release();
                     } catch (Exception e) {
-                        // Never die
-                        logger.error("Exception in stream runnable!", e);
+                        logger.error("Exception freeing frames", e);
                     }
                 } else {
                     // busy wait! hurray!
diff --git a/photon-core/src/main/java/org/photonvision/vision/processes/VisionModuleChangeSubscriber.java b/photon-core/src/main/java/org/photonvision/vision/processes/VisionModuleChangeSubscriber.java
index 4707426af..1966a40f8 100644
--- a/photon-core/src/main/java/org/photonvision/vision/processes/VisionModuleChangeSubscriber.java
+++ b/photon-core/src/main/java/org/photonvision/vision/processes/VisionModuleChangeSubscriber.java
@@ -89,7 +89,8 @@ public class VisionModuleChangeSubscriber extends DataChangeSubscriber {
                     case "deleteCurrPipeline":
                         var indexToDelete = parentModule.pipelineManager.getCurrentPipelineIndex();
                         logger.info("Deleting current pipe at index " + indexToDelete);
-                        parentModule.pipelineManager.removePipeline(indexToDelete);
+                        int newIndex = parentModule.pipelineManager.removePipeline(indexToDelete);
+                        parentModule.setPipeline(newIndex);
                         parentModule.saveAndBroadcastAll();
                         return;
                     case "changePipeline": // change active pipeline
@@ -110,7 +111,8 @@ public class VisionModuleChangeSubscriber extends DataChangeSubscriber {
                         parentModule.takeCalibrationSnapshot();
                         return;
                     case "duplicatePipeline":
-                        parentModule.pipelineManager.duplicatePipeline((Integer) newPropValue);
+                        int idx = parentModule.pipelineManager.duplicatePipeline((Integer) newPropValue);
+                        parentModule.setPipeline(idx);
                         parentModule.saveAndBroadcastAll();
                         return;
                     case "robotOffsetPoint":
@@ -154,6 +156,10 @@ public class VisionModuleChangeSubscriber extends DataChangeSubscriber {
                             }
                         }
                         return;
+                    case "changePipelineType":
+                        parentModule.pipelineManager.changePipelineType((Integer) newPropValue);
+                        parentModule.saveAndBroadcastAll();
+                        return;
                 }
 
                 // special case for camera settables
@@ -183,8 +189,8 @@ public class VisionModuleChangeSubscriber extends DataChangeSubscriber {
                         var actual = new DoubleCouple(orig.get(0), orig.get(1));
                         propField.set(currentSettings, actual);
                     } else if (propType.isAssignableFrom(IntegerCouple.class)) {
-                        var orig = (ArrayList<Integer>) newPropValue;
-                        var actual = new IntegerCouple(orig.get(0), orig.get(1));
+                        var orig = (ArrayList<Number>) newPropValue;
+                        var actual = new IntegerCouple(orig.get(0).intValue(), orig.get(1).intValue());
                         propField.set(currentSettings, actual);
                     } else if (propType.equals(Double.TYPE)) {
                         propField.setDouble(currentSettings, ((Number) newPropValue).doubleValue());
diff --git a/photon-core/src/main/java/org/photonvision/vision/processes/VisionSourceManager.java b/photon-core/src/main/java/org/photonvision/vision/processes/VisionSourceManager.java
index 8109f5821..49b5f54b1 100644
--- a/photon-core/src/main/java/org/photonvision/vision/processes/VisionSourceManager.java
+++ b/photon-core/src/main/java/org/photonvision/vision/processes/VisionSourceManager.java
@@ -22,6 +22,7 @@ import edu.wpi.cscore.UsbCameraInfo;
 import java.util.*;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 import org.photonvision.common.configuration.CameraConfiguration;
 import org.photonvision.common.configuration.ConfigManager;
 import org.photonvision.common.dataflow.DataChangeService;
@@ -144,6 +145,11 @@ public class VisionSourceManager {
                             "After matching, "
                                     + unmatchedLoadedConfigs.size()
                                     + " configs remained unmatched. Is your camera disconnected?");
+            logger.warn(
+                    "Unloaded configs: "
+                            + unmatchedLoadedConfigs.stream()
+                                    .map(it -> it.nickname)
+                                    .collect(Collectors.joining()));
             hasWarned = true;
         }
 
diff --git a/photon-core/src/main/java/org/photonvision/vision/target/PotentialTarget.java b/photon-core/src/main/java/org/photonvision/vision/target/PotentialTarget.java
index 40f690a5b..5e1ae399e 100644
--- a/photon-core/src/main/java/org/photonvision/vision/target/PotentialTarget.java
+++ b/photon-core/src/main/java/org/photonvision/vision/target/PotentialTarget.java
@@ -20,6 +20,7 @@ package org.photonvision.vision.target;
 import java.util.ArrayList;
 import java.util.List;
 import org.opencv.core.RotatedRect;
+import org.photonvision.vision.opencv.CVShape;
 import org.photonvision.vision.opencv.Contour;
 import org.photonvision.vision.opencv.Releasable;
 
@@ -27,15 +28,24 @@ public class PotentialTarget implements Releasable {
 
     public final Contour m_mainContour;
     public final List<Contour> m_subContours;
+    public final CVShape shape;
 
     public PotentialTarget(Contour inputContour) {
-        m_mainContour = inputContour;
-        m_subContours = new ArrayList<>(); // empty
+        this(inputContour, List.of());
     }
 
     public PotentialTarget(Contour inputContour, List<Contour> subContours) {
+        this(inputContour, subContours, null);
+    }
+
+    public PotentialTarget(Contour inputContour, List<Contour> subContours, CVShape shape) {
         m_mainContour = inputContour;
         m_subContours = new ArrayList<>(subContours);
+        this.shape = shape;
+    }
+
+    public PotentialTarget(Contour inputContour, CVShape shape) {
+        this(inputContour, List.of(), shape);
     }
 
     public RotatedRect getMinAreaRect() {
@@ -53,5 +63,6 @@ public class PotentialTarget implements Releasable {
             sc.release();
         }
         m_subContours.clear();
+        if (shape != null) shape.release();
     }
 }
diff --git a/photon-core/src/main/java/org/photonvision/vision/target/TrackedTarget.java b/photon-core/src/main/java/org/photonvision/vision/target/TrackedTarget.java
index 6dc452e21..333ec0f56 100644
--- a/photon-core/src/main/java/org/photonvision/vision/target/TrackedTarget.java
+++ b/photon-core/src/main/java/org/photonvision/vision/target/TrackedTarget.java
@@ -25,9 +25,7 @@ import org.opencv.core.MatOfPoint2f;
 import org.opencv.core.Point;
 import org.opencv.core.RotatedRect;
 import org.photonvision.vision.frame.FrameStaticProperties;
-import org.photonvision.vision.opencv.Contour;
-import org.photonvision.vision.opencv.DualOffsetValues;
-import org.photonvision.vision.opencv.Releasable;
+import org.photonvision.vision.opencv.*;
 
 public class TrackedTarget implements Releasable {
     public final Contour m_mainContour;
@@ -47,11 +45,15 @@ public class TrackedTarget implements Releasable {
 
     private Transform2d m_cameraToTarget = new Transform2d();
 
+    private CVShape m_shape;
+
     private Mat m_cameraRelativeTvec, m_cameraRelativeRvec;
 
-    public TrackedTarget(PotentialTarget origTarget, TargetCalculationParameters params) {
+    public TrackedTarget(
+            PotentialTarget origTarget, TargetCalculationParameters params, CVShape shape) {
         this.m_mainContour = origTarget.m_mainContour;
         this.m_subContours = origTarget.m_subContours;
+        this.m_shape = shape;
         calculateValues(params);
     }
 
@@ -170,13 +172,15 @@ public class TrackedTarget implements Releasable {
         cameraRelativeRvec.copyTo(this.m_cameraRelativeRvec);
     }
 
+    public CVShape getShape() {
+        return m_shape;
+    }
+
+    public void setShape(CVShape shape) {
+        this.m_shape = shape;
+    }
+
     public HashMap<String, Object> toHashMap() {
-        //                pitch: 0,
-        //                    yaw: 0,
-        //                    skew: 0,
-        //                    area: 0,
-        //                    // 3D only
-        //                    pose: {x: 0, y: 0, rot: 0},
         var ret = new HashMap<String, Object>();
         ret.put("pitch", getPitch());
         ret.put("yaw", getYaw());
diff --git a/photon-core/src/test/java/org/photonvision/common/ShapeBenchmarkTest.java b/photon-core/src/test/java/org/photonvision/common/ShapeBenchmarkTest.java
index 7f4174eda..062a67b2c 100644
--- a/photon-core/src/test/java/org/photonvision/common/ShapeBenchmarkTest.java
+++ b/photon-core/src/test/java/org/photonvision/common/ShapeBenchmarkTest.java
@@ -68,8 +68,8 @@ public class ShapeBenchmarkTest {
         pipeline.getSettings().outputShowMultipleTargets = true;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
-        pipeline.getSettings().desiredShape = ContourShape.Custom;
-        pipeline.getSettings().allowableThreshold = 10;
+        pipeline.getSettings().contourShape = ContourShape.Custom;
+        pipeline.getSettings().circleDetectThreshold = 10;
         pipeline.getSettings().accuracyPercentage = 30.0;
         var frameProvider =
                 new FileFrameProvider(
@@ -89,8 +89,8 @@ public class ShapeBenchmarkTest {
         pipeline.getSettings().outputShowMultipleTargets = true;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
-        pipeline.getSettings().desiredShape = ContourShape.Custom;
-        pipeline.getSettings().allowableThreshold = 10;
+        pipeline.getSettings().contourShape = ContourShape.Custom;
+        pipeline.getSettings().circleDetectThreshold = 10;
         pipeline.getSettings().accuracyPercentage = 30.0;
 
         var frameProvider =
@@ -111,8 +111,8 @@ public class ShapeBenchmarkTest {
         pipeline.getSettings().outputShowMultipleTargets = true;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
-        pipeline.getSettings().desiredShape = ContourShape.Custom;
-        pipeline.getSettings().allowableThreshold = 10;
+        pipeline.getSettings().contourShape = ContourShape.Custom;
+        pipeline.getSettings().circleDetectThreshold = 10;
         pipeline.getSettings().accuracyPercentage = 30.0;
 
         var frameProvider =
@@ -133,8 +133,8 @@ public class ShapeBenchmarkTest {
         pipeline.getSettings().outputShowMultipleTargets = true;
         pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
         pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
-        pipeline.getSettings().desiredShape = ContourShape.Custom;
-        pipeline.getSettings().allowableThreshold = 10;
+        pipeline.getSettings().contourShape = ContourShape.Custom;
+        pipeline.getSettings().circleDetectThreshold = 10;
         pipeline.getSettings().accuracyPercentage = 30.0;
 
         var frameProvider =
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/CirclePNPTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/CirclePNPTest.java
index 528b13535..c38433d8c 100644
--- a/photon-core/src/test/java/org/photonvision/vision/pipeline/CirclePNPTest.java
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/CirclePNPTest.java
@@ -19,6 +19,7 @@ package org.photonvision.vision.pipeline;
 
 import static org.junit.jupiter.api.Assertions.*;
 
+import edu.wpi.first.wpilibj.geometry.Rotation2d;
 import java.util.stream.Collectors;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -30,7 +31,9 @@ import org.photonvision.vision.frame.provider.FileFrameProvider;
 import org.photonvision.vision.opencv.CVMat;
 import org.photonvision.vision.opencv.ContourGroupingMode;
 import org.photonvision.vision.opencv.ContourIntersectionDirection;
+import org.photonvision.vision.opencv.ContourShape;
 import org.photonvision.vision.pipeline.result.CVPipelineResult;
+import org.photonvision.vision.target.TargetModel;
 import org.photonvision.vision.target.TrackedTarget;
 
 public class CirclePNPTest {
@@ -80,46 +83,43 @@ public class CirclePNPTest {
         assertEquals(5, cameraCalibration.getCameraExtrinsicsMat().cols());
     }
 
-    //    @Test
-    //    public void testCircle() {
-    //        var pipeline = new ColoredShapePipeline();
-    //
-    //        pipeline.getSettings().hsvHue.set(0, 100);
-    //        pipeline.getSettings().hsvSaturation.set(100, 255);
-    //        pipeline.getSettings().hsvValue.set(100, 255);
-    //        pipeline.getSettings().outputShouldDraw = true;
-    //        pipeline.getSettings().maxCannyThresh = 50;
-    //        pipeline.getSettings().accuracy = 15;
-    //        pipeline.getSettings().allowableThreshold = 5;
-    //        pipeline.getSettings().solvePNPEnabled = true;
-    //        pipeline.getSettings().cornerDetectionAccuracyPercentage = 4;
-    //        pipeline.getSettings().cornerDetectionUseConvexHulls = true;
-    //        pipeline.getSettings().cameraCalibration = getCoeffs(LIFECAM_480P_CAL_FILE);
-    //        pipeline.getSettings().targetModel = TargetModel.kCircularPowerCell7in;
-    //        pipeline.getSettings().outputShouldDraw = true;
-    //        pipeline.getSettings().outputShowMultipleTargets = false;
-    //        pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
-    //        pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
-    //        pipeline.getSettings().desiredShape = ContourShape.Circle;
-    //        pipeline.getSettings().allowableThreshold = 10;
-    //        pipeline.getSettings().minRadius = 30;
-    //        pipeline.getSettings().accuracyPercentage = 30.0;
-    //
-    //        var frameProvider =
-    //                new FileFrameProvider(
-    //
-    // TestUtils.getPowercellImagePath(TestUtils.PowercellTestImages.kPowercell_test_6, false),
-    //                        TestUtils.WPI2020Image.FOV,
-    //                        new Rotation2d(),
-    //                        TestUtils.get2020LifeCamCoeffs(false));
-    //
-    //        CVPipelineResult pipelineResult = pipeline.run(frameProvider.get(),
-    // QuirkyCamera.DefaultCamera);
-    //        printTestResults(pipelineResult);
-    //
-    //        TestUtils.showImage(pipelineResult.outputFrame.image.getMat(), "Pipeline output",
-    // 999999);
-    //    }
+    @Test
+    public void testCircle() {
+        var pipeline = new ColoredShapePipeline();
+
+        pipeline.getSettings().hsvHue.set(0, 100);
+        pipeline.getSettings().hsvSaturation.set(100, 255);
+        pipeline.getSettings().hsvValue.set(100, 255);
+        pipeline.getSettings().outputShouldDraw = true;
+        pipeline.getSettings().maxCannyThresh = 50;
+        pipeline.getSettings().circleAccuracy = 15;
+        pipeline.getSettings().circleDetectThreshold = 5;
+        pipeline.getSettings().solvePNPEnabled = true;
+        pipeline.getSettings().cornerDetectionAccuracyPercentage = 4;
+        pipeline.getSettings().cornerDetectionUseConvexHulls = true;
+        pipeline.getSettings().cameraCalibration = getCoeffs(LIFECAM_480P_CAL_FILE);
+        pipeline.getSettings().targetModel = TargetModel.kCircularPowerCell7in;
+        pipeline.getSettings().outputShouldDraw = true;
+        pipeline.getSettings().outputShowMultipleTargets = false;
+        pipeline.getSettings().contourGroupingMode = ContourGroupingMode.Single;
+        pipeline.getSettings().contourIntersection = ContourIntersectionDirection.Up;
+        pipeline.getSettings().contourShape = ContourShape.Circle;
+        pipeline.getSettings().circleDetectThreshold = 10;
+        pipeline.getSettings().contourRadius.setFirst(30);
+        pipeline.getSettings().accuracyPercentage = 30.0;
+
+        var frameProvider =
+                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);
+        printTestResults(pipelineResult);
+
+        TestUtils.showImage(pipelineResult.outputFrame.image.getMat(), "Pipeline output", 999999);
+    }
 
     private static void continuouslyRunPipeline(Frame frame, ReflectivePipelineSettings settings) {
         var pipeline = new ReflectivePipeline();
diff --git a/photon-core/src/test/java/org/photonvision/vision/pipeline/ColoredShapePipelineTest.java b/photon-core/src/test/java/org/photonvision/vision/pipeline/ColoredShapePipelineTest.java
index c7a8ba2e6..c774a43ad 100644
--- a/photon-core/src/test/java/org/photonvision/vision/pipeline/ColoredShapePipelineTest.java
+++ b/photon-core/src/test/java/org/photonvision/vision/pipeline/ColoredShapePipelineTest.java
@@ -17,6 +17,7 @@
 
 package org.photonvision.vision.pipeline;
 
+import org.junit.jupiter.api.Test;
 import org.photonvision.common.util.TestUtils;
 import org.photonvision.vision.camera.QuirkyCamera;
 import org.photonvision.vision.frame.Frame;
@@ -39,7 +40,7 @@ public class ColoredShapePipelineTest {
 
     public static void testQuadrilateralDetection(
             ColoredShapePipeline pipeline, ColoredShapePipelineSettings settings, Frame frame) {
-        settings.desiredShape = ContourShape.Quadrilateral;
+        settings.contourShape = ContourShape.Quadrilateral;
         pipeline.settings = settings;
         CVPipelineResult colouredShapePipelineResult = pipeline.run(frame, QuirkyCamera.DefaultCamera);
         TestUtils.showImage(
@@ -49,7 +50,7 @@ public class ColoredShapePipelineTest {
 
     public static void testCustomShapeDetection(
             ColoredShapePipeline pipeline, ColoredShapePipelineSettings settings, Frame frame) {
-        settings.desiredShape = ContourShape.Custom;
+        settings.contourShape = ContourShape.Custom;
         pipeline.settings = settings;
         CVPipelineResult colouredShapePipelineResult = pipeline.run(frame, QuirkyCamera.DefaultCamera);
         TestUtils.showImage(
@@ -57,36 +58,33 @@ public class ColoredShapePipelineTest {
         printTestResults(colouredShapePipelineResult);
     }
 
-    //    @Test
-    //    public static void testCircleShapeDetection(
-    //            ColoredShapePipeline pipeline, ColoredShapePipelineSettings settings, Frame frame) {
-    //        settings.desiredShape = ContourShape.Circle;
-    //        pipeline.settings = settings;
-    //        CVPipelineResult colouredShapePipelineResult = pipeline.run(frame,
-    // QuirkyCamera.DefaultCamera);
-    //        TestUtils.showImage(
-    //                colouredShapePipelineResult.outputFrame.image.getMat(), "Pipeline output:
-    // Circle.");
-    //        printTestResults(colouredShapePipelineResult);
-    //    }
-    //
-    //    @Test
-    //    public static void testPowercellDetection(
-    //            ColoredShapePipelineSettings settings, ColoredShapePipeline pipeline) {
-    //
-    //        settings.hsvHue.set(10, 40);
-    //        settings.hsvSaturation.set(100, 255);
-    //        settings.hsvValue.set(100, 255);
-    //        settings.maxCannyThresh = 50;
-    //        settings.accuracy = 15;
-    //        settings.allowableThreshold = 5;
-    //        var frameProvider =
-    //                new FileFrameProvider(
-    //
-    // TestUtils.getPowercellImagePath(TestUtils.PowercellTestImages.kPowercell_test_6, false),
-    //                        TestUtils.WPI2019Image.FOV);
-    //        testCircleShapeDetection(pipeline, settings, frameProvider.get());
-    //    }
+    @Test
+    public static void testCircleShapeDetection(
+            ColoredShapePipeline pipeline, ColoredShapePipelineSettings settings, Frame frame) {
+        settings.contourShape = ContourShape.Circle;
+        pipeline.settings = settings;
+        CVPipelineResult colouredShapePipelineResult = pipeline.run(frame, QuirkyCamera.DefaultCamera);
+        TestUtils.showImage(
+                colouredShapePipelineResult.outputFrame.image.getMat(), "Pipeline output: Circle.");
+        printTestResults(colouredShapePipelineResult);
+    }
+
+    @Test
+    public static void testPowercellDetection(
+            ColoredShapePipelineSettings settings, ColoredShapePipeline pipeline) {
+
+        settings.hsvHue.set(10, 40);
+        settings.hsvSaturation.set(100, 255);
+        settings.hsvValue.set(100, 255);
+        settings.maxCannyThresh = 50;
+        settings.circleAccuracy = 15;
+        settings.circleDetectThreshold = 5;
+        var frameProvider =
+                new FileFrameProvider(
+                        TestUtils.getPowercellImagePath(TestUtils.PowercellTestImages.kPowercell_test_6, false),
+                        TestUtils.WPI2019Image.FOV);
+        testCircleShapeDetection(pipeline, settings, frameProvider.get());
+    }
 
     public static void main(String[] args) {
         TestUtils.loadLibraries();
@@ -104,8 +102,8 @@ public class ColoredShapePipelineTest {
         settings.outputShowMultipleTargets = true;
         settings.contourGroupingMode = ContourGroupingMode.Single;
         settings.contourIntersection = ContourIntersectionDirection.Up;
-        settings.desiredShape = ContourShape.Triangle;
-        settings.allowableThreshold = 10;
+        settings.contourShape = ContourShape.Triangle;
+        settings.circleDetectThreshold = 10;
         settings.accuracyPercentage = 30.0;
 
         ColoredShapePipeline pipeline = new ColoredShapePipeline();
diff --git a/photon-core/src/test/java/org/photonvision/vision/processes/PipelineManagerTest.java b/photon-core/src/test/java/org/photonvision/vision/processes/PipelineManagerTest.java
new file mode 100644
index 000000000..30fbf74f0
--- /dev/null
+++ b/photon-core/src/test/java/org/photonvision/vision/processes/PipelineManagerTest.java
@@ -0,0 +1,62 @@
+/*
+ * 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.processes;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.photonvision.common.util.TestUtils;
+import org.photonvision.vision.pipeline.DriverModePipelineSettings;
+import org.photonvision.vision.pipeline.PipelineType;
+
+public class PipelineManagerTest {
+
+    @Test
+    public void testUniqueName() {
+        TestUtils.loadLibraries();
+        PipelineManager manager = new PipelineManager(new DriverModePipelineSettings(), List.of());
+        manager.addPipeline(PipelineType.Reflective, "Another");
+
+        // We now have ["New Pipeline", "Another"]
+        // After we duplicate 0 and 1, we expect ["New Pipeline", "Another", "New Pipeline (1)",
+        // "Another (1)"]
+        manager.duplicatePipeline(0);
+        manager.duplicatePipeline(1);
+
+        // Should add "Another (2)"
+        manager.duplicatePipeline(3);
+        // Should add "Another (3)
+        manager.duplicatePipeline(3);
+        // Should add "Another (4)
+        manager.duplicatePipeline(1);
+
+        // Should add "Another (5)" through "Another (15)"
+        for (int i = 5; i < 15; i++) {
+            manager.duplicatePipeline(1);
+        }
+
+        var nicks = manager.getPipelineNicknames();
+        var expected =
+                new ArrayList<>(List.of("New Pipeline", "Another", "New Pipeline (1)", "Another (1)"));
+        for (int i = 2; i < 15; i++) {
+            expected.add("Another (" + i + ")");
+        }
+        Assertions.assertEquals(expected, nicks);
+    }
+}
diff --git a/photon-core/src/test/java/org/photonvision/vision/target/TrackedTargetTest.java b/photon-core/src/test/java/org/photonvision/vision/target/TrackedTargetTest.java
index 6723e41aa..5d4b2095f 100644
--- a/photon-core/src/test/java/org/photonvision/vision/target/TrackedTargetTest.java
+++ b/photon-core/src/test/java/org/photonvision/vision/target/TrackedTargetTest.java
@@ -45,6 +45,7 @@ public class TrackedTargetTest {
                         new Point(426.22, 302),
                         new Point(400, 302))); // gives contour with center of 426, 300
         Contour contour = new Contour(mat);
+
         var pTarget = new PotentialTarget(contour);
 
         var imageSize = new Size(800, 600);
@@ -61,7 +62,7 @@ public class TrackedTargetTest {
                         34.3,
                         imageSize.area());
 
-        var trackedTarget = new TrackedTarget(pTarget, setting);
+        var trackedTarget = new TrackedTarget(pTarget, setting, null);
         // TODO change these hardcoded values
         assertEquals(12.0, trackedTarget.getYaw(), 0.05, "Yaw was incorrect");
         assertEquals(0, trackedTarget.getPitch(), 0.05, "Pitch was incorrect");
diff --git a/photon-server/src/main/java/org/photonvision/Main.java b/photon-server/src/main/java/org/photonvision/Main.java
index 03e4416ab..6d8e11a6f 100644
--- a/photon-server/src/main/java/org/photonvision/Main.java
+++ b/photon-server/src/main/java/org/photonvision/Main.java
@@ -36,6 +36,7 @@ import org.photonvision.vision.camera.FileVisionSource;
 import org.photonvision.vision.opencv.CVMat;
 import org.photonvision.vision.opencv.ContourGroupingMode;
 import org.photonvision.vision.pipeline.CVPipelineSettings;
+import org.photonvision.vision.pipeline.ColoredShapePipelineSettings;
 import org.photonvision.vision.pipeline.PipelineProfiler;
 import org.photonvision.vision.pipeline.ReflectivePipelineSettings;
 import org.photonvision.vision.processes.VisionModule;
@@ -123,6 +124,16 @@ public class Main {
         collectedSources.add(fvs2019);
         collectedSources.add(fvs2020);
 
+        // Colored shape testing
+        var camConfShape =
+                new CameraConfiguration(
+                        "Shape",
+                        TestUtils.getPowercellImagePath(TestUtils.PowercellTestImages.kPowercell_test_1, true)
+                                .toString());
+        camConfShape.addPipelineSetting(new ColoredShapePipelineSettings());
+        var fvsShape = new FileVisionSource(camConfShape);
+        collectedSources.add(fvsShape);
+
         //                logger.info("Adding " + allSources.size() + " configs to VMM.");
         VisionModuleManager.getInstance().addSources(collectedSources).forEach(VisionModule::start);
         ConfigManager.getInstance().addCameraConfigurations(collectedSources);
diff --git a/photon-server/src/main/java/org/photonvision/server/SocketHandler.java b/photon-server/src/main/java/org/photonvision/server/SocketHandler.java
index dcc4936da..708444b98 100644
--- a/photon-server/src/main/java/org/photonvision/server/SocketHandler.java
+++ b/photon-server/src/main/java/org/photonvision/server/SocketHandler.java
@@ -26,6 +26,7 @@ import io.javalin.websocket.WsConnectContext;
 import io.javalin.websocket.WsContext;
 import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -183,8 +184,9 @@ public class SocketHandler {
                                 //                                var type = (PipelineType)
                                 // data.get("pipelineType");
                                 //                                var name = (String) data.get("pipelineName");
-                                var type = PipelineType.Reflective;
-                                var name = (String) entryValue;
+                                var arr = (ArrayList<Object>) entryValue;
+                                var name = (String) arr.get(0);
+                                var type = PipelineType.values()[(Integer) arr.get(1) + 2];
 
                                 var newPipelineEvent =
                                         new IncomingWebSocketEvent<>(
@@ -310,6 +312,18 @@ public class SocketHandler {
                                 }
                                 break;
                             }
+                        case SMT_CHANGEPIPELINETYPE:
+                            {
+                                var changePipelineEvent =
+                                        new IncomingWebSocketEvent<>(
+                                                DataChangeDestination.DCD_ACTIVEMODULE,
+                                                "changePipelineType",
+                                                (Integer) entryValue,
+                                                cameraIndex,
+                                                context);
+                                dcService.publishEvent(changePipelineEvent);
+                                break;
+                            }
                     }
                 } catch (Exception e) {
                     logger.error("Failed to parse message!", e);
diff --git a/photon-server/src/main/java/org/photonvision/server/SocketMessageType.java b/photon-server/src/main/java/org/photonvision/server/SocketMessageType.java
index c62fa6faa..ff5ba3a36 100644
--- a/photon-server/src/main/java/org/photonvision/server/SocketMessageType.java
+++ b/photon-server/src/main/java/org/photonvision/server/SocketMessageType.java
@@ -35,7 +35,8 @@ public enum SocketMessageType {
     SMT_TAKECALIBRATIONSNAPSHOT("takeCalibrationSnapshot"),
     SMT_DUPLICATEPIPELINE("duplicatePipeline"),
     SMT_CHANGEBRIGHTNESS("enabledLEDPercentage"),
-    SMT_ROBOTOFFSETPOINT("robotOffsetPoint");
+    SMT_ROBOTOFFSETPOINT("robotOffsetPoint"),
+    SMT_CHANGEPIPELINETYPE("pipelineType");
 
     public final String entryKey;
 
diff --git a/photon-server/src/main/resources/testimages/polygons/powercells/powercell_test_1.png b/photon-server/src/main/resources/testimages/polygons/powercells/powercell_test_1.png
new file mode 100644
index 000000000..83d22cb63
Binary files /dev/null and b/photon-server/src/main/resources/testimages/polygons/powercells/powercell_test_1.png differ